diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0be9712f..38ffec46 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -76,6 +76,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@5b842231ba77f5c045dba54ac5560fed2db780e2 # nightly
         with:
           toolchain: nightly
+          components: rustfmt
 
       - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
 
@@ -83,12 +84,22 @@ jobs:
         with:
           node-version: 22
 
-      - name: Install workspace deps
-        run: npm ci --ignore-scripts
-
+      # codegen.sh emits the gitignored generated TS first and only then
+      # installs/builds the npm workspace, so package `prepare` (tsc -b)
+      # scripts see the generated modules. Installing the workspace before
+      # codegen fails: npm runs the truapi-host-wasm prepare build against
+      # sources whose ./generated imports don't exist yet.
       - name: Run codegen
         run: ./scripts/codegen.sh
 
+      - name: Check committed Rust codegen output is current
+        run: git diff --exit-code -- rust/crates/truapi-server/src/generated
+
+      - name: Wire-table parity (Rust vs generated TS)
+        run: cargo test -p truapi-server --test wire_table_ts_parity
+        env:
+          TRUAPI_REQUIRE_GENERATED_TS: 1
+
       - name: Upload codegen output
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
@@ -101,6 +112,7 @@ jobs:
             js/packages/truapi/src/explorer/codegen
             js/packages/truapi/src/explorer/versions.ts
             js/packages/truapi-host/src/generated
+            js/packages/truapi-host-wasm/src/generated
             playground/test/generated
 
   ts-client:
@@ -219,60 +231,86 @@ jobs:
         run: npm run build
 
   e2e:
-    name: E2E (playground inside dotli)
-    # Temporarily disabled while the dotli playground smoke test is stabilized.
-    if: false
+    name: E2E (dotli playground diagnosis)
     runs-on: ubuntu-latest
     needs: playground
-    timeout-minutes: 30
+    timeout-minutes: 35
     env:
       TRUAPI_REQUIRE_GENERATED: 1
+      SIGNER_BOT_SVC_TOKEN: ${{ secrets.SIGNER_BOT_SVC_TOKEN }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          submodules: recursive
           persist-credentials: false
 
+      - name: Check dotli submodule access
+        id: dotli-access
+        env:
+          DOTLI_CHECKOUT_TOKEN: ${{ secrets.DOTLI_CHECKOUT_TOKEN }}
+        run: |
+          if [ -n "$DOTLI_CHECKOUT_TOKEN" ]; then
+            git config --global url."https://x-access-token:${DOTLI_CHECKOUT_TOKEN}@github.com/".insteadOf "https://github.com/"
+          fi
+          if git ls-remote https://github.com/paritytech/dotli.git >/dev/null 2>&1; then
+            echo "available=true" >> "$GITHUB_OUTPUT"
+            git submodule update --init --recursive hosts/dotli
+          else
+            echo "::warning::dotli submodule is not accessible to this workflow; skipping dotli e2e."
+            echo "available=false" >> "$GITHUB_OUTPUT"
+          fi
+
       - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        if: steps.dotli-access.outputs.available == 'true'
         with:
           node-version: 22
 
       - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        if: steps.dotli-access.outputs.available == 'true'
         with:
           bun-version: latest
 
+      - uses: dtolnay/rust-toolchain@5b842231ba77f5c045dba54ac5560fed2db780e2 # stable
+        if: steps.dotli-access.outputs.available == 'true'
+        with:
+          toolchain: stable
+
       - name: Download codegen output
+        if: steps.dotli-access.outputs.available == 'true'
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: codegen-output
 
-      - name: Build @parity/truapi
-        run: |
-          npm ci --ignore-scripts
-          npm run build --prefix js/packages/truapi
+      - name: Install wasm-pack
+        if: steps.dotli-access.outputs.available == 'true'
+        run: cargo install wasm-pack --version 0.14.0 --locked
 
       - name: Install dotli deps
+        if: steps.dotli-access.outputs.available == 'true'
         working-directory: hosts/dotli
         run: bun install --frozen-lockfile
 
-      - name: Install playground deps
-        working-directory: playground
-        run: yarn install --frozen-lockfile
-
       - name: Install Playwright browsers
-        working-directory: playground
-        run: npx playwright install --with-deps chromium
+        if: steps.dotli-access.outputs.available == 'true'
+        working-directory: hosts/dotli/apps/host
+        run: bunx playwright install --with-deps chromium
 
-      - name: Run Playwright e2e
-        working-directory: playground
-        run: yarn e2e
-
-      - name: Upload Playwright report
-        if: failure()
+      - name: Run dotli diagnosis e2e
+        if: steps.dotli-access.outputs.available == 'true'
+        run: |
+          if [ -n "$SIGNER_BOT_SVC_TOKEN" ]; then
+            make e2e-dotli
+          else
+            echo "::warning::SIGNER_BOT_SVC_TOKEN is unavailable; running QR smoke mode only."
+            E2E_DOTLI_SMOKE=1 make e2e-dotli
+          fi
+
+      - name: Upload dotli e2e results
+        if: always()
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: playwright-report
-          path: playground/playwright-report
+          name: dotli-e2e-results
+          path: hosts/dotli/test-results/e2e-dotli
+          if-no-files-found: ignore
           retention-days: 14
 
   ci-status:
diff --git a/.github/workflows/host-packages.yml b/.github/workflows/host-packages.yml
new file mode 100644
index 00000000..5d13d1f3
--- /dev/null
+++ b/.github/workflows/host-packages.yml
@@ -0,0 +1,71 @@
+name: host-packages
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'js/packages/truapi-host-wasm/**'
+      - 'rust/crates/truapi-server/**'
+      - 'rust/crates/truapi-platform/**'
+      - 'rust/crates/truapi-codegen/**'
+      - 'rust/crates/truapi-macros/**'
+      - 'rust/crates/truapi/**'
+  pull_request:
+    paths:
+      - 'js/packages/truapi-host-wasm/**'
+      - 'rust/crates/truapi-server/**'
+      - 'rust/crates/truapi-platform/**'
+      - 'rust/crates/truapi-codegen/**'
+      - 'rust/crates/truapi-macros/**'
+      - 'rust/crates/truapi/**'
+
+jobs:
+  wasm-bundle-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - name: Install wasm-pack
+        run: cargo install wasm-pack
+      # Builds the bundle from the current truapi-server source and runs the
+      # truapi-host-wasm node smoke test against those freshly-built artifacts.
+      # The dist/wasm/ artifacts are gitignored; every consumer (local dev via
+      # `make wasm`, CI here) builds them from the Rust source.
+      - name: Build WASM
+        run: make wasm
+      - name: Sanity-check artifact presence
+        run: |
+          test -s js/packages/truapi-host-wasm/dist/wasm/web/truapi_server_bg.wasm
+          test -s js/packages/truapi-host-wasm/dist/wasm/web/truapi_server.js
+          test -s js/packages/truapi-host-wasm/dist/wasm/node/truapi_server_bg.wasm
+          test -s js/packages/truapi-host-wasm/dist/wasm/node/truapi_server.js
+      - name: Build @parity/truapi-host (dep)
+        run: cd js/packages/truapi-host && npm install --no-fund --no-audit && npm run build
+      - name: Build @parity/truapi client (dep)
+        run: cd js/packages/truapi && npm install --no-fund --no-audit && npm run build
+      - name: Test @parity/truapi-host-wasm against the rebuilt bundle
+        run: cd js/packages/truapi-host-wasm && npm install --no-fund --no-audit && npm test
+  host-packages-js-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - name: Install wasm-pack
+        run: cargo install wasm-pack
+      # The truapi-host-wasm tests load dist/wasm/{web,node}, which is
+      # gitignored, so build it from the Rust source first.
+      - name: Build WASM
+        run: make wasm
+      - name: Build @parity/truapi-host (dep)
+        run: cd js/packages/truapi-host && npm install --no-fund --no-audit && npm run build
+      - name: Build @parity/truapi client (dep)
+        run: cd js/packages/truapi && npm install --no-fund --no-audit && npm run build
+      - name: Test @parity/truapi-host-wasm
+        run: cd js/packages/truapi-host-wasm && npm install --no-fund --no-audit && npm test
diff --git a/.gitignore b/.gitignore
index 9138e1a8..620568d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,12 @@ lerna-debug.log*
 node_modules
 target
 
+# Gradle (Android workspace at repo root)
+/.gradle/
+/build/
+/android/*/build/
+local.properties
+
 # Environment / secrets (never commit real env files; keep example templates)
 .env
 .env.*
@@ -39,3 +45,16 @@ playground/public/static.files
 
 # Auto-generated by truapi-codegen (typecheck fixtures for rustdoc ts blocks)
 playground/test/generated/
+
+# Auto-generated FFI / WASM binding outputs
+android/truapi-host/src/main/kotlin/generated/
+ios/truapi-host/Sources/TrUAPIHost/truapi_server.swift
+ios/truapi-host/Sources/truapi_serverFFI/
+rust/crates/truapi-server/pkg/
+js/packages/truapi/src/generated/
+js/packages/truapi/dist/generated/
+js/packages/truapi-host/src/generated/
+js/packages/truapi-host/dist/generated/
+js/packages/truapi-host-wasm/src/generated/
+js/packages/truapi-host-wasm/dist/generated/
+js/packages/truapi-host-wasm/dist/wasm/
diff --git a/Cargo.lock b/Cargo.lock
index 7bb9e809..40f8c40e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,68 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "addr2line"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -38,7 +100,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -49,7 +111,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -59,202 +121,198 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
-name = "arrayvec"
-version = "0.7.6"
+name = "arbitrary"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 
 [[package]]
-name = "bitvec"
-version = "1.0.1"
+name = "arrayref"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
-name = "byte-slice-cast"
-version = "1.2.3"
+name = "arrayvec"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
+checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9"
+dependencies = [
+ "nodrop",
+]
 
 [[package]]
-name = "clap"
-version = "4.6.1"
+name = "arrayvec"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
-name = "clap_builder"
-version = "4.6.0"
+name = "askama"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+checksum = "5d4744ed2eef2645831b441d8f5459689ade2ab27c854488fbab1fbe94fce1a7"
 dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
+ "askama_derive",
+ "itoa",
+ "percent-encoding",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "clap_derive"
-version = "4.6.1"
+name = "askama_derive"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
+checksum = "d661e0f57be36a5c14c48f78d09011e67e0cb618f269cca9f2fd8d15b68c46ac"
 dependencies = [
- "heck",
+ "askama_parser",
+ "basic-toml",
+ "memchr",
  "proc-macro2",
  "quote",
+ "rustc-hash",
+ "serde",
+ "serde_derive",
  "syn",
 ]
 
 [[package]]
-name = "clap_lex"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
-
-[[package]]
-name = "const_format"
-version = "0.2.36"
+name = "askama_parser"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e"
+checksum = "cf315ce6524c857bb129ff794935cf6d42c82a6cff60526fe2a63593de4d0d4f"
 dependencies = [
- "const_format_proc_macros",
- "konst",
+ "memchr",
+ "serde",
+ "serde_derive",
+ "winnow 0.7.15",
 ]
 
 [[package]]
-name = "const_format_proc_macros"
-version = "0.2.34"
+name = "async-channel"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "convert_case"
-version = "0.6.0"
+name = "async-executor"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
 dependencies = [
- "unicode-segmentation",
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
 ]
 
 [[package]]
-name = "convert_case"
-version = "0.10.0"
+name = "async-fs"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
 dependencies = [
- "unicode-segmentation",
+ "async-lock",
+ "blocking",
+ "futures-lite",
 ]
 
 [[package]]
-name = "derive_more"
-version = "2.1.1"
+name = "async-io"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 dependencies = [
- "derive_more-impl",
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix",
+ "slab",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "derive_more-impl"
-version = "2.1.1"
+name = "async-lock"
+version = "3.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 dependencies = [
- "convert_case 0.10.0",
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn",
- "unicode-xid",
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
-[[package]]
-name = "funty"
+name = "async-net"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "futures"
-version = "0.3.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
 dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
+ "async-io",
+ "blocking",
+ "futures-lite",
 ]
 
 [[package]]
-name = "futures-channel"
-version = "0.3.32"
+name = "async-process"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
 dependencies = [
- "futures-core",
- "futures-sink",
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix",
 ]
 
 [[package]]
-name = "futures-core"
-version = "0.3.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.32"
+name = "async-signal"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"
 dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
  "futures-core",
- "futures-task",
- "futures-util",
+ "futures-io",
+ "rustix",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "futures-io"
-version = "0.3.32"
+name = "async-task"
+version = "4.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
-name = "futures-macro"
-version = "0.3.32"
+name = "async-trait"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -262,399 +320,4107 @@ dependencies = [
 ]
 
 [[package]]
-name = "futures-sink"
-version = "0.3.32"
+name = "atomic-take"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+checksum = "a8ab6b55fe97976e46f91ddbed8d147d966475dc29b2032757ba47e02376fbc3"
 
 [[package]]
-name = "futures-task"
-version = "0.3.32"
+name = "atomic-waker"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
-name = "futures-util"
-version = "0.3.32"
+name = "autocfg"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "slab",
-]
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
-name = "hashbrown"
-version = "0.17.0"
+name = "base16ct"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
 [[package]]
-name = "heck"
-version = "0.5.0"
+name = "base32"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+checksum = "022dfe9eb35f19ebbcb51e0b40a5ab759f46ad60cadf7297e0bd085afb50e076"
 
 [[package]]
-name = "hex"
-version = "0.4.3"
+name = "base64"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
-name = "impl-trait-for-tuples"
-version = "0.2.3"
+name = "base64ct"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "basic-toml"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "serde",
 ]
 
 [[package]]
-name = "indexmap"
-version = "2.14.0"
+name = "bip39"
+version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc"
 dependencies = [
- "equivalent",
- "hashbrown",
+ "bitcoin_hashes",
 ]
 
 [[package]]
-name = "indoc"
-version = "2.0.7"
+name = "bitcoin_hashes"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b"
 dependencies = [
- "rustversion",
+ "hex-conservative",
 ]
 
 [[package]]
-name = "is_terminal_polyfill"
-version = "1.70.2"
+name = "bitflags"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
-name = "itoa"
-version = "1.0.18"
+name = "bitvec"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
 
 [[package]]
-name = "konst"
-version = "0.2.20"
+name = "blake2-rfc"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb"
+checksum = "5d6d530bdd2d52966a6d03b7a964add7ae1a288d25214066fd4b600f0f796400"
 dependencies = [
- "konst_macro_rules",
+ "arrayvec 0.4.12",
+ "constant_time_eq 0.1.5",
 ]
 
 [[package]]
-name = "konst_macro_rules"
-version = "0.2.19"
+name = "blake2b_simd"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
+checksum = "b79834656f71332577234b50bfc009996f7449e0c056884e6a02492ded0ca2f3"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.6",
+ "constant_time_eq 0.4.2",
+]
 
 [[package]]
-name = "memchr"
-version = "2.8.0"
+name = "block-buffer"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+dependencies = [
+ "generic-array",
+]
 
 [[package]]
-name = "once_cell_polyfill"
-version = "1.70.2"
+name = "block-buffer"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+dependencies = [
+ "allocator-api2",
+]
+
+[[package]]
+name = "byte-slice-cast"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.2.62"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "clap"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const_format"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e"
+dependencies = [
+ "const_format_proc_macros",
+ "konst",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+
+[[package]]
+name = "constant_time_eq"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cranelift-assembler-x64"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44f81cede359311706057b689b91b59f464926de0316f389898a2b028cb494fa"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+]
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa6ca11305de425ea08884097b913ebe1a83875253b3c0063ce28411e226bfdc"
+dependencies = [
+ "cranelift-srcgen",
+]
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7537341a9a4ba9812141927be733e7254bf2318aab6597d567af9cad90609f27"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-bitset"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d28a4ca5faf25ff821fcc768f26e68ffef505e9f71bb06e608862d941fa65086"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d891057fe1b73910c41e73b32a70fa8454092fce65942b5fa6f72aa6d5487f8a"
+dependencies = [
+ "bumpalo",
+ "cranelift-assembler-x64",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli",
+ "hashbrown 0.15.5",
+ "log",
+ "pulley-interpreter",
+ "regalloc2",
+ "rustc-hash",
+ "serde",
+ "smallvec",
+ "target-lexicon",
+ "wasmtime-internal-math",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c29a66028a78eedc534b3a94e5ebfbaeb4e1f6b09038afe41bb24afd614faa4b"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+ "cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck",
+ "pulley-interpreter",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95809ad251fe9422087b4a72d61e584d6ab6eff44dee1335f93cfaea0bedc9ac"
+
+[[package]]
+name = "cranelift-control"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f79d0cacf063c297e5e8d5b73cb355b41b87f6d248e252d1b284e7a7b73673c2"
+dependencies = [
+ "arbitrary",
+]
+
+[[package]]
+name = "cranelift-entity"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2d73297a195ce3be55997c6307142c4b1e58dd0c2f18ceaa0179444024e312a"
+dependencies = [
+ "cranelift-bitset",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be38d1ae29ef7c5d611fc6cb694f698dc4ca44152dcaa112ec0fef8d4d34858"
+dependencies = [
+ "cranelift-codegen",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-isle"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6761926f6636209de7ac568be28b206890f2181761375b9722e0a1e7a7e1637a"
+
+[[package]]
+name = "cranelift-native"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0893472f73f0d530a28e9a573ada6d1f93b9659bb6734dfe17061ac967bd1830"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-srcgen"
+version = "0.123.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1daccebabb1ccd034dbab0eacc0722af27d3cccc7929dea27a3546cb3562e40"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "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",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-mac"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
+dependencies = [
+ "generic-array",
+ "subtle",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "rustc_version",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case 0.10.0",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "ed25519"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
+dependencies = [
+ "pkcs8",
+ "signature",
+]
+
+[[package]]
+name = "ed25519-zebra"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "775765289f7c6336c18d3d66127527820dd45ffd9eb3b6b8ee4708590e6c20f5"
+dependencies = [
+ "curve25519-dalek",
+ "ed25519",
+ "hashbrown 0.16.1",
+ "pkcs8",
+ "rand_core",
+ "sha2 0.10.9",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest 0.10.7",
+ "ff",
+ "generic-array",
+ "group",
+ "hkdf",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fastbloom"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef975e30683b2d965054bb0a836f8973857c4ebf6acf274fe46617cd285060d8"
+dependencies = [
+ "foldhash 0.2.0",
+ "libm",
+ "portable-atomic",
+ "siphasher 1.0.3",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "ff"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+dependencies = [
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs-err"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a41f105fe1d5b6b34b2055e3dc59bb79b46b48b2040b9e6c7b4b5de097aa41"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+dependencies = [
+ "gloo-timers",
+ "send_wrapper 0.4.0",
+]
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "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",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "getrandom_or_panic"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea1015b5a70616b688dc230cfe50c8af89d972cb132d5a622814d29773b10b9"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
+[[package]]
+name = "gimli"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+dependencies = [
+ "fallible-iterator",
+ "indexmap",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gloo-timers"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "goblin"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b363a30c165f666402fe6a3024d3bec7ebc898f96a4a23bd1c99f8dbf3f4f47"
+dependencies = [
+ "log",
+ "plain",
+ "scroll",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+ "serde",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
+[[package]]
+name = "hashlink"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
+dependencies = [
+ "arrayvec 0.7.6",
+]
+
+[[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 = "hmac"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840"
+dependencies = [
+ "crypto-mac",
+ "digest 0.9.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]]
+name = "hmac-drbg"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17ea0a1394df5b6574da6e0c1ade9e78868c9fb0a4e5ef4428e32da4676b85b1"
+dependencies = [
+ "digest 0.9.0",
+ "generic-array",
+ "hmac 0.8.1",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "impl-trait-for-tuples"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[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 = "js-sys"
+version = "0.3.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "konst"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb"
+dependencies = [
+ "konst_macro_rules",
+]
+
+[[package]]
+name = "konst_macro_rules"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libsecp256k1"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e79019718125edc905a079a70cfa5f3820bc76139fc91d6f9abc27ea2a887139"
+dependencies = [
+ "arrayref",
+ "base64",
+ "digest 0.9.0",
+ "hmac-drbg",
+ "libsecp256k1-core",
+ "libsecp256k1-gen-ecmult",
+ "libsecp256k1-gen-genmult",
+ "rand",
+ "serde",
+ "sha2 0.9.9",
+ "typenum",
+]
+
+[[package]]
+name = "libsecp256k1-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be9b9bb642d8522a44d533eab56c16c738301965504753b03ad1de3425d5451"
+dependencies = [
+ "crunchy",
+ "digest 0.9.0",
+ "subtle",
+]
+
+[[package]]
+name = "libsecp256k1-gen-ecmult"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3038c808c55c87e8a172643a7d87187fc6c4174468159cb3090659d55bcb4809"
+dependencies = [
+ "libsecp256k1-core",
+]
+
+[[package]]
+name = "libsecp256k1-gen-genmult"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db8d6ba2cec9eacc40e6e8ccc98931840301f1006e95647ceb2dd5c3aa06f7c"
+dependencies = [
+ "libsecp256k1-core",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "mach2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memfd"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad38eb12aea514a0466ea40a80fd8cc83637065948eb4a426e4aa46261175227"
+dependencies = [
+ "rustix",
+]
+
+[[package]]
+name = "merlin"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d"
+dependencies = [
+ "byteorder",
+ "keccak",
+ "rand_core",
+ "zeroize",
+]
+
+[[package]]
+name = "minicov"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d"
+dependencies = [
+ "cc",
+ "walkdir",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "multi-stash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685a9ac4b61f4e728e1d2c6a7844609c16527aeb5e6c865915c08e619c16410f"
+
+[[package]]
+name = "nodrop"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "p256"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"
+dependencies = [
+ "elliptic-curve",
+ "primeorder",
+]
 
 [[package]]
 name = "parity-scale-codec"
 version = "3.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa"
+checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa"
+dependencies = [
+ "arrayvec 0.7.6",
+ "bitvec",
+ "byte-slice-cast",
+ "const_format",
+ "impl-trait-for-tuples",
+ "parity-scale-codec-derive",
+ "rustversion",
+ "serde",
+]
+
+[[package]]
+name = "parity-scale-codec-derive"
+version = "3.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "serde",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "primeorder"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
+dependencies = [
+ "elliptic-curve",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pulley-interpreter"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b78fdec962b639b921badfcfe77db7d18aa3c0c1e292ac2aa268c0efe8fe683"
+dependencies = [
+ "cranelift-bitset",
+ "log",
+ "pulley-macros",
+ "wasmtime-internal-math",
+]
+
+[[package]]
+name = "pulley-macros"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f718f4e8cd5fdfa08b3b1d2d25fe288350051be330544305f0a9b93a937b3d42"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[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",
+]
+
+[[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]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regalloc2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5216b1837de2149f8bc8e6d5f88a9326b63b8c836ed58ce4a0a29ec736a59734"
+dependencies = [
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.15.5",
+ "log",
+ "rustc-hash",
+ "smallvec",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.32.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ruzstd"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7c1c839d570d835527c9a5e4db7cb2198683a988cb9d7293fc8674e6bd58fc8"
+
+[[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 = "schnorrkel"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9fcb6c2e176e86ec703e22560d99d65a5ee9056ae45a08e13e84ebf796296f"
+dependencies = [
+ "aead",
+ "arrayref",
+ "arrayvec 0.7.6",
+ "curve25519-dalek",
+ "getrandom_or_panic",
+ "merlin",
+ "rand_core",
+ "serde_bytes",
+ "sha2 0.10.9",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scroll"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ab8598aa408498679922eff7fa985c25d58a90771bd6be794434c5277eab1a6"
+dependencies = [
+ "scroll_derive",
+]
+
+[[package]]
+name = "scroll_derive"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "send_wrapper"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f638d531eccd6e23b980caf34876660d38e265409d8e99b397ab71eb3612fad0"
+
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
+dependencies = [
+ "block-buffer 0.9.0",
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.9.0",
+ "opaque-debug",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874"
+dependencies = [
+ "digest 0.10.7",
+ "keccak",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "siphasher"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "smawk"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
+
+[[package]]
+name = "smol"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33bd3e260892199c3ccfc487c88b2da2265080acb316cd920da72fdfd7c599f"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-fs",
+ "async-io",
+ "async-lock",
+ "async-net",
+ "async-process",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "smoldot"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b22238c3655a9e66285b5fc1a59aa914a3c09160caf5b9604f8c11de787d77f"
+dependencies = [
+ "arrayvec 0.7.6",
+ "async-lock",
+ "atomic-take",
+ "base32",
+ "base64",
+ "bip39",
+ "blake2-rfc",
+ "bs58",
+ "chacha20",
+ "crossbeam-queue",
+ "derive_more",
+ "ed25519-zebra",
+ "either",
+ "event-listener",
+ "fastbloom",
+ "fnv",
+ "futures-lite",
+ "futures-util",
+ "hashbrown 0.16.1",
+ "hex",
+ "hmac 0.12.1",
+ "itertools",
+ "libm",
+ "libsecp256k1",
+ "merlin",
+ "nom 8.0.0",
+ "num-bigint",
+ "num-rational",
+ "num-traits",
+ "parking_lot",
+ "pbkdf2",
+ "pin-project",
+ "poly1305",
+ "rand",
+ "rand_chacha",
+ "rusqlite",
+ "ruzstd",
+ "schnorrkel",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "sha3",
+ "siphasher 1.0.3",
+ "slab",
+ "smallvec",
+ "soketto",
+ "twox-hash 2.1.2",
+ "wasmi",
+ "wasmtime",
+ "x25519-dalek",
+ "zeroize",
+]
+
+[[package]]
+name = "smoldot-light"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ec52700b57df3f2a031873c5de7d44f2f8abae54b622ccf15ad9bc7c05a7c2"
+dependencies = [
+ "async-channel",
+ "async-lock",
+ "base64",
+ "blake2-rfc",
+ "bs58",
+ "derive_more",
+ "either",
+ "event-listener",
+ "fnv",
+ "futures-channel",
+ "futures-lite",
+ "futures-util",
+ "hashbrown 0.16.1",
+ "hex",
+ "itertools",
+ "log",
+ "lru",
+ "parking_lot",
+ "pin-project",
+ "rand",
+ "rand_chacha",
+ "serde",
+ "serde_json",
+ "siphasher 1.0.3",
+ "slab",
+ "smol",
+ "smoldot",
+ "zeroize",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soketto"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e859df029d160cb88608f5d7df7fb4753fd20fdfb4de5644f3d8b8440841721"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures",
+ "httparse",
+ "log",
+ "rand",
+ "sha1",
+]
+
+[[package]]
+name = "sp-crypto-hashing"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc9927a7f81334ed5b8a98a4a978c81324d12bd9713ec76b5c68fd410174c5eb"
+dependencies = [
+ "blake2b_simd",
+ "byteorder",
+ "digest 0.10.7",
+ "sha2 0.10.9",
+ "sha3",
+ "twox-hash 1.6.3",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "static_assertions"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
+dependencies = [
+ "smawk",
+]
+
+[[package]]
+name = "thiserror"
+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.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.11+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "sharded-slab",
+ "thread_local",
+ "tracing-core",
+]
+
+[[package]]
+name = "truapi"
+version = "0.3.0"
+dependencies = [
+ "derive_more",
+ "futures",
+ "hex",
+ "parity-scale-codec",
+ "truapi-macros",
+]
+
+[[package]]
+name = "truapi-codegen"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "convert_case 0.6.0",
+ "indoc",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "truapi",
+]
+
+[[package]]
+name = "truapi-macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "truapi-platform"
+version = "0.1.0"
+dependencies = [
+ "futures",
+ "truapi",
+ "url",
+]
+
+[[package]]
+name = "truapi-server"
+version = "0.1.0"
+dependencies = [
+ "aes-gcm",
+ "async-trait",
+ "blake2-rfc",
+ "bs58",
+ "console_error_panic_hook",
+ "derive_more",
+ "futures",
+ "futures-timer",
+ "futures-util",
+ "getrandom 0.2.17",
+ "hex",
+ "hkdf",
+ "js-sys",
+ "p256",
+ "parity-scale-codec",
+ "pin-project",
+ "rand",
+ "schnorrkel",
+ "send_wrapper 0.6.0",
+ "serde_json",
+ "sha2 0.10.9",
+ "smoldot",
+ "smoldot-light",
+ "sp-crypto-hashing",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-tungstenite",
+ "tracing",
+ "tracing-subscriber",
+ "truapi",
+ "truapi-platform",
+ "unicode-normalization",
+ "uniffi",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-bindgen-test",
+ "web-sys",
+ "web-time",
+]
+
+[[package]]
+name = "tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+ "static_assertions",
+]
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "typenum"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "uniffi"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3291800a6b06569f7d3e15bdb6dc235e0f0c8bd3eb07177f430057feb076415f"
+dependencies = [
+ "anyhow",
+ "cargo_metadata",
+ "uniffi_bindgen",
+ "uniffi_core",
+ "uniffi_macros",
+ "uniffi_pipeline",
+]
+
+[[package]]
+name = "uniffi_bindgen"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a04b99fa7796eaaa7b87976a0dbdd1178dc1ee702ea00aca2642003aef9b669e"
+dependencies = [
+ "anyhow",
+ "askama",
+ "camino",
+ "cargo_metadata",
+ "fs-err",
+ "glob",
+ "goblin",
+ "heck",
+ "indexmap",
+ "once_cell",
+ "serde",
+ "tempfile",
+ "textwrap",
+ "toml",
+ "uniffi_internal_macros",
+ "uniffi_meta",
+ "uniffi_pipeline",
+ "uniffi_udl",
+]
+
+[[package]]
+name = "uniffi_core"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38a9a27529ccff732f8efddb831b65b1e07f7dea3fd4cacd4a35a8c4b253b98"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "once_cell",
+ "static_assertions",
+]
+
+[[package]]
+name = "uniffi_internal_macros"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09acd2ce09c777dd65ee97c251d33c8a972afc04873f1e3b21eb3492ade16933"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "uniffi_macros"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5596f178c4f7aafa1a501c4e0b96236a96bc2ef92bdb453d83e609dad0040152"
+dependencies = [
+ "camino",
+ "fs-err",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn",
+ "toml",
+ "uniffi_meta",
+]
+
+[[package]]
+name = "uniffi_meta"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "beadc1f460eb2e209263c49c4f5b19e9a02e00a3b2b393f78ad10d766346ecff"
 dependencies = [
- "arrayvec",
- "bitvec",
- "byte-slice-cast",
- "const_format",
- "impl-trait-for-tuples",
- "parity-scale-codec-derive",
+ "anyhow",
+ "siphasher 0.3.11",
+ "uniffi_internal_macros",
+ "uniffi_pipeline",
+]
+
+[[package]]
+name = "uniffi_pipeline"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd76b3ac8a2d964ca9fce7df21c755afb4c77b054a85ad7a029ad179cc5abb8a"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "tempfile",
+ "uniffi_internal_macros",
+]
+
+[[package]]
+name = "uniffi_udl"
+version = "0.29.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4319cf905911d70d5b97ce0f46f101619a22e9a189c8c46d797a9955e9233716"
+dependencies = [
+ "anyhow",
+ "textwrap",
+ "uniffi_meta",
+ "weedle2",
+]
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[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 = "wasi"
+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.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790"
+dependencies = [
+ "cfg-if",
+ "once_cell",
  "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96492d0d3ffba25305a7dc88720d250b1401d7edca02cc3bcd50633b424673b8"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-bindgen-test"
+version = "0.3.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af5ec93229ad9ccd0a545a516dec76dc276613f278f6a91aa6b463d5b33d42d0"
+dependencies = [
+ "async-trait",
+ "cast",
+ "js-sys",
+ "libm",
+ "minicov",
+ "nu-ansi-term",
+ "num-traits",
+ "oorandom",
  "serde",
+ "serde_json",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-bindgen-test-macro",
+ "wasm-bindgen-test-shared",
 ]
 
 [[package]]
-name = "parity-scale-codec-derive"
-version = "3.7.5"
+name = "wasm-bindgen-test-macro"
+version = "0.3.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c81b9fef827e575e0e54431736d1baa0d700315d8c62cfef1f61fa3aad0cbeb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "wasm-bindgen-test-shared"
+version = "0.2.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f4d8ae7ad5440360e9799dfd42857d126454a88441ddf72d288ef83fa47f527"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.236.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "724fccfd4f3c24b7e589d333fc0429c68042897a7e8a5f8694f31792471841e7"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.236.1",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder 0.244.0",
+ "wasmparser 0.244.0",
+]
+
+[[package]]
+name = "wasmi"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19af97fcb96045dd1d6b4d23e2b4abdbbe81723dbc5c9f016eb52145b320063"
+dependencies = [
+ "arrayvec 0.7.6",
+ "multi-stash",
+ "smallvec",
+ "spin",
+ "wasmi_collections",
+ "wasmi_core",
+ "wasmi_ir",
+ "wasmparser 0.221.3",
+]
+
+[[package]]
+name = "wasmi_collections"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e80d6b275b1c922021939d561574bf376613493ae2b61c6963b15db0e8813562"
+
+[[package]]
+name = "wasmi_core"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8c51482cc32d31c2c7ff211cd2bedd73c5bd057ba16a2ed0110e7a96097c33"
+dependencies = [
+ "downcast-rs",
+ "libm",
+]
+
+[[package]]
+name = "wasmi_ir"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e431a14c186db59212a88516788bd68ed51f87aa1e08d1df742522867b5289a"
+dependencies = [
+ "wasmi_core",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.236.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9b1e81f3eb254cf7404a82cee6926a4a3ccc5aad80cc3d43608a070c67aa1d7"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+ "serde",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "wasmprinter"
+version = "0.236.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2df225df06a6df15b46e3f73ca066ff92c2e023670969f7d50ce7d5e695abbb1"
+dependencies = [
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.236.1",
+]
+
+[[package]]
+name = "wasmtime"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b10306ead921db2c4645ff99867b7539b65e18afd8816d471547f5e6f3b09492"
+dependencies = [
+ "addr2line",
+ "anyhow",
+ "async-trait",
+ "bitflags",
+ "bumpalo",
+ "cc",
+ "cfg-if",
+ "encoding_rs",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "libc",
+ "log",
+ "mach2",
+ "memfd",
+ "object",
+ "once_cell",
+ "postcard",
+ "pulley-interpreter",
+ "rustix",
+ "semver",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "target-lexicon",
+ "wasmparser 0.236.1",
+ "wasmtime-environ",
+ "wasmtime-internal-asm-macros",
+ "wasmtime-internal-component-macro",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-cranelift",
+ "wasmtime-internal-fiber",
+ "wasmtime-internal-jit-debug",
+ "wasmtime-internal-jit-icache-coherence",
+ "wasmtime-internal-math",
+ "wasmtime-internal-slab",
+ "wasmtime-internal-unwinder",
+ "wasmtime-internal-versioned-export-macros",
+ "wasmtime-internal-winch",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "wasmtime-environ"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7fb2c37ca263d444f33871bf0221e7de0707b2b2bb88165df6db6d58c73375f"
+dependencies = [
+ "anyhow",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli",
+ "indexmap",
+ "log",
+ "object",
+ "postcard",
+ "semver",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "target-lexicon",
+ "wasm-encoder 0.236.1",
+ "wasmparser 0.236.1",
+ "wasmprinter",
+ "wasmtime-internal-component-util",
+]
+
+[[package]]
+name = "wasmtime-internal-asm-macros"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19c6c0d3c8d2db554a3af8e8d413ff2815362ebce0911808ecfdaaa257438f93"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "wasmtime-internal-component-macro"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e3f3752466eb0e1f97149e53bf15c0e18ff520fc0a98b4bee1680e6de1c6f0"
+dependencies = [
+ "anyhow",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-wit-bindgen",
+ "wit-parser 0.236.1",
+]
+
+[[package]]
+name = "wasmtime-internal-component-util"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f54018baf62f4e9c616c31f2aeadcf0c202ff691a390ad53e291ae7160b169e"
+
+[[package]]
+name = "wasmtime-internal-cranelift"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a2412f2afb0a5db2a4ac1cfff73247e240aeaa90bf41497ad0a5084b6a24eca"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cranelift-codegen",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "gimli",
+ "itertools",
+ "log",
+ "object",
+ "pulley-interpreter",
+ "smallvec",
+ "target-lexicon",
+ "thiserror 2.0.18",
+ "wasmparser 0.236.1",
+ "wasmtime-environ",
+ "wasmtime-internal-math",
+ "wasmtime-internal-versioned-export-macros",
+]
+
+[[package]]
+name = "wasmtime-internal-fiber"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecfdc460dd5d343d88ff1ffaf65ae019feeb6124ddcfd3f39d28331068d25b1f"
+dependencies = [
+ "anyhow",
+ "cc",
+ "cfg-if",
+ "libc",
+ "rustix",
+ "wasmtime-internal-asm-macros",
+ "wasmtime-internal-versioned-export-macros",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "wasmtime-internal-jit-debug"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5abb428a71827b7f90fc64406749883ccc6e58addf6d36974d5e06942011707"
+dependencies = [
+ "cc",
+ "wasmtime-internal-versioned-export-macros",
+]
+
+[[package]]
+name = "wasmtime-internal-jit-icache-coherence"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba6cc13f14c3fb83fb877cb1d5c605e93f7ec1bf7fc1a5e8b361209d2f8ca028"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "wasmtime-internal-math"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cb209473a09f4dbd9c87bb9f18b8dcb0c9da30d12a260e3eacf7a1a53b41480"
+dependencies = [
+ "libm",
+]
+
+[[package]]
+name = "wasmtime-internal-slab"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aab4df5a04752106e1ecef9d40145ef28fa033b0d5dd3c839c9b208b2d522183"
+
+[[package]]
+name = "wasmtime-internal-unwinder"
+version = "36.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5359875d29bddb6f7e65e698157714d8d35ebd8ea2a92893d05d6b062147b639"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cranelift-codegen",
+ "log",
+ "object",
+]
+
+[[package]]
+name = "wasmtime-internal-versioned-export-macros"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a"
+checksum = "2e247bcdd69701743ba386c933b26ebad2ce912ff9cb68b5b71fdb29d39ba04a"
 dependencies = [
- "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
-name = "pin-project-lite"
-version = "0.2.17"
+name = "wasmtime-internal-winch"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+checksum = "d0298dfd9f57588222b5a92dcffe75894f1ead4e519850f176bde7fcfd105d54"
+dependencies = [
+ "anyhow",
+ "cranelift-codegen",
+ "gimli",
+ "object",
+ "target-lexicon",
+ "wasmparser 0.236.1",
+ "wasmtime-environ",
+ "wasmtime-internal-cranelift",
+ "winch-codegen",
+]
 
 [[package]]
-name = "proc-macro-crate"
-version = "3.5.0"
+name = "wasmtime-internal-wit-bindgen"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+checksum = "1706803e83b9bae726a0f55e7c1bbf78a7421cf2da68c940c70978e91dfc0339"
 dependencies = [
- "toml_edit",
+ "anyhow",
+ "bitflags",
+ "heck",
+ "indexmap",
+ "wit-parser 0.236.1",
 ]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.106"
+name = "web-sys"
+version = "0.3.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+checksum = "4b572dff8bcf38bad0fa19729c89bb5748b2b9b1d8be70cf90df697e3a8f32aa"
 dependencies = [
- "unicode-ident",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "quote"
-version = "1.0.45"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
- "proc-macro2",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "radium"
-version = "0.7.0"
+name = "weedle2"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+checksum = "998d2c24ec099a87daf9467808859f9d82b61f1d9c9701251aea037f514eae0e"
+dependencies = [
+ "nom 7.1.3",
+]
 
 [[package]]
-name = "rustc_version"
-version = "0.4.1"
+name = "winapi-util"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "semver",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "rustversion"
-version = "1.0.22"
+name = "winch-codegen"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+checksum = "2e2d7ea2137be52644d9c42ca5a4899bba07c2ed2db1e66c4c1994adfe35d39e"
+dependencies = [
+ "anyhow",
+ "cranelift-assembler-x64",
+ "cranelift-codegen",
+ "gimli",
+ "regalloc2",
+ "smallvec",
+ "target-lexicon",
+ "thiserror 2.0.18",
+ "wasmparser 0.236.1",
+ "wasmtime-environ",
+ "wasmtime-internal-cranelift",
+ "wasmtime-internal-math",
+]
 
 [[package]]
-name = "semver"
-version = "1.0.28"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
-name = "serde"
-version = "1.0.228"
+name = "windows-sys"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "serde_core",
- "serde_derive",
+ "windows-targets",
 ]
 
 [[package]]
-name = "serde_core"
-version = "1.0.228"
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "serde_derive",
+ "windows-link",
 ]
 
 [[package]]
-name = "serde_derive"
-version = "1.0.228"
+name = "windows-targets"
+version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "windows-link",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
-name = "serde_json"
-version = "1.0.149"
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 dependencies = [
- "itoa",
  "memchr",
- "serde",
- "serde_core",
- "zmij",
 ]
 
 [[package]]
-name = "slab"
-version = "0.4.12"
+name = "winnow"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
-name = "strsim"
-version = "0.11.1"
+name = "wit-bindgen"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
 
 [[package]]
-name = "syn"
-version = "2.0.117"
+name = "wit-bindgen"
+version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser 0.244.0",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
 dependencies = [
+ "anyhow",
+ "prettyplease",
  "proc-macro2",
  "quote",
- "unicode-ident",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
 ]
 
 [[package]]
-name = "tap"
-version = "1.0.1"
+name = "wit-component"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder 0.244.0",
+ "wasm-metadata",
+ "wasmparser 0.244.0",
+ "wit-parser 0.244.0",
+]
 
 [[package]]
-name = "toml_datetime"
-version = "1.1.1+spec-1.1.0"
+name = "wit-parser"
+version = "0.236.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+checksum = "16e4833a20cd6e85d6abfea0e63a399472d6f88c6262957c17f546879a80ba15"
 dependencies = [
- "serde_core",
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.236.1",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.25.11+spec-1.1.0"
+name = "wit-parser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
+ "anyhow",
+ "id-arena",
  "indexmap",
- "toml_datetime",
- "toml_parser",
- "winnow",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "toml_parser"
-version = "1.1.2+spec-1.1.0"
+name = "writeable"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
 dependencies = [
- "winnow",
+ "tap",
 ]
 
 [[package]]
-name = "truapi"
-version = "0.3.0"
+name = "x25519-dalek"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
- "derive_more",
- "futures",
- "hex",
- "parity-scale-codec",
- "truapi-macros",
+ "curve25519-dalek",
+ "rand_core",
+ "serde",
+ "zeroize",
 ]
 
 [[package]]
-name = "truapi-codegen"
-version = "0.1.0"
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
 dependencies = [
- "anyhow",
- "clap",
- "convert_case 0.6.0",
- "indoc",
- "serde",
- "serde_json",
- "truapi",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
 ]
 
 [[package]]
-name = "truapi-macros"
-version = "0.1.0"
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
+ "synstructure",
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.24"
+name = "zerocopy"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
 
 [[package]]
-name = "unicode-segmentation"
-version = "1.13.2"
+name = "zerocopy-derive"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.6"
+name = "zerofrom"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
 
 [[package]]
-name = "utf8parse"
-version = "0.2.2"
+name = "zerofrom-derive"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
 
 [[package]]
-name = "windows-link"
-version = "0.2.1"
+name = "zeroize"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
 
 [[package]]
-name = "windows-sys"
-version = "0.61.2"
+name = "zeroize_derive"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
- "windows-link",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
-name = "winnow"
-version = "1.0.2"
+name = "zerotrie"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
 dependencies = [
- "memchr",
+ "displaydoc",
+ "yoke",
+ "zerofrom",
 ]
 
 [[package]]
-name = "wyz"
-version = "0.5.1"
+name = "zerovec"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
 dependencies = [
- "tap",
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
diff --git a/Makefile b/Makefile
index c8bc371c..a24ed9df 100644
--- a/Makefile
+++ b/Makefile
@@ -3,12 +3,23 @@
 # Run `make help` for the list of targets.
 
 .DEFAULT_GOAL := help
-.PHONY: help setup build codegen test check playground dev matrix explorer
+.PHONY: help setup build codegen test check playground wasm wasm-crypto-test uniffi android-publish-local dev dev-bootstrap dev-link-check e2e-dotli matrix explorer
 
 TRUAPI_PKG := js/packages/truapi
 PLAYGROUND := playground
+JS_PACKAGES := js/packages
 EXPLORER := explorer
 DOTLI := hosts/dotli
+HOST_WASM_PKG := $(JS_PACKAGES)/truapi-host-wasm
+HOST_WASM_GENERATED := $(HOST_WASM_PKG)/src/generated/host-callbacks.ts
+HOST_WASM_WEB := $(HOST_WASM_PKG)/dist/wasm/web/truapi_server.js
+HOST_WASM_NODE := $(HOST_WASM_PKG)/dist/wasm/node/truapi_server.js
+DOTLI_UI := $(DOTLI)/packages/ui
+DOTLI_HOST_WASM_LINK := $(DOTLI_UI)/node_modules/@parity/truapi-host-wasm
+SIGNER_BOT_BASE_URL ?= https://signing-bot-dev.novasama-tech.org/
+SIGNER_BOT_NETWORK ?= paseo-next-v2
+export SIGNER_BOT_BASE_URL
+export SIGNER_BOT_NETWORK
 
 # `make dev DEBUG=1` runs dotli with VITE_APP_DEBUG=true to log every wire frame.
 DOTLI_PREVIEW := preview
@@ -18,31 +29,77 @@ endif
 
 help: ## Show this help.
 	@awk 'BEGIN { FS = ":.*##"; printf "Usage: make <target>\n\nTargets:\n" } \
-	      /^[a-zA-Z_-]+:.*?##/ { printf "  %-12s %s\n", $$1, $$2 }' $(MAKEFILE_LIST)
+	      /^[a-zA-Z0-9_-]+:.*?##/ { printf "  %-12s %s\n", $$1, $$2 }' $(MAKEFILE_LIST)
 
-setup: ## First-time setup: submodules + JS dependencies.
+setup: ## First-time setup: submodules, JS dependencies, generated artifacts.
 	git submodule update --init --recursive
-	cd $(TRUAPI_PKG) && npm install
+	# --ignore-scripts: the workspace `prepare` builds need generated sources
+	# that only exist after codegen.sh, which also builds the packages.
+	npm ci --ignore-scripts
+	./scripts/codegen.sh
 	cd $(PLAYGROUND) && yarn install --frozen-lockfile
+	cd $(DOTLI) && bun install --frozen-lockfile
 
 build: ## Build the Rust workspace and the TypeScript client.
 	cargo build --workspace
 	cd $(TRUAPI_PKG) && npm run build
+	cd $(HOST_WASM_PKG) && npm run build
 
-codegen: ## Regenerate the TypeScript client from the Rust crate.
+codegen: ## Regenerate generated TS/Rust artifacts from the Rust crates.
 	./scripts/codegen.sh
 	cd $(PLAYGROUND) && rm -rf node_modules/@parity && yarn install
 
+wasm: ## Rebuild the truapi-server WASM artifacts under js/packages/truapi-host-wasm/dist/wasm/.
+	cd $(HOST_WASM_PKG) && npm run build:wasm
+
+wasm-crypto-test: ## Run crypto/vector tests on wasm32 via wasm-pack/node.
+	wasm-pack test --node rust/crates/truapi-server --test wasm_crypto_vectors --no-default-features
+
+UNIFFI_CDYLIB_DIR := target/release
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+UNIFFI_CDYLIB := $(UNIFFI_CDYLIB_DIR)/libtruapi_server.dylib
+else
+UNIFFI_CDYLIB := $(UNIFFI_CDYLIB_DIR)/libtruapi_server.so
+endif
+
+UNIFFI_SWIFT_TMP := target/uniffi-swift-out
+
+uniffi: ## Regenerate Kotlin + Swift bindings from truapi-server cdylib.
+	cargo build -p truapi-server --release --features ws-bridge
+	cargo run -p uniffi-bindgen-cli -- generate \
+		--library $(UNIFFI_CDYLIB) \
+		--language kotlin \
+		--out-dir android/truapi-host/src/main/kotlin/generated
+	rm -rf $(UNIFFI_SWIFT_TMP)
+	mkdir -p $(UNIFFI_SWIFT_TMP)
+	cargo run -p uniffi-bindgen-cli -- generate \
+		--library $(UNIFFI_CDYLIB) \
+		--language swift \
+		--out-dir $(UNIFFI_SWIFT_TMP)
+	mkdir -p ios/truapi-host/Sources/truapi_serverFFI/include
+	cp $(UNIFFI_SWIFT_TMP)/truapi_server.swift \
+		ios/truapi-host/Sources/TrUAPIHost/truapi_server.swift
+	cp $(UNIFFI_SWIFT_TMP)/truapi_serverFFI.h \
+		ios/truapi-host/Sources/truapi_serverFFI/include/truapi_serverFFI.h
+	cp $(UNIFFI_SWIFT_TMP)/truapi_serverFFI.modulemap \
+		ios/truapi-host/Sources/truapi_serverFFI/include/module.modulemap
+
+android-publish-local: uniffi ## Publish io.parity:truapi-host-android to ~/.m2 (dev workflow).
+	gradle :truapi-host:publishReleasePublicationToMavenLocal --no-daemon
+
 test: ## Run Rust + TypeScript client tests.
-	cargo test --workspace
+	cargo test --workspace --features ws-bridge
 	cd $(TRUAPI_PKG) && npm test
+	cd $(JS_PACKAGES)/truapi-host-wasm && npm test
 
 check: ## Full verification suite (build, fmt, clippy, test, TS tests, playground build + lint).
 	cargo build --workspace
 	cargo +nightly fmt --check
 	cargo clippy --workspace --all-targets --all-features -- -D warnings
-	cargo test --workspace
+	cargo test --workspace --features ws-bridge
 	cd $(TRUAPI_PKG) && npm run build && npm test
+	cd $(JS_PACKAGES)/truapi-host-wasm && npm install --no-fund --no-audit && npm test
 	cd $(PLAYGROUND) && yarn build && yarn lint
 
 playground: ## Refresh the playground's @parity/truapi snapshot and rebuild.
@@ -50,12 +107,45 @@ playground: ## Refresh the playground's @parity/truapi snapshot and rebuild.
 	cd $(PLAYGROUND) && rm -rf node_modules/@parity && yarn install
 	cd $(PLAYGROUND) && yarn build
 
-dev: ## Start dotli host (:5173) + playground (:3000) together; open http://localhost:5173/localhost:3000. DEBUG=1 logs wire frames.
+dev-bootstrap: ## Prepare ignored generated/build artifacts needed by dotli preview.
+	git submodule update --init --recursive
+	# --ignore-scripts: the workspace `prepare` builds need generated sources
+	# that only exist after codegen.sh, which also builds the packages.
+	if [ ! -d node_modules ]; then npm ci --ignore-scripts; fi
+	if [ ! -f "$(HOST_WASM_GENERATED)" ]; then ./scripts/codegen.sh; fi
+	cd $(HOST_WASM_PKG) && npm run build
+	TRUAPI_WASM_PROFILE=dev $(MAKE) wasm
+	cd $(PLAYGROUND) && yarn install --frozen-lockfile
+	cd $(DOTLI) && bun install --frozen-lockfile
+	$(MAKE) dev-link-check
+
+dev-link-check: ## Verify dotli can resolve the local @parity/truapi-host-wasm package.
+	@test -f "$(HOST_WASM_GENERATED)" || (echo "Missing generated host callbacks. Run: make codegen"; exit 1)
+	@test -f "$(HOST_WASM_PKG)/dist/index.js" || (echo "Missing @parity/truapi-host-wasm dist. Run: npm run build --prefix $(HOST_WASM_PKG)"; exit 1)
+	@test -f "$(HOST_WASM_WEB)" || (echo "Missing @parity/truapi-host-wasm web WASM glue. Run: make wasm"; exit 1)
+	@test -e "$(DOTLI_HOST_WASM_LINK)/package.json" || (echo "dotli cannot resolve @parity/truapi-host-wasm. Run top-level: make dev"; exit 1)
+	cd $(DOTLI_UI) && bun -e 'await import("@parity/truapi-host-wasm"); await import("@parity/truapi-host-wasm/web");'
+
+dev: dev-bootstrap ## Start dotli host (:5173) + playground (:3000) together; open http://localhost:5173/localhost:3000. DEBUG=1 logs wire frames.
 	@trap 'kill 0' EXIT; \
 	( cd $(DOTLI) && bun run $(DOTLI_PREVIEW) ) & \
 	( cd $(PLAYGROUND) && yarn dev ) & \
 	wait
 
+e2e-dotli: ## Fully automated dotli + playground diagnosis e2e. Requires SIGNER_BOT_SVC_TOKEN unless E2E_DOTLI_SMOKE=1.
+	@SIGNER_BOT_SVC_TOKEN_ENV="$$SIGNER_BOT_SVC_TOKEN"; \
+	SIGNER_BOT_BASE_URL_ENV="$$SIGNER_BOT_BASE_URL"; \
+	SIGNER_BOT_NETWORK_ENV="$$SIGNER_BOT_NETWORK"; \
+	set -a; \
+	if [ -f .env ]; then . ./.env; fi; \
+	set +a; \
+	if [ -n "$$SIGNER_BOT_SVC_TOKEN_ENV" ]; then SIGNER_BOT_SVC_TOKEN="$$SIGNER_BOT_SVC_TOKEN_ENV"; export SIGNER_BOT_SVC_TOKEN; fi; \
+	if [ -n "$$SIGNER_BOT_BASE_URL_ENV" ]; then SIGNER_BOT_BASE_URL="$$SIGNER_BOT_BASE_URL_ENV"; export SIGNER_BOT_BASE_URL; fi; \
+	if [ -n "$$SIGNER_BOT_NETWORK_ENV" ]; then SIGNER_BOT_NETWORK="$$SIGNER_BOT_NETWORK_ENV"; export SIGNER_BOT_NETWORK; fi; \
+	if [ "$$E2E_DOTLI_SMOKE" != "1" ]; then test -n "$$SIGNER_BOT_SVC_TOKEN" || (echo "Missing SIGNER_BOT_SVC_TOKEN. e2e-dotli requires signer-bot; without it a human phone scan is required."; exit 1); fi; \
+	$(MAKE) dev-bootstrap; \
+	cd $(DOTLI)/apps/host && bun tests/e2e/playground-diagnosis.ts
+
 matrix: ## Regenerate the host compatibility matrix from explorer/diagnosis-reports.
 	cd $(EXPLORER) && npm run generate-matrix
 
diff --git a/deny.toml b/deny.toml
index 707c6f77..14156d84 100644
--- a/deny.toml
+++ b/deny.toml
@@ -5,8 +5,32 @@
 allow = [
     "MIT",
     "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "CC0-1.0",
     "Unicode-3.0",
     "Unlicense",
     "Zlib",
 ]
 confidence-threshold = 0.8
+
+# uniffi is MPL-2.0: file-level weak copyleft, consumed unmodified as a
+# dependency, which MPL-2.0 permits without affecting the MIT outbound licence.
+# Scoped per crate so MPL-2.0 stays disallowed everywhere else.
+# smoldot is GPL-3.0-or-later WITH Classpath-exception-2.0: the Classpath
+# exception explicitly permits linking it into independently-licensed works,
+# so the GPL does not extend to this crate. Scoped to the two smoldot crates
+# so plain GPL stays disallowed everywhere else.
+exceptions = [
+    { name = "smoldot", allow = ["GPL-3.0-or-later WITH Classpath-exception-2.0"] },
+    { name = "smoldot-light", allow = ["GPL-3.0-or-later WITH Classpath-exception-2.0"] },
+    { name = "uniffi", allow = ["MPL-2.0"] },
+    { name = "uniffi_bindgen", allow = ["MPL-2.0"] },
+    { name = "uniffi_core", allow = ["MPL-2.0"] },
+    { name = "uniffi_internal_macros", allow = ["MPL-2.0"] },
+    { name = "uniffi_macros", allow = ["MPL-2.0"] },
+    { name = "uniffi_meta", allow = ["MPL-2.0"] },
+    { name = "uniffi_pipeline", allow = ["MPL-2.0"] },
+    { name = "uniffi_udl", allow = ["MPL-2.0"] },
+]
diff --git a/docs/rfcs/extended-theme-api.md b/docs/rfcs/extended-theme-api.md
index accc6290..95649354 100644
--- a/docs/rfcs/extended-theme-api.md
+++ b/docs/rfcs/extended-theme-api.md
@@ -59,4 +59,3 @@ The old `Theme` enum (`Light | Dark`) is renamed to `ThemeVariant` for clarity.
 ## Drawbacks
 
 - Wire-breaking change: deployed products on the old schema will fail to decode the new payload until updated.
-
diff --git a/hosts/dotli b/hosts/dotli
index 0d5beea4..832fe422 160000
--- a/hosts/dotli
+++ b/hosts/dotli
@@ -1 +1 @@
-Subproject commit 0d5beea4b20335e10347512d98365419284ef261
+Subproject commit 832fe42271b033dbfdf538e5acf1a0414f9470b2
diff --git a/js/packages/truapi-host-wasm/.gitignore b/js/packages/truapi-host-wasm/.gitignore
new file mode 100644
index 00000000..288deac9
--- /dev/null
+++ b/js/packages/truapi-host-wasm/.gitignore
@@ -0,0 +1,11 @@
+node_modules/
+*.tsbuildinfo
+# Ignore compiled TS output (top-level + the web/ and electron/ entry subdirs)
+# Generated WASM artifacts under dist/wasm/ are ignored by the repo root.
+dist/**/*.js
+dist/**/*.d.ts
+dist/**/*.js.map
+dist/**/*.d.ts.map
+dist/generated/
+# Codegen output from truapi-codegen --platform-ts-output.
+src/generated/
diff --git a/js/packages/truapi-host-wasm/README.md b/js/packages/truapi-host-wasm/README.md
new file mode 100644
index 00000000..d6945ef1
--- /dev/null
+++ b/js/packages/truapi-host-wasm/README.md
@@ -0,0 +1,117 @@
+# @parity/truapi-host-wasm
+
+WASM-backed TrUAPI host runtime. It embeds the `truapi-server` Rust core (compiled to WASM) and
+provides the `Provider` factories that drive it, plus per-environment integration entry points.
+It is the counterpart to the native Android/iOS host shells.
+
+> This is distinct from [`@parity/truapi-host`](../truapi-host), which is the host-side codegen +
+> dispatcher for hosts that bring their **own** runtime and do not embed the shared Rust core.
+
+## Entry points
+
+The package exposes tree-shakeable subpath exports — import only what your environment needs:
+
+| Import                                     | Provides                                                                                                                |
+| ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `@parity/truapi-host-wasm`                 | Core: `createWasmProvider`, `createNodeWasmProvider`, `createHostServer`, the dispatcher adapter, and the shared types. |
+| `@parity/truapi-host-wasm/web`             | Browser host: `createIframeHost` (iframe MessageChannel handshake) and `createWebWorkerProvider`.                       |
+| `@parity/truapi-host-wasm/electron`        | `createElectronProvider` — wraps an Electron `MessagePortMain` as a `Provider`.                                         |
+| `@parity/truapi-host-wasm/worker-runtime`  | Web Worker entrypoint (import with your bundler's `?worker` suffix) so the WASM core runs off the page main thread.     |
+| `@parity/truapi-host-wasm/wasm/{web,node}` | The raw `wasm-bindgen` glue, if you need to instantiate the core yourself.                                              |
+
+## Generated WASM artefacts
+
+The ignored bundles under `dist/wasm/web/` and `dist/wasm/node/` are built without smoldot
+(`wasm-pack build --no-default-features`). Hosts that already manage chain access through their own
+JSON-RPC provider wire `chainConnect` into the callbacks and never touch smoldot. The bundled WASM
+is about 1 MB (release build with `wasm-opt`).
+
+Build them after editing `rust/crates/truapi-server` and before packaging, publishing, or running
+tests that load the raw WASM bundle (requires `wasm-pack` on PATH):
+
+```bash
+npm run build:wasm   # or `make wasm` from the repo root
+```
+
+## Example — Node / Electron
+
+```ts
+import {
+  createNodeWasmProvider,
+  createHostServer,
+} from "@parity/truapi-host-wasm";
+import { createElectronProvider } from "@parity/truapi-host-wasm/electron";
+
+const provider = await createNodeWasmProvider(
+  {
+    navigateTo: async (url) => {
+      /* shell.openExternal(url) */
+    },
+    pushNotification: async () => {},
+    devicePermission: async () => true,
+    remotePermission: async () => true,
+    featureSupported: async (payload) => payload,
+    localStorageRead: async () => undefined,
+    localStorageWrite: async () => {},
+    localStorageClear: async () => {},
+    // Optional: authStateChanged (core-owned auth UI state stream),
+    // readSession/writeSession/clearSession, subscribeSessionStore,
+    // confirmation, preimage, theme, and chain callbacks.
+  },
+  {
+    runtimeConfig: {
+      productLabel: "example",
+      productId: "example.dot",
+      siteId: "dot.li",
+      hostName: "Polkadot Web",
+      hostIcon: "https://dot.li/dotli.png",
+      hostVersion: "0.5.0",
+      platformType: "browser",
+      platformVersion: "unknown",
+      peopleChainGenesisHash:
+        "0xa22a2424d2cbf561eaecf7da8b1b548fa9d1939f60265e942b1049616a012f71",
+      pairingDeeplinkScheme: "polkadotapp",
+    },
+  },
+);
+
+const server = createHostServer(provider, [
+  /* dispatch entries */
+]);
+```
+
+## Example — browser (Web Worker)
+
+```ts
+import HostWorker from "@parity/truapi-host-wasm/worker-runtime?worker";
+import { createWebWorkerProvider } from "@parity/truapi-host-wasm/web";
+
+const provider = await createWebWorkerProvider(new HostWorker(), callbacks, {
+  runtimeConfig,
+});
+```
+
+`@parity/truapi-host-wasm/web` also exports `createIframeHost` for the protocol-iframe
+MessageChannel handshake.
+
+## Publishing
+
+The npm publish workflow is not wired yet. A release-process discussion is needed before adding a
+publish job to `.github/workflows/`. Until then, consumers depend on the package via the workspace
+`file:` link or by publishing locally with `npm pack`.
+
+## Architecture
+
+```text
+JS host code
+  protocol handlers / typed callbacks
+       |
+       v
+createHostServer (re-exported from @parity/truapi-host) <-- bytes --> Provider
+                                                                        |
+                                                                        v
+                                                      createWasmProvider / Worker
+                                                                        |
+                                                                        v
+                                                            truapi-server WASM core
+```
diff --git a/js/packages/truapi-host-wasm/package.json b/js/packages/truapi-host-wasm/package.json
new file mode 100644
index 00000000..c48e2a70
--- /dev/null
+++ b/js/packages/truapi-host-wasm/package.json
@@ -0,0 +1,61 @@
+{
+  "name": "@parity/truapi-host-wasm",
+  "version": "0.1.0",
+  "description": "WASM-backed TrUAPI host runtime: embeds the Rust core, with web (iframe + Web Worker) and Electron (MessagePortMain) entry points",
+  "license": "MIT",
+  "author": "Parity Technologies <admin@parity.io>",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": [
+    "./dist/worker-runtime.js",
+    "./dist/wasm/**"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./web": {
+      "types": "./dist/web/index.d.ts",
+      "import": "./dist/web/index.js"
+    },
+    "./electron": {
+      "types": "./dist/electron/index.d.ts",
+      "import": "./dist/electron/index.js"
+    },
+    "./node-runtime": {
+      "types": "./dist/node-runtime.d.ts",
+      "import": "./dist/node-runtime.js"
+    },
+    "./worker-runtime": {
+      "types": "./dist/worker-runtime.d.ts",
+      "import": "./dist/worker-runtime.js"
+    },
+    "./wasm/web": {
+      "types": "./dist/wasm/web/truapi_server.d.ts",
+      "import": "./dist/wasm/web/truapi_server.js"
+    },
+    "./wasm/node": {
+      "types": "./dist/wasm/node/truapi_server.d.ts",
+      "import": "./dist/wasm/node/truapi_server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "build:wasm": "node scripts/build-wasm.mjs",
+    "prepare": "npm run build",
+    "test": "for f in test/*.test.mjs; do echo \"=== $f ===\" && node --test \"$f\" || exit 1; done"
+  },
+  "dependencies": {
+    "@parity/truapi": "file:../truapi",
+    "@parity/truapi-host": "file:../truapi-host"
+  },
+  "devDependencies": {
+    "typescript": "^5.7"
+  }
+}
diff --git a/js/packages/truapi-host-wasm/scripts/build-wasm.mjs b/js/packages/truapi-host-wasm/scripts/build-wasm.mjs
new file mode 100644
index 00000000..ce20d027
--- /dev/null
+++ b/js/packages/truapi-host-wasm/scripts/build-wasm.mjs
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Rebuild the truapi-server WASM artefacts generated under
+// `dist/wasm/{web,node}/`. wasm-pack is required.
+
+import { execFile } from "node:child_process";
+import { rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = resolve(__dirname, "..");
+const repoRoot = resolve(pkgRoot, "../../..");
+const rustCrate = resolve(repoRoot, "rust/crates/truapi-server");
+const wasmProfile = process.env.TRUAPI_WASM_PROFILE ?? "release";
+
+function args(target, outDir) {
+  const command = [
+    "build",
+    "--target",
+    target,
+    "--out-dir",
+    outDir,
+    "--out-name",
+    "truapi_server",
+  ];
+  if (wasmProfile === "dev") {
+    command.push("--dev");
+  } else if (wasmProfile === "profiling") {
+    command.push("--profiling");
+  } else if (wasmProfile !== "release") {
+    throw new Error(
+      `Unsupported TRUAPI_WASM_PROFILE=${wasmProfile}; expected release, dev, or profiling`,
+    );
+  }
+  command.push(rustCrate, "--no-default-features");
+  return command;
+}
+
+async function build(target, subdir) {
+  const outDir = resolve(pkgRoot, "dist/wasm", subdir);
+  process.stdout.write(
+    `wasm-pack build --target ${target} --${wasmProfile} → ${outDir}\n`,
+  );
+  try {
+    await execFileAsync("wasm-pack", args(target, outDir), { cwd: repoRoot });
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      console.error(
+        "wasm-pack is required. Install it with `cargo install wasm-pack` " +
+          "or see https://rustwasm.github.io/wasm-pack/installer/",
+      );
+      process.exit(1);
+    }
+    throw err;
+  }
+  // wasm-pack writes a nested `.gitignore: *`; the repo-level ignore already
+  // owns generated WASM outputs.
+  await rm(resolve(outDir, ".gitignore"), { force: true });
+}
+
+await build("web", "web");
+await build("nodejs", "node");
diff --git a/js/packages/truapi-host-wasm/src/dispatcher.ts b/js/packages/truapi-host-wasm/src/dispatcher.ts
new file mode 100644
index 00000000..6de72e64
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/dispatcher.ts
@@ -0,0 +1,20 @@
+// Generic dispatcher utilities sit in `@parity/truapi-host`. This module
+// re-exports them so hosts that depend on `@parity/truapi-host-wasm` get the
+// dispatcher entry-point without a separate install.
+
+export {
+  createHostServer,
+  toFlatResponsePayload,
+  toResponsePayload,
+} from "@parity/truapi-host";
+
+export type {
+  CallContext,
+  HostDispatchEntry,
+  HostServerHooks,
+  RequestEntry,
+  SubscriptionCleanup,
+  SubscriptionEntry,
+  SubscriptionFramePort,
+  TrUApiHostServer,
+} from "@parity/truapi-host";
diff --git a/js/packages/truapi-host-wasm/src/electron/index.ts b/js/packages/truapi-host-wasm/src/electron/index.ts
new file mode 100644
index 00000000..9288419f
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/electron/index.ts
@@ -0,0 +1,112 @@
+import type { Provider } from "@parity/truapi";
+
+/**
+ * Minimal subset of Electron's `MessagePortMain` interface used by this
+ * package. Kept local so the package does not have a hard `electron`
+ * dependency (the host code passes the port in at runtime).
+ */
+export interface ElectronMessagePortMain {
+  postMessage(message: unknown, transfer?: unknown[]): void;
+  on(event: "message", handler: (event: { data: unknown }) => void): this;
+  on(event: "close", handler: () => void): this;
+  off(event: "message", handler: (event: { data: unknown }) => void): this;
+  off(event: "close", handler: () => void): this;
+  start(): void;
+  close(): void;
+}
+
+/**
+ * Options for `createElectronProvider`.
+ */
+export interface CreateElectronProviderOptions {
+  /** One end of an Electron `MessageChannelMain`. The other end must be
+   * transferred to the renderer through the preload script. */
+  port: ElectronMessagePortMain;
+}
+
+/**
+ * Wrap an Electron `MessagePortMain` as a TrUAPI `Provider`. The
+ * provider exchanges SCALE-encoded `Uint8Array` frames with the renderer.
+ * The provider's `dispose` closes the port.
+ *
+ * Hosts typically pair this with `@parity/truapi-host-wasm`'s
+ * `createNodeWasmProvider` (for the WASM core) and `createHostServer`
+ * from `@parity/truapi-host` (for the dispatcher) to assemble a full
+ * Electron host.
+ */
+export function createElectronProvider(
+  options: CreateElectronProviderOptions,
+): Provider {
+  const { port } = options;
+  const listeners = new Set<(message: Uint8Array) => void>();
+  const closeListeners = new Set<(error: Error) => void>();
+  let disposed = false;
+  let closedError: Error | null = null;
+
+  const onMessage = (event: { data: unknown }): void => {
+    if (closedError) return;
+    const data = event.data;
+    if (!(data instanceof Uint8Array)) return;
+    for (const listener of [...listeners]) listener(data);
+  };
+
+  const removePortListeners = (): void => {
+    try {
+      port.off("message", onMessage);
+      port.off("close", onClose);
+    } catch {
+      // already detached
+    }
+  };
+
+  const close = (error: Error): void => {
+    if (closedError) return;
+    closedError = error;
+    removePortListeners();
+    for (const listener of [...closeListeners]) listener(error);
+    listeners.clear();
+    closeListeners.clear();
+  };
+
+  const onClose = (): void => {
+    close(new Error("electron message port closed"));
+  };
+
+  port.on("message", onMessage);
+  port.on("close", onClose);
+  port.start();
+
+  return {
+    postMessage(bytes: Uint8Array): void {
+      if (closedError) return;
+      port.postMessage(bytes);
+    },
+    subscribe(callback) {
+      if (closedError) return () => {};
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    },
+    subscribeClose(callback) {
+      if (closedError) {
+        callback(closedError);
+        return () => {};
+      }
+      closeListeners.add(callback);
+      return () => {
+        closeListeners.delete(callback);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        port.close();
+      } catch {
+        // already closed
+      }
+      close(new Error("electron provider disposed"));
+    },
+  };
+}
diff --git a/js/packages/truapi-host-wasm/src/error-message.ts b/js/packages/truapi-host-wasm/src/error-message.ts
new file mode 100644
index 00000000..b3583ffd
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/error-message.ts
@@ -0,0 +1,5 @@
+export function errorMessage(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return JSON.stringify(err) ?? String(err);
+}
diff --git a/js/packages/truapi-host-wasm/src/index.ts b/js/packages/truapi-host-wasm/src/index.ts
new file mode 100644
index 00000000..53821bb7
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/index.ts
@@ -0,0 +1,59 @@
+export type {
+  Payload,
+  ProtocolMessage,
+  Provider,
+  HostPermissionKind,
+} from "./types.js";
+
+export type {
+  AuthState,
+  Awaitable,
+  ChainConnect,
+  ChainConnection,
+  ChainProvider,
+  Features,
+  HostCallbacks,
+  LogLevel,
+  Navigation,
+  Notifications,
+  Permissions,
+  PreimageHost,
+  PlatformJsonRpcConnection,
+  SessionUiInfo,
+  HostStorage,
+  ThemeHost,
+  TrUApiHostWasmProvider,
+  WasmCoreLike,
+  WasmRawCallbacks,
+  WasmRuntimeConfig,
+} from "./runtime.js";
+export { createUnavailableCallbacks, createWasmProvider } from "./runtime.js";
+export { createWasmRawCallbacks } from "./typed-callbacks.js";
+
+export type { CreateNodeWasmProviderOptions } from "./node-runtime.js";
+export { createNodeWasmProvider } from "./node-runtime.js";
+
+export type {
+  CallbackArgs,
+  CallbackName,
+  MainToWorker,
+  OptionalCallbackName,
+  SubscriptionName,
+  WorkerToMain,
+} from "./worker-protocol.js";
+
+export type {
+  CallContext,
+  HostDispatchEntry,
+  HostServerHooks,
+  RequestEntry,
+  SubscriptionCleanup,
+  SubscriptionEntry,
+  SubscriptionFramePort,
+  TrUApiHostServer,
+} from "./dispatcher.js";
+export {
+  createHostServer,
+  toFlatResponsePayload,
+  toResponsePayload,
+} from "./dispatcher.js";
diff --git a/js/packages/truapi-host-wasm/src/node-runtime.ts b/js/packages/truapi-host-wasm/src/node-runtime.ts
new file mode 100644
index 00000000..cfcf53ac
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/node-runtime.ts
@@ -0,0 +1,63 @@
+import {
+  createWasmProvider,
+  type LogLevel,
+  type TrUApiHostWasmProvider,
+  type WasmCoreLike,
+  type WasmRawCallbacks,
+  type WasmRuntimeConfig,
+} from "./runtime.js";
+
+interface NodeWasmModuleShape {
+  WasmTrUApiCore: new (callbacks: unknown, runtimeConfig: unknown) => WasmCoreLike;
+  setLogLevel: (level: string) => void;
+}
+
+/**
+ * Options for `createNodeWasmProvider`.
+ */
+export interface CreateNodeWasmProviderOptions {
+  /** Wasm core log level. Default: `"off"`. */
+  logLevel?: LogLevel;
+  /** Static product/pairing config passed to the Rust core. */
+  runtimeConfig: WasmRuntimeConfig;
+}
+
+/**
+ * Lazy-load the node-targeted WASM bundle and wrap it in a `Provider`.
+ *
+ * The bundle initialises synchronously (wasm-pack nodejs target uses
+ * `require()` under the hood for the .wasm file), so callers receive
+ * a ready-to-use provider once the dynamic import resolves.
+ */
+export async function createNodeWasmProvider(
+  partial: Omit<WasmRawCallbacks, "emitFrame">,
+  options: CreateNodeWasmProviderOptions,
+): Promise<TrUApiHostWasmProvider> {
+  if (!options?.runtimeConfig) {
+    throw new Error("runtimeConfig is required");
+  }
+
+  // Dynamic import keeps the WASM module out of the package's static
+  // dependency graph and out of the tsc rootDir. Indirected through a
+  // variable so TS skips the static module-existence check.
+  const wasmNodePath = "./wasm/node/truapi_server.js";
+  const mod = (await import(
+    /* @vite-ignore */ wasmNodePath
+  )) as NodeWasmModuleShape | { default: NodeWasmModuleShape };
+
+  const wasm: NodeWasmModuleShape =
+    "WasmTrUApiCore" in mod
+      ? (mod as NodeWasmModuleShape)
+      : (mod.default as NodeWasmModuleShape);
+
+  if (!wasm?.WasmTrUApiCore) {
+    throw new Error("Node WASM bundle did not export WasmTrUApiCore");
+  }
+
+  wasm.setLogLevel?.(options.logLevel ?? "off");
+
+  return createWasmProvider(
+    (raw) => new wasm.WasmTrUApiCore(raw, options.runtimeConfig),
+    partial,
+  );
+}
diff --git a/js/packages/truapi-host-wasm/src/runtime.ts b/js/packages/truapi-host-wasm/src/runtime.ts
new file mode 100644
index 00000000..e2d5aab4
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/runtime.ts
@@ -0,0 +1,303 @@
+import type { Provider } from "@parity/truapi";
+
+// The typed capability interfaces below come straight from the
+// `truapi-platform` Rust crate via `truapi-codegen --platform-ts-output`.
+// They are the host-author-facing surface: each method takes/returns
+// typed wrappers (`HostDevicePermissionRequest`, etc.) rather than raw
+// SCALE bytes. The `WasmRawCallbacks` interface declared further down
+// is the byte-oriented wire surface the WASM core invokes; use
+// `createWasmRawCallbacks` to adapt this typed surface into the raw
+// callback surface consumed by `createWasmProvider`.
+export type {
+  AuthState,
+  ChainProvider,
+  Features,
+  HostCallbacks,
+  JsonRpcConnection as PlatformJsonRpcConnection,
+  Navigation,
+  Notifications,
+  Permissions,
+  PreimageHost,
+  SessionUiInfo,
+  HostStorage,
+  ThemeHost,
+} from "./generated/host-callbacks.js";
+import type { AuthState } from "./generated/host-callbacks.js";
+
+/**
+ * Async-or-sync return. Synchronous hosts (e.g. the dotli main-thread
+ * shell hitting localStorage) can return a plain value; the WASM bridge
+ * awaits every return so an `async` impl also works.
+ */
+export type Awaitable<T> = T | Promise<T>;
+
+/**
+ * Open a JSON-RPC connection for `genesisHash`. The wasm bridge passes
+ * `onResponse` so the host can push smoldot replies back asynchronously.
+ * Returning `null` (or throwing) tells the core no provider is available.
+ */
+export type ChainConnect = (
+  genesisHash: string,
+  onResponse: (json: string) => void,
+) => Awaitable<ChainConnection | null>;
+
+/**
+ * Per-connection handle returned by `chainConnect`. `send` forwards a
+ * SCALE-encoded JSON-RPC request; `close` tears the connection down.
+ */
+export interface ChainConnection {
+  send(request: string): void;
+  close(): void;
+}
+
+/**
+ * Verbosity threshold for the wasm core's `tracing` output. `off` silences
+ * it; the rest map to the matching browser `console` method (`debug`/`trace`
+ * land on `console.debug`, hidden in Chrome unless the console level dropdown
+ * includes "Verbose").
+ */
+export type LogLevel = "off" | "error" | "warn" | "info" | "debug" | "trace";
+
+export interface WasmRuntimeConfig {
+  productLabel: string;
+  productId: string;
+  siteId: string;
+  hostName: string;
+  hostIcon?: string;
+  hostVersion?: string;
+  platformType?: string;
+  platformVersion?: string;
+  peopleChainGenesisHash: string | Uint8Array;
+  pairingDeeplinkScheme:
+    | "polkadotapp"
+    | "polkadotApp"
+    | "PolkadotApp"
+    | "polkadotappdev"
+    | "polkadotAppDev"
+    | "PolkadotAppDev";
+}
+
+/**
+ * Raw byte-oriented callbacks the WASM core invokes. Names match the
+ * camelCase property keys the Rust `JsBridge::from_js` extracts. Request
+ * callbacks return `Promise<Uint8Array>` (or `Promise<bool>` for the
+ * permission prompts); subscription callbacks accept a `sendItem` sink
+ * and return an optional `dispose` function.
+ *
+ * This interface is the SCALE-byte-level wire surface between the WASM
+ * core and JS; the typed `HostCallbacks` interface above is the
+ * host-author surface. They overlap on the capability methods covered by
+ * `truapi-platform`; account, signing, and statement-store methods are owned
+ * by the Rust core and do not cross this callback boundary.
+ */
+export interface WasmRawCallbacks {
+  navigateTo(url: string): Promise<void>;
+  pushNotification(payload: Uint8Array): Promise<number>;
+  cancelNotification?(id: number): Promise<void>;
+  devicePermission(payload: Uint8Array): Promise<boolean>;
+  remotePermission(payload: Uint8Array): Promise<boolean>;
+  featureSupported(payload: Uint8Array): Promise<boolean>;
+  localStorageRead(key: string): Promise<Uint8Array | null | undefined>;
+  localStorageWrite(key: string, value: Uint8Array): Promise<void>;
+  localStorageClear(key: string): Promise<void>;
+  authStateChanged?(state: AuthState): void;
+  readSession?(): Promise<Uint8Array | null | undefined>;
+  writeSession?(value: Uint8Array): Promise<void>;
+  clearSession?(): Promise<void>;
+  subscribeSessionStore?(sendItem: () => void): (() => void) | void;
+  confirmSignPayload?(payload: Uint8Array): Promise<boolean>;
+  confirmSignRaw?(payload: Uint8Array): Promise<boolean>;
+  confirmCreateTransaction?(payload: Uint8Array): Promise<boolean>;
+  confirmAccountAlias?(payload: Uint8Array): Promise<boolean>;
+  confirmResourceAllocation?(payload: Uint8Array): Promise<boolean>;
+  confirmPreimageSubmit?(size: number): Promise<void>;
+  submitPreimage?(value: Uint8Array): Promise<Uint8Array>;
+  themeSubscribe?(
+    sendItem: (theme: "Light" | "Dark" | 0 | 1 | Uint8Array) => void,
+  ): (() => void) | void;
+  preimageLookupSubscribe(
+    key: Uint8Array,
+    sendItem: (value: Uint8Array | null | undefined) => void,
+  ): (() => void) | void;
+  /** Optional. When omitted, the WASM bridge reports chain calls as
+   * "unavailable". Hosts that own chain access (e.g. dotli's
+   * smoldot/RPC toggle) supply it. */
+  chainConnect?: ChainConnect;
+  emitFrame(frame: Uint8Array): void;
+  dispose?(): void;
+}
+
+/**
+ * Stubs every required callback so a host can spread them over its own
+ * implementation and override only what it supports. Unavailable methods
+ * reject with a descriptive error; unavailable subscriptions emit a current
+ * default item where the platform contract requires one.
+ */
+export function createUnavailableCallbacks(): Omit<
+  WasmRawCallbacks,
+  "emitFrame" | "dispose" | "chainConnect"
+> {
+  const unavailable = (method: string) => async (): Promise<never> => {
+    throw new Error(`${method} unavailable on this host`);
+  };
+  const emitCurrentTick = (sendItem: () => void): void => {
+    sendItem();
+  };
+  const emitCurrentTheme = (
+    sendItem: (theme: "Light" | "Dark" | 0 | 1 | Uint8Array) => void,
+  ): void => {
+    sendItem("Dark");
+  };
+  const emitCurrentPreimageMiss = (
+    _key: Uint8Array,
+    sendItem: (value: Uint8Array | null | undefined) => void,
+  ): void => {
+    sendItem(undefined);
+  };
+  return {
+    navigateTo: unavailable("navigateTo"),
+    pushNotification: async () => 0,
+    devicePermission: async () => false,
+    remotePermission: async () => false,
+    featureSupported: unavailable("featureSupported"),
+    localStorageRead: async () => undefined,
+    localStorageWrite: unavailable("localStorageWrite"),
+    localStorageClear: unavailable("localStorageClear"),
+    confirmPreimageSubmit: unavailable("confirmPreimageSubmit"),
+    submitPreimage: unavailable("submitPreimage"),
+    subscribeSessionStore: emitCurrentTick,
+    themeSubscribe: emitCurrentTheme,
+    preimageLookupSubscribe: emitCurrentPreimageMiss,
+  };
+}
+
+/**
+ * Shape exposed by the wasm-pack output's `WasmTrUApiCore`. Kept local
+ * so the package does not have a hard dependency on the generated `.d.ts`
+ * file path.
+ */
+export interface WasmCoreLike {
+  receiveFromProduct(frame: Uint8Array): Promise<void>;
+  disconnect?(): Promise<void>;
+  cancelLogin?(): void;
+  dispose(): void;
+  free(): void;
+}
+
+export interface TrUApiHostWasmProvider extends Provider {
+  /**
+   * Core-owned logout/disconnect. This best-effort notifies the SSO peer,
+   * clears the in-memory session, clears SessionStore, and broadcasts
+   * Disconnected from the Rust core.
+   */
+  disconnect(): Promise<void>;
+
+  /**
+   * Cancel any in-flight `requestLogin` pairing (e.g. the user closed the
+   * pairing UI). The core emits a `Disconnected` auth state and resolves
+   * the pending login as `Rejected`. A no-op when no login is in progress.
+   */
+  cancelLogin(): void;
+
+  /**
+   * Re-tune the wasm core's log level at runtime. Present on runtimes that
+   * keep a live channel to the core (e.g. the Web Worker provider); absent on
+   * one-shot constructions that only accept `logLevel` up front.
+   */
+  setLogLevel?(level: LogLevel): void;
+}
+
+/**
+ * Wraps a WASM core in a `Provider`, the byte transport abstraction
+ * exposed by `@parity/truapi`. The provider can be handed to
+ * `createHostServer` from `@parity/truapi-host` so the dispatcher dispatches
+ * inbound frames into the WASM core and forwards core-emitted frames back
+ * to the listener registered through `provider.subscribe`.
+ */
+export function createWasmProvider(
+  createCore: (rawCallbacks: WasmRawCallbacks) => WasmCoreLike,
+  partial: Omit<WasmRawCallbacks, "emitFrame">,
+): TrUApiHostWasmProvider {
+  const listeners = new Set<(message: Uint8Array) => void>();
+  const closeListeners = new Set<(error: Error) => void>();
+  let disposed = false;
+  let closedError: Error | null = null;
+
+  // Terminal close-once transition, matching `createBaseProvider` in
+  // @parity/truapi: notify close listeners exactly once, then drop all
+  // listeners so the provider stops delivering.
+  const close = (error: Error): void => {
+    if (closedError) return;
+    closedError = error;
+    for (const listener of [...closeListeners]) listener(error);
+    listeners.clear();
+    closeListeners.clear();
+  };
+
+  const raw: WasmRawCallbacks = {
+    ...partial,
+    emitFrame(frame: Uint8Array) {
+      if (disposed || closedError) return;
+      // Copy out of the WASM-owned buffer so retained references stay
+      // valid once the core reuses the underlying memory.
+      const copy = new Uint8Array(frame.length);
+      copy.set(frame);
+      for (const listener of [...listeners]) listener(copy);
+    },
+  };
+
+  const core = createCore(raw);
+
+  return {
+    postMessage(bytes: Uint8Array): void {
+      if (disposed || closedError) return;
+      void core.receiveFromProduct(bytes).catch((err: unknown) => {
+        close(err instanceof Error ? err : new Error(String(err)));
+      });
+    },
+    subscribe(callback) {
+      if (closedError) return () => {};
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    },
+    subscribeClose(callback) {
+      if (closedError) {
+        callback(closedError);
+        return () => {};
+      }
+      closeListeners.add(callback);
+      return () => {
+        closeListeners.delete(callback);
+      };
+    },
+    async disconnect() {
+      if (disposed || closedError) return;
+      if (!core.disconnect) {
+        throw new Error("disconnect unavailable on this WASM core");
+      }
+      await core.disconnect();
+    },
+    cancelLogin() {
+      if (disposed || closedError) return;
+      core.cancelLogin?.();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        core.dispose();
+      } catch {
+        // host dispose threw, swallow during teardown
+      }
+      try {
+        core.free();
+      } catch {
+        // already freed
+      }
+      close(new Error("wasm provider disposed"));
+      partial.dispose?.();
+    },
+  };
+}
diff --git a/js/packages/truapi-host-wasm/src/subscription-table.ts b/js/packages/truapi-host-wasm/src/subscription-table.ts
new file mode 100644
index 00000000..b76fd372
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/subscription-table.ts
@@ -0,0 +1,71 @@
+// Single source of truth for streaming host subscriptions crossing the
+// worker boundary. Both the main-thread provider (callback dispatch and
+// `optionalSubscriptions` advertisement) and the worker runtime (raw
+// callback construction) derive their behavior from this table.
+
+import type { WasmRawCallbacks } from "./runtime.js";
+import type { SubscriptionName } from "./worker-protocol.js";
+
+/** Host-side callback set the subscription adapters dispatch into. */
+export type SubscriptionCallbacks = Omit<WasmRawCallbacks, "emitFrame">;
+
+/** Pushes one subscription item back to the worker. */
+export type PushItem = (value?: unknown) => void;
+
+type StartResult = (() => void) | void;
+
+/**
+ * One streaming subscription: the `WasmRawCallbacks` key implementing it,
+ * its wire-protocol name, and a `start` adapter typed per entry. Entries
+ * with `payload: "required"` are only started with a non-null payload.
+ */
+export type SubscriptionDispatchEntry = {
+  readonly callback: keyof SubscriptionCallbacks;
+  readonly protocol: SubscriptionName;
+} & (
+  | {
+      readonly payload: "none";
+      readonly start: (
+        callbacks: SubscriptionCallbacks,
+        push: PushItem,
+      ) => StartResult;
+    }
+  | {
+      readonly payload: "required";
+      readonly start: (
+        callbacks: SubscriptionCallbacks,
+        payload: Uint8Array,
+        push: PushItem,
+      ) => StartResult;
+    }
+);
+
+/** Every streaming subscription the worker bridge knows how to dispatch. */
+export const SUBSCRIPTION_DISPATCH: readonly SubscriptionDispatchEntry[] = [
+  {
+    callback: "subscribeSessionStore",
+    protocol: "sessionStoreSubscribe",
+    payload: "none",
+    start: (callbacks, push) => callbacks.subscribeSessionStore?.(push),
+  },
+  {
+    callback: "themeSubscribe",
+    protocol: "themeSubscribe",
+    payload: "none",
+    start: (callbacks, push) => callbacks.themeSubscribe?.(push),
+  },
+  {
+    callback: "preimageLookupSubscribe",
+    protocol: "preimageLookupSubscribe",
+    payload: "required",
+    start: (callbacks, payload, push) =>
+      callbacks.preimageLookupSubscribe(payload, push),
+  },
+];
+
+/** Looks up the dispatch entry for a wire subscription name, if known. */
+export function subscriptionDispatchEntry(
+  name: SubscriptionName,
+): SubscriptionDispatchEntry | undefined {
+  return SUBSCRIPTION_DISPATCH.find((entry) => entry.protocol === name);
+}
diff --git a/js/packages/truapi-host-wasm/src/typed-callbacks.ts b/js/packages/truapi-host-wasm/src/typed-callbacks.ts
new file mode 100644
index 00000000..82417db9
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/typed-callbacks.ts
@@ -0,0 +1,257 @@
+import {
+  HostDevicePermissionRequest,
+  HostFeatureSupportedRequest,
+  HostPushNotificationRequest,
+  RemotePermissionRequest,
+  ThemeVariant,
+  type GenericError,
+  type Result,
+} from "@parity/truapi";
+import { hexToBytes } from "@parity/truapi/scale";
+
+import {
+  createUnavailableCallbacks,
+  type ChainConnection,
+  type WasmRawCallbacks,
+} from "./runtime.js";
+import type { AuthState, HostCallbacks } from "./generated/host-callbacks.js";
+
+type WireResult<T, E> =
+  | { success: true; value: T }
+  | { success: false; value: E };
+
+type StreamResult<T, E> = Result<T, E> | WireResult<T, E>;
+
+type MaybeAsyncIterable<T> = AsyncIterable<T> | Iterable<T>;
+
+type OptionalTypedCallbacks = Partial<HostCallbacks>;
+
+type RawWithoutEmit = Omit<WasmRawCallbacks, "emitFrame">;
+
+const decodePushNotification = HostPushNotificationRequest.dec;
+const decodeDevicePermission = HostDevicePermissionRequest.dec;
+const decodeRemotePermission = RemotePermissionRequest.dec;
+const decodeFeatureSupported = HostFeatureSupportedRequest.dec;
+
+function errorReason(error: GenericError): string {
+  return error.reason;
+}
+
+function unwrapStreamResult<T>(item: StreamResult<T, GenericError>): T {
+  if ("success" in item) {
+    if (item.success === false) {
+      throw new Error(errorReason(item.value));
+    }
+    return item.value;
+  }
+  if (item.isErr()) {
+    throw new Error(errorReason(item.error));
+  }
+  return item.value;
+}
+
+function toAsyncIterator<T>(stream: MaybeAsyncIterable<T>): AsyncIterator<T> {
+  const asyncIterable = stream as AsyncIterable<T>;
+  if (typeof asyncIterable[Symbol.asyncIterator] === "function") {
+    return asyncIterable[Symbol.asyncIterator]();
+  }
+
+  const iterator = (stream as Iterable<T>)[Symbol.iterator]();
+  const asyncIterator: AsyncIterator<T> = {
+    next: async () => iterator.next(),
+  };
+  if (iterator.return) {
+    asyncIterator.return = async () => iterator.return!();
+  }
+  return asyncIterator;
+}
+
+function driveResultStream<T>(
+  stream: MaybeAsyncIterable<StreamResult<T, GenericError>>,
+  sendItem: (value: T) => void,
+): () => void {
+  const iterator = toAsyncIterator(stream);
+  let stopped = false;
+  void (async () => {
+    try {
+      while (!stopped) {
+        const next = await iterator.next();
+        if (next.done) return;
+        sendItem(unwrapStreamResult(next.value));
+      }
+    } catch (err) {
+      console.error("[truapi typed callbacks] subscription failed:", err);
+    }
+  })();
+  return () => {
+    stopped = true;
+    void iterator.return?.();
+  };
+}
+
+function chainConnect(
+  callbacks: OptionalTypedCallbacks,
+): RawWithoutEmit["chainConnect"] {
+  if (!callbacks.connect) return undefined;
+  return async (genesisHash, onResponse): Promise<ChainConnection | null> => {
+    const connection = await callbacks.connect!(hexToBytes(genesisHash));
+    const iterator = connection.responses()[Symbol.asyncIterator]();
+    let closed = false;
+    void (async () => {
+      try {
+        while (!closed) {
+          const next = await iterator.next();
+          if (next.done) return;
+          onResponse(next.value);
+        }
+      } catch (err) {
+        console.error("[truapi typed callbacks] chain responses failed:", err);
+      }
+    })();
+    return {
+      send(request: string): void {
+        connection.send(request);
+      },
+      close(): void {
+        closed = true;
+        void iterator.return?.();
+      },
+    };
+  };
+}
+
+/**
+ * Adapt generated typed host callbacks into the raw SCALE-byte callback
+ * surface consumed by the WASM core.
+ */
+export function createWasmRawCallbacks(
+  callbacks: OptionalTypedCallbacks,
+): RawWithoutEmit {
+  const unavailable = createUnavailableCallbacks();
+  const connect = chainConnect(callbacks);
+  return {
+    ...unavailable,
+    navigateTo: callbacks.navigateTo
+      ? (url) => callbacks.navigateTo!(url)
+      : unavailable.navigateTo,
+    pushNotification: callbacks.pushNotification
+      ? async (payload) => {
+          const response = await callbacks.pushNotification!(
+            decodePushNotification(payload),
+          );
+          return response.id;
+        }
+      : unavailable.pushNotification,
+    ...(callbacks.cancelNotification
+      ? {
+          cancelNotification: (id: number) => callbacks.cancelNotification!(id),
+        }
+      : {}),
+    devicePermission: callbacks.devicePermission
+      ? async (payload) => {
+          const response = await callbacks.devicePermission!(
+            decodeDevicePermission(payload),
+          );
+          return response.granted;
+        }
+      : unavailable.devicePermission,
+    remotePermission: callbacks.remotePermission
+      ? async (payload) => {
+          const response = await callbacks.remotePermission!(
+            decodeRemotePermission(payload),
+          );
+          return response.granted;
+        }
+      : unavailable.remotePermission,
+    featureSupported: callbacks.featureSupported
+      ? async (payload) => {
+          const response = await callbacks.featureSupported!(
+            decodeFeatureSupported(payload),
+          );
+          return response.supported;
+        }
+      : unavailable.featureSupported,
+    localStorageRead: callbacks.read
+      ? (key) => callbacks.read!(key)
+      : unavailable.localStorageRead,
+    localStorageWrite: callbacks.write
+      ? (key, value) => callbacks.write!(key, value)
+      : unavailable.localStorageWrite,
+    localStorageClear: callbacks.clear
+      ? (key) => callbacks.clear!(key)
+      : unavailable.localStorageClear,
+    ...(callbacks.authStateChanged
+      ? {
+          authStateChanged: (state: AuthState) =>
+            callbacks.authStateChanged!(state),
+        }
+      : {}),
+    ...(callbacks.readSession
+      ? { readSession: () => callbacks.readSession!() }
+      : {}),
+    ...(callbacks.writeSession
+      ? { writeSession: (value: Uint8Array) => callbacks.writeSession!(value) }
+      : {}),
+    ...(callbacks.clearSession
+      ? { clearSession: () => callbacks.clearSession!() }
+      : {}),
+    ...(callbacks.subscribeSessionStore
+      ? {
+          subscribeSessionStore: (sendItem: () => void) =>
+            driveResultStream(callbacks.subscribeSessionStore!(), () =>
+              sendItem(),
+            ),
+        }
+      : {}),
+    ...(callbacks.confirmSignPayload
+      ? {
+          confirmSignPayload: (payload: Uint8Array) =>
+            callbacks.confirmSignPayload!(payload),
+        }
+      : {}),
+    ...(callbacks.confirmSignRaw
+      ? {
+          confirmSignRaw: (payload: Uint8Array) =>
+            callbacks.confirmSignRaw!(payload),
+        }
+      : {}),
+    ...(callbacks.confirmCreateTransaction
+      ? {
+          confirmCreateTransaction: (payload: Uint8Array) =>
+            callbacks.confirmCreateTransaction!(payload),
+        }
+      : {}),
+    ...(callbacks.confirmAccountAlias
+      ? {
+          confirmAccountAlias: (payload: Uint8Array) =>
+            callbacks.confirmAccountAlias!(payload),
+        }
+      : {}),
+    ...(callbacks.confirmResourceAllocation
+      ? {
+          confirmResourceAllocation: (payload: Uint8Array) =>
+            callbacks.confirmResourceAllocation!(payload),
+        }
+      : {}),
+    confirmPreimageSubmit: callbacks.confirmPreimageSubmit
+      ? (size) => callbacks.confirmPreimageSubmit!(BigInt(size))
+      : unavailable.confirmPreimageSubmit,
+    submitPreimage: callbacks.submitPreimage
+      ? (value) => callbacks.submitPreimage!(value)
+      : unavailable.submitPreimage,
+    ...(callbacks.subscribeTheme
+      ? {
+          themeSubscribe: (sendItem: (theme: ThemeVariant) => void) =>
+            driveResultStream(callbacks.subscribeTheme!(), sendItem),
+        }
+      : {}),
+    preimageLookupSubscribe: callbacks.lookupPreimage
+      ? (key, sendItem) =>
+          driveResultStream(callbacks.lookupPreimage!(key), (item) => {
+            const value = item as Uint8Array | undefined;
+            sendItem(value);
+          })
+      : unavailable.preimageLookupSubscribe,
+    ...(connect ? { chainConnect: connect } : {}),
+  };
+}
diff --git a/js/packages/truapi-host-wasm/src/types.ts b/js/packages/truapi-host-wasm/src/types.ts
new file mode 100644
index 00000000..6ee1216c
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/types.ts
@@ -0,0 +1,9 @@
+import type { Payload, ProtocolMessage, Provider } from "@parity/truapi";
+
+export type { Payload, ProtocolMessage, Provider };
+
+/**
+ * Subset of permission tags the host can be asked to prompt for. Mirrors
+ * the Rust `Permission` enum that flows through the WASM bridge.
+ */
+export type HostPermissionKind = "Device" | "Remote";
diff --git a/js/packages/truapi-host-wasm/src/web/create-iframe-host.ts b/js/packages/truapi-host-wasm/src/web/create-iframe-host.ts
new file mode 100644
index 00000000..da9ef0ac
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/web/create-iframe-host.ts
@@ -0,0 +1,146 @@
+import type { Provider } from "@parity/truapi";
+
+/**
+ * Options for `createIframeHost`.
+ */
+export interface IframeHostOptions {
+  /** URL of the product iframe. */
+  iframeUrl: string;
+  /** Container element the iframe is appended to. */
+  container: HTMLElement;
+  /**
+   * Called with one end of the MessageChannel once the iframe has loaded.
+   * Hosts typically pipe this into a `Provider` (e.g. via
+   * `createMessagePortProvider` from `@parity/truapi`) and hand the
+   * provider to `createHostServer`.
+   */
+  onPort: (port: MessagePort) => void;
+  /**
+   * Optional explicit allow-list origin. Defaults to the origin of
+   * `iframeUrl`. Throws if it disagrees with the iframe URL's origin.
+   */
+  allowedOrigin?: string;
+  /** Override the default iframe sandbox attribute. */
+  sandbox?: string;
+}
+
+/**
+ * Handle returned by `createIframeHost`.
+ */
+export interface IframeHost {
+  iframe: HTMLIFrameElement;
+  dispose: () => void;
+}
+
+const DEFAULT_IFRAME_SANDBOX = "allow-forms allow-same-origin allow-scripts";
+type CredentiallessIframe = HTMLIFrameElement & { credentialless?: boolean };
+
+function resolveAllowedOrigin(
+  iframeUrl: string,
+  allowedOrigin?: string,
+): string {
+  const targetUrl = new URL(iframeUrl, window.location.href);
+  if (targetUrl.protocol !== "http:" && targetUrl.protocol !== "https:") {
+    throw new Error(
+      `Iframe host only allows http(s) playground URLs, received ${targetUrl.protocol}`,
+    );
+  }
+
+  if (!allowedOrigin) {
+    return targetUrl.origin;
+  }
+
+  const normalizedOrigin = new URL(allowedOrigin).origin;
+  if (normalizedOrigin !== targetUrl.origin) {
+    throw new Error(
+      `Iframe host origin policy mismatch, expected ${normalizedOrigin}, got ${targetUrl.origin}`,
+    );
+  }
+
+  return normalizedOrigin;
+}
+
+/**
+ * Embed a product iframe and transfer a `MessagePort` into it. The host
+ * keeps the other end and passes it to a `Provider` (typically via
+ * `createMessagePortProvider`). All product traffic flows over the
+ * MessageChannel.
+ */
+export function createIframeHost(options: IframeHostOptions): IframeHost {
+  const {
+    iframeUrl,
+    container,
+    onPort,
+    allowedOrigin,
+    sandbox = DEFAULT_IFRAME_SANDBOX,
+  } = options;
+
+  const channel = new MessageChannel();
+  const hostPort = channel.port1;
+  const productPort = channel.port2;
+  const targetOrigin = resolveAllowedOrigin(iframeUrl, allowedOrigin);
+
+  // Hand the host-side port to the caller immediately so it can wire up
+  // a provider before the iframe finishes loading. Queued postMessage
+  // calls are delivered once the channel is started by the provider.
+  onPort(hostPort);
+
+  const iframe = document.createElement("iframe");
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  // COEP hosts need credentialless product iframes when the product origin
+  // does not serve matching embedder headers.
+  const credentiallessIframe = iframe as CredentiallessIframe;
+  credentiallessIframe.credentialless = true;
+  iframe.setAttribute("sandbox", sandbox);
+  iframe.referrerPolicy = "no-referrer";
+  iframe.src = iframeUrl;
+  const initTargetOrigin = credentiallessIframe.credentialless
+    ? "*"
+    : targetOrigin;
+
+  let initSent = false;
+  const sendInit = (): void => {
+    if (initSent) return;
+    const contentWindow = iframe.contentWindow;
+    if (!contentWindow) return;
+    initSent = true;
+    contentWindow.postMessage({ type: "truapi-init" }, initTargetOrigin, [
+      productPort,
+    ]);
+  };
+
+  const onWindowMessage = (event: MessageEvent): void => {
+    if (event.source !== iframe.contentWindow) return;
+    if (event.origin !== targetOrigin && event.origin !== "null") return;
+    if (event.data?.type === "truapi-playground-ready") {
+      sendInit();
+    }
+  };
+  window.addEventListener("message", onWindowMessage);
+
+  container.appendChild(iframe);
+
+  return {
+    iframe,
+    dispose() {
+      window.removeEventListener("message", onWindowMessage);
+      try {
+        hostPort.close();
+      } catch {
+        // already closed
+      }
+      try {
+        productPort.close();
+      } catch {
+        // already closed
+      }
+      iframe.remove();
+    },
+  };
+}
+
+// Suppress unused-symbol warning when consumers do not import Provider
+// directly; declaring the type relationship keeps the contract visible.
+export type { Provider };
diff --git a/js/packages/truapi-host-wasm/src/web/create-worker-host-runtime.ts b/js/packages/truapi-host-wasm/src/web/create-worker-host-runtime.ts
new file mode 100644
index 00000000..5c5b35de
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/web/create-worker-host-runtime.ts
@@ -0,0 +1,695 @@
+import type {
+  ChainConnection,
+  LogLevel,
+  MainToWorker,
+  SubscriptionName,
+  TrUApiHostWasmProvider,
+  WasmRuntimeConfig,
+  WasmRawCallbacks,
+  WorkerToMain,
+} from "../index.js";
+import {
+  OPTIONAL_CALLBACK_NAMES,
+  type CallbackName,
+  type OptionalCallbackName,
+} from "../worker-protocol.js";
+import { errorMessage } from "../error-message.js";
+import {
+  SUBSCRIPTION_DISPATCH,
+  subscriptionDispatchEntry,
+} from "../subscription-table.js";
+import { decodeWireMessage, describeWireId } from "@parity/truapi";
+import { bytesToHex } from "@parity/truapi/scale";
+
+interface WorkerProviderState {
+  worker: Worker;
+  rawCallbacks: WasmRawCallbacks;
+  listeners: Set<(message: Uint8Array) => void>;
+  closeListeners: Set<(error: Error) => void>;
+  subscriptionDisposers: Map<number, () => void>;
+  chainConnections: Map<number, ChainConnection>;
+  pendingDisconnects: Map<
+    number,
+    { resolve: () => void; reject: (error: Error) => void }
+  >;
+  closedError: Error | null;
+  logLevel: LogLevel;
+  disposed: boolean;
+}
+
+function debugLoggingEnabled(state: WorkerProviderState): boolean {
+  return state.logLevel === "debug" || state.logLevel === "trace";
+}
+
+let nextDisconnectRequestId = 0;
+
+/** localStorage key the dev log level is persisted under, so it survives reloads. */
+const DEV_LOG_LEVEL_KEY = "truapi:logLevel";
+const LOG_LEVELS: readonly LogLevel[] = [
+  "off",
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace",
+];
+
+function isLogLevel(value: string | null): value is LogLevel {
+  return value !== null && (LOG_LEVELS as readonly string[]).includes(value);
+}
+
+/** Read the persisted dev log level. Returns null when unset or unavailable. */
+function readPersistedLogLevel(): LogLevel | null {
+  try {
+    const stored = globalThis.localStorage?.getItem(DEV_LOG_LEVEL_KEY);
+    return isLogLevel(stored) ? stored : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Persist the dev log level so it re-applies on the next reload. */
+function persistLogLevel(level: LogLevel): void {
+  try {
+    globalThis.localStorage?.setItem(DEV_LOG_LEVEL_KEY, level);
+  } catch {
+    // Storage unavailable (sandboxed iframe / privacy mode); the level still
+    // applies for the current session.
+  }
+}
+
+let devLogLevelOverride: LogLevel | null = readPersistedLogLevel();
+const devGlobalProviders = new Set<TrUApiHostWasmProvider>();
+
+interface TrUApiDevConsole {
+  setLogLevel(level: LogLevel): void;
+  getLogLevel(): LogLevel | null;
+  getProviderCount(): number;
+}
+
+function optionalCallbacks(
+  callbacks: Omit<WasmRawCallbacks, "emitFrame">,
+): OptionalCallbackName[] {
+  return OPTIONAL_CALLBACK_NAMES.filter(
+    (name) => typeof callbacks[name] === "function",
+  );
+}
+
+function optionalSubscriptions(
+  callbacks: Omit<WasmRawCallbacks, "emitFrame">,
+): SubscriptionName[] {
+  return SUBSCRIPTION_DISPATCH.filter(
+    ({ callback }) => typeof callbacks[callback] === "function",
+  ).map(({ protocol }) => protocol);
+}
+
+function bytesToHexPreview(bytes: Uint8Array, maxBytes = 96): string {
+  const visible = bytes.subarray(0, maxBytes);
+  const suffix =
+    bytes.length > maxBytes ? `…(+${bytes.length - maxBytes})` : "";
+  return `${bytesToHex(visible)}${suffix}`;
+}
+
+function describeWireFrame(bytes: Uint8Array) {
+  const decoded = decodeWireMessage(bytes);
+  if (decoded.isErr()) {
+    return {
+      frameBytes: bytes.byteLength,
+      decodeError: decoded.error.message,
+      frameHex: bytesToHexPreview(bytes),
+    };
+  }
+  const wireId = decoded.value.payload.id;
+  const payload = decoded.value.payload.value;
+  return {
+    frame: describeWireId(wireId),
+    requestId: decoded.value.requestId,
+    wireId,
+    frameBytes: bytes.byteLength,
+    payloadBytes: payload.byteLength,
+    payloadHex: bytesToHexPreview(payload),
+  };
+}
+
+function handleCallbackRequest(
+  state: WorkerProviderState,
+  msg: {
+    requestId: number;
+    name: CallbackName;
+    args: readonly unknown[];
+  },
+): void {
+  // Own-property guard: `msg.name` is worker-supplied, never walk the
+  // prototype chain with it.
+  const fn = Object.hasOwn(state.rawCallbacks, msg.name)
+    ? (
+        state.rawCallbacks as unknown as Record<
+          string,
+          (...args: readonly unknown[]) => unknown
+        >
+      )[msg.name]
+    : undefined;
+  if (!fn) {
+    const reply: MainToWorker = {
+      kind: "callbackResponse",
+      requestId: msg.requestId,
+      ok: false,
+      error: `unknown callback: ${msg.name}`,
+    };
+    state.worker.postMessage(reply);
+    return;
+  }
+  Promise.resolve()
+    .then(() => fn(...msg.args))
+    .then(
+      (value) => {
+        const reply: MainToWorker = {
+          kind: "callbackResponse",
+          requestId: msg.requestId,
+          ok: true,
+          value,
+        };
+        state.worker.postMessage(reply);
+      },
+      (err) => {
+        const reply: MainToWorker = {
+          kind: "callbackResponse",
+          requestId: msg.requestId,
+          ok: false,
+          error: errorMessage(err),
+        };
+        state.worker.postMessage(reply);
+      },
+    );
+}
+
+function handleSubscriptionStart(
+  state: WorkerProviderState,
+  msg: {
+    subId: number;
+    name: SubscriptionName;
+    payload: Uint8Array | null;
+  },
+): void {
+  const entry = subscriptionDispatchEntry(msg.name);
+  if (!entry) {
+    console.warn(`[truapi worker] unknown subscription: ${msg.name}`);
+    return;
+  }
+  const sendItem = (value?: unknown): void => {
+    if (state.disposed) return;
+    const post: MainToWorker = {
+      kind: "subscriptionItem",
+      subId: msg.subId,
+      value,
+    };
+    state.worker.postMessage(post);
+  };
+  let dispose: (() => void) | void;
+  try {
+    if (entry.payload === "required") {
+      if (msg.payload === null) {
+        console.warn(
+          `[truapi worker] ${msg.name} requires payload, none received`,
+        );
+        return;
+      }
+      dispose = entry.start(state.rawCallbacks, msg.payload, sendItem);
+    } else {
+      dispose = entry.start(state.rawCallbacks, sendItem);
+    }
+  } catch (err) {
+    console.error(`[truapi worker] ${msg.name} threw on start:`, err);
+    return;
+  }
+  if (typeof dispose === "function") {
+    state.subscriptionDisposers.set(msg.subId, dispose);
+  }
+}
+
+function handleSubscriptionStop(
+  state: WorkerProviderState,
+  msg: { subId: number },
+): void {
+  const dispose = state.subscriptionDisposers.get(msg.subId);
+  if (!dispose) return;
+  state.subscriptionDisposers.delete(msg.subId);
+  try {
+    dispose();
+  } catch (err) {
+    console.warn("[truapi worker] subscription dispose threw:", err);
+  }
+}
+
+async function handleChainConnectStart(
+  state: WorkerProviderState,
+  msg: { connId: number; genesisHash: string },
+): Promise<void> {
+  const chainConnect = state.rawCallbacks.chainConnect;
+  if (!chainConnect) {
+    const reply: MainToWorker = {
+      kind: "chainConnectAck",
+      connId: msg.connId,
+      ok: false,
+      error: "host did not supply chainConnect",
+    };
+    state.worker.postMessage(reply);
+    return;
+  }
+  const onResponse = (json: string): void => {
+    if (state.disposed) return;
+    const post: MainToWorker = {
+      kind: "chainResponse",
+      connId: msg.connId,
+      json,
+    };
+    state.worker.postMessage(post);
+  };
+  try {
+    const conn = await chainConnect(msg.genesisHash, onResponse);
+    if (!conn) {
+      const reply: MainToWorker = {
+        kind: "chainConnectAck",
+        connId: msg.connId,
+        ok: false,
+        error: `chainConnect returned null for genesisHash ${msg.genesisHash}`,
+      };
+      state.worker.postMessage(reply);
+      return;
+    }
+    state.chainConnections.set(msg.connId, conn);
+    const reply: MainToWorker = {
+      kind: "chainConnectAck",
+      connId: msg.connId,
+      ok: true,
+    };
+    state.worker.postMessage(reply);
+  } catch (err) {
+    const reply: MainToWorker = {
+      kind: "chainConnectAck",
+      connId: msg.connId,
+      ok: false,
+      error: errorMessage(err),
+    };
+    state.worker.postMessage(reply);
+  }
+}
+
+function handleChainSend(
+  state: WorkerProviderState,
+  msg: { connId: number; request: string },
+): void {
+  const conn = state.chainConnections.get(msg.connId);
+  if (!conn) return;
+  try {
+    if (debugLoggingEnabled(state)) {
+      console.debug("[truapi worker] chainSend", msg.connId, msg.request);
+    }
+    conn.send(msg.request);
+  } catch (err) {
+    console.warn("[truapi worker] chain send threw:", err);
+  }
+}
+
+function handleChainClose(
+  state: WorkerProviderState,
+  msg: { connId: number },
+): void {
+  const conn = state.chainConnections.get(msg.connId);
+  if (!conn) return;
+  state.chainConnections.delete(msg.connId);
+  try {
+    conn.close();
+  } catch (err) {
+    console.warn("[truapi worker] chain close threw:", err);
+  }
+}
+
+function handleDisconnectResponse(
+  state: WorkerProviderState,
+  msg:
+    | { requestId: number; ok: true }
+    | { requestId: number; ok: false; error: string },
+): void {
+  const pending = state.pendingDisconnects.get(msg.requestId);
+  if (!pending) return;
+  state.pendingDisconnects.delete(msg.requestId);
+  if (msg.ok) {
+    pending.resolve();
+  } else {
+    pending.reject(new Error(msg.error));
+  }
+}
+
+function rejectPendingDisconnects(
+  state: WorkerProviderState,
+  error: Error,
+): void {
+  for (const pending of state.pendingDisconnects.values()) {
+    pending.reject(error);
+  }
+  state.pendingDisconnects.clear();
+}
+
+/**
+ * Shared terminal teardown for both `dispose()` and worker faults: rejects
+ * pending disconnects, runs subscription disposers, closes chain connections,
+ * and terminates the worker. A fault additionally notifies close listeners.
+ */
+function teardown(
+  state: WorkerProviderState,
+  error: Error,
+  fault: boolean,
+): void {
+  if (state.disposed) return;
+  state.disposed = true;
+  state.closedError = error;
+  rejectPendingDisconnects(state, error);
+  for (const fn of state.subscriptionDisposers.values()) {
+    try {
+      fn();
+    } catch {
+      // ignore during teardown
+    }
+  }
+  state.subscriptionDisposers.clear();
+  for (const conn of state.chainConnections.values()) {
+    try {
+      conn.close();
+    } catch {
+      // ignore during teardown
+    }
+  }
+  state.chainConnections.clear();
+  if (fault) {
+    state.worker.terminate();
+  } else {
+    try {
+      const post: MainToWorker = { kind: "dispose" };
+      state.worker.postMessage(post);
+    } catch {
+      // ignore if worker already gone
+    }
+    // Give the worker a tick to free the core before terminating.
+    setTimeout(() => state.worker.terminate(), 0);
+  }
+  for (const listener of [...state.closeListeners]) listener(error);
+  state.listeners.clear();
+  state.closeListeners.clear();
+}
+
+export interface CreateWebWorkerProviderOptions {
+  /** Wasm core log level. Default: `"off"`. */
+  logLevel?: LogLevel;
+  /** Static product/pairing config passed to the Rust core. */
+  runtimeConfig: WasmRuntimeConfig;
+  /**
+   * Milliseconds to wait for the worker to report `ready` before rejecting
+   * and terminating it. Default: 30000.
+   */
+  initTimeoutMs?: number;
+}
+
+/**
+ * Spawn the truapi-server WASM in `worker` and bridge it into a
+ * `Provider`. The provider can be handed to `createHostServer` from
+ * `@parity/truapi-host`.
+ *
+ * The caller is responsible for instantiating the Worker, Vite users
+ * typically import the worker entry-point with `?worker`:
+ *
+ * ```ts
+ * import HostWorker from "@parity/truapi-host-wasm/worker-runtime?worker";
+ * const worker = new HostWorker();
+ * const provider = await createWebWorkerProvider(worker, callbacks, {
+ *   runtimeConfig,
+ * });
+ * ```
+ *
+ * Resolves once the worker reports `ready` and rejects if the WASM
+ * fails to load.
+ */
+export function createWebWorkerProvider(
+  worker: Worker,
+  callbacks: Omit<WasmRawCallbacks, "emitFrame">,
+  options: CreateWebWorkerProviderOptions,
+): Promise<TrUApiHostWasmProvider> {
+  if (!options?.runtimeConfig) {
+    return Promise.reject(new Error("runtimeConfig is required"));
+  }
+
+  return new Promise((resolve, reject) => {
+    const state: WorkerProviderState = {
+      worker,
+      // `emitFrame` is satisfied by the worker side; main thread never
+      // calls it. Fill in a no-op so the typed callback set is complete.
+      rawCallbacks: {
+        ...(callbacks as WasmRawCallbacks),
+        emitFrame: () => {},
+      },
+      listeners: new Set(),
+      closeListeners: new Set(),
+      subscriptionDisposers: new Map(),
+      chainConnections: new Map(),
+      pendingDisconnects: new Map(),
+      closedError: null,
+      logLevel: devLogLevelOverride ?? options.logLevel ?? "off",
+      disposed: false,
+    };
+
+    const onMessage = (ev: MessageEvent<WorkerToMain>): void => {
+      const msg = ev.data;
+      switch (msg.kind) {
+        case "loaded":
+          break;
+        case "ready":
+          break;
+        case "fatalError":
+          console.error("[truapi worker]", msg.error);
+          notifyFault(new Error(`worker fatal error: ${msg.error}`));
+          break;
+        case "frameError":
+          console.error("[truapi worker]", msg.error);
+          notifyFault(new Error(`worker frame error: ${msg.error}`));
+          break;
+        case "disposeError":
+          console.warn("[truapi worker] dispose:", msg.error);
+          break;
+        case "frame":
+          if (debugLoggingEnabled(state)) {
+            console.debug(
+              "[truapi worker] frame <-",
+              describeWireFrame(msg.bytes),
+            );
+          }
+          for (const listener of [...state.listeners]) listener(msg.bytes);
+          break;
+        case "disconnectResponse":
+          handleDisconnectResponse(state, msg);
+          break;
+        case "callbackRequest":
+          if (debugLoggingEnabled(state)) {
+            console.debug("[truapi worker] callbackRequest", msg.name);
+          }
+          handleCallbackRequest(state, msg);
+          break;
+        case "subscriptionStart":
+          handleSubscriptionStart(state, msg);
+          break;
+        case "subscriptionStop":
+          handleSubscriptionStop(state, msg);
+          break;
+        case "chainConnectStart":
+          if (debugLoggingEnabled(state)) {
+            console.debug("[truapi worker] chainConnectStart", msg.connId);
+          }
+          void handleChainConnectStart(state, msg);
+          break;
+        case "chainSend":
+          handleChainSend(state, msg);
+          break;
+        case "chainClose":
+          handleChainClose(state, msg);
+          break;
+        default: {
+          const { kind } = msg as { kind?: unknown };
+          console.warn(
+            `[truapi worker] unknown worker message kind: ${String(kind)}`,
+          );
+        }
+      }
+    };
+
+    const notifyFault = (error: Error): void => {
+      teardown(state, error, true);
+    };
+
+    const onError = (e: ErrorEvent): void => {
+      cleanupInit();
+      worker.terminate();
+      reject(new Error(`worker init failed: ${e.message}`));
+    };
+
+    const onInitMessageError = (): void => {
+      cleanupInit();
+      worker.terminate();
+      reject(new Error("worker message could not be deserialized during init"));
+    };
+
+    const onRuntimeError = (e: ErrorEvent): void => {
+      console.error("[truapi worker]", e.message);
+      notifyFault(new Error(`worker error: ${e.message}`));
+    };
+
+    const onMessageError = (): void => {
+      notifyFault(new Error("worker message could not be deserialized"));
+    };
+
+    const onInitMessage = (ev: MessageEvent<WorkerToMain>): void => {
+      const msg = ev.data;
+      if (msg.kind === "loaded") {
+        const init: MainToWorker = {
+          kind: "init",
+          logLevel: devLogLevelOverride ?? options.logLevel ?? "off",
+          runtimeConfig: options.runtimeConfig,
+          optionalCallbacks: optionalCallbacks(callbacks),
+          optionalSubscriptions: optionalSubscriptions(callbacks),
+          chainConnect: typeof callbacks.chainConnect === "function",
+        };
+        worker.postMessage(init);
+      } else if (msg.kind === "ready") {
+        cleanupInit();
+        worker.addEventListener("message", onMessage);
+        // Surface a post-init worker fault (uncaught throw, OOM, killed
+        // worker) to close listeners for the provider's lifetime.
+        worker.addEventListener("error", onRuntimeError);
+        worker.addEventListener("messageerror", onMessageError);
+        const provider = buildProvider(state);
+        exposeDevGlobal(provider);
+        resolve(provider);
+      } else if (msg.kind === "fatalError") {
+        cleanupInit();
+        worker.terminate();
+        reject(new Error(`worker init reported error: ${msg.error}`));
+      }
+    };
+
+    const cleanupInit = (): void => {
+      clearTimeout(initTimeout);
+      worker.removeEventListener("error", onError);
+      worker.removeEventListener("messageerror", onInitMessageError);
+      worker.removeEventListener("message", onInitMessage);
+    };
+
+    const timeoutMs = options.initTimeoutMs ?? 30_000;
+    const initTimeout = setTimeout(() => {
+      cleanupInit();
+      worker.terminate();
+      reject(new Error(`worker init timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    worker.addEventListener("error", onError);
+    worker.addEventListener("messageerror", onInitMessageError);
+    worker.addEventListener("message", onInitMessage);
+  });
+}
+
+function buildProvider(state: WorkerProviderState): TrUApiHostWasmProvider {
+  const provider: TrUApiHostWasmProvider = {
+    postMessage(bytes: Uint8Array): void {
+      if (state.disposed) return;
+      const post: MainToWorker = { kind: "frame", bytes };
+      if (debugLoggingEnabled(state)) {
+        console.debug("[truapi worker] frame ->", describeWireFrame(bytes));
+      }
+      state.worker.postMessage(post);
+    },
+    subscribe(callback) {
+      state.listeners.add(callback);
+      return () => {
+        state.listeners.delete(callback);
+      };
+    },
+    subscribeClose(callback) {
+      if (state.closedError) {
+        callback(state.closedError);
+        return () => {};
+      }
+      state.closeListeners.add(callback);
+      return () => {
+        state.closeListeners.delete(callback);
+      };
+    },
+    disconnect(): Promise<void> {
+      if (state.disposed) return Promise.resolve();
+      return new Promise((resolve, reject) => {
+        const requestId = ++nextDisconnectRequestId;
+        state.pendingDisconnects.set(requestId, { resolve, reject });
+        try {
+          const post: MainToWorker = { kind: "disconnect", requestId };
+          state.worker.postMessage(post);
+        } catch (err) {
+          state.pendingDisconnects.delete(requestId);
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+    },
+    cancelLogin(): void {
+      if (state.disposed) return;
+      const post: MainToWorker = { kind: "cancelLogin" };
+      state.worker.postMessage(post);
+    },
+    setLogLevel(level: LogLevel): void {
+      if (state.disposed) return;
+      state.logLevel = level;
+      const post: MainToWorker = { kind: "setLogLevel", level };
+      state.worker.postMessage(post);
+    },
+    dispose() {
+      devGlobalProviders.delete(provider);
+      teardown(state, new Error("provider disposed"), false);
+    },
+  };
+  return provider;
+}
+
+/**
+ * Publish `globalThis.__truapi.setLogLevel(level)` so a developer can re-tune
+ * the wasm core's verbosity live from the browser console without a reload. The
+ * level is persisted to `localStorage["truapi:logLevel"]` and re-applied on the
+ * next load, so it survives refreshes. Pair with the DevTools console "Verbose"
+ * level to surface debug/trace.
+ */
+function exposeDevGlobal(provider: TrUApiHostWasmProvider): void {
+  devGlobalProviders.add(provider);
+  if (devLogLevelOverride !== null) {
+    provider.setLogLevel?.(devLogLevelOverride);
+  }
+  publishDevGlobal();
+}
+
+function publishDevGlobal(): void {
+  const target = globalThis as {
+    __truapi?: TrUApiDevConsole;
+  };
+  target.__truapi = {
+    setLogLevel(level: LogLevel): void {
+      devLogLevelOverride = level;
+      persistLogLevel(level);
+      for (const provider of [...devGlobalProviders]) {
+        provider.setLogLevel?.(level);
+      }
+      console.info(
+        `[truapi worker] logLevel=${level} providers=${String(devGlobalProviders.size)}`,
+      );
+    },
+    getLogLevel(): LogLevel | null {
+      return devLogLevelOverride;
+    },
+    getProviderCount(): number {
+      return devGlobalProviders.size;
+    },
+  };
+}
+
+publishDevGlobal();
diff --git a/js/packages/truapi-host-wasm/src/web/index.ts b/js/packages/truapi-host-wasm/src/web/index.ts
new file mode 100644
index 00000000..6876c6cc
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/web/index.ts
@@ -0,0 +1,4 @@
+export type { IframeHost, IframeHostOptions } from "./create-iframe-host.js";
+export { createIframeHost } from "./create-iframe-host.js";
+export type { CreateWebWorkerProviderOptions } from "./create-worker-host-runtime.js";
+export { createWebWorkerProvider } from "./create-worker-host-runtime.js";
diff --git a/js/packages/truapi-host-wasm/src/worker-protocol.ts b/js/packages/truapi-host-wasm/src/worker-protocol.ts
new file mode 100644
index 00000000..5f42a867
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/worker-protocol.ts
@@ -0,0 +1,121 @@
+// Wire format between the main thread (`createWebWorkerProvider`) and the
+// Web Worker that hosts the truapi-server WASM core.
+//
+// Frames (`kind: 'frame'`) carry SCALE-encoded `ProtocolMessage` bytes
+// untouched in either direction. Everything else is a control message
+// for callback dispatch, subscription bookkeeping, or chain connections.
+//
+// Frame bytes cross the boundary by structured clone, deliberately not as
+// transferables: the sender keeps using its buffer (the worker side posts
+// views into WASM memory) and frames are small, so the copy is the simpler
+// safe choice.
+
+import type { LogLevel } from "./runtime.js";
+
+/**
+ * Names of every request/response style host callback the wasm core can
+ * invoke. Names match the camelCase property keys of `WasmRawCallbacks`.
+ */
+export const CALLBACK_NAMES = [
+  "navigateTo",
+  "pushNotification",
+  "cancelNotification",
+  "devicePermission",
+  "remotePermission",
+  "featureSupported",
+  "localStorageRead",
+  "localStorageWrite",
+  "localStorageClear",
+  "authStateChanged",
+  "readSession",
+  "writeSession",
+  "clearSession",
+  "confirmSignPayload",
+  "confirmSignRaw",
+  "confirmCreateTransaction",
+  "confirmAccountAlias",
+  "confirmResourceAllocation",
+  "confirmPreimageSubmit",
+  "submitPreimage",
+] as const;
+
+export type CallbackName = (typeof CALLBACK_NAMES)[number];
+
+export const OPTIONAL_CALLBACK_NAMES = [
+  "cancelNotification",
+  "authStateChanged",
+  "readSession",
+  "writeSession",
+  "clearSession",
+  "confirmSignPayload",
+  "confirmSignRaw",
+  "confirmCreateTransaction",
+  "confirmAccountAlias",
+  "confirmResourceAllocation",
+  "confirmPreimageSubmit",
+  "submitPreimage",
+] as const satisfies readonly CallbackName[];
+
+export type OptionalCallbackName = (typeof OPTIONAL_CALLBACK_NAMES)[number];
+
+/**
+ * Names of every subscription host callback. Each has the shape
+ * `(payload?, sendItem) => dispose | void`.
+ */
+export type SubscriptionName =
+  | "sessionStoreSubscribe"
+  | "preimageLookupSubscribe"
+  | "themeSubscribe";
+
+/**
+ * Positional arguments for a callback. The wasm core calls each callback
+ * at a fixed arity; a uniform `unknown[]` keeps the wire protocol simple.
+ */
+export type CallbackArgs = readonly unknown[];
+
+export type MainToWorker =
+  | {
+      kind: "init";
+      logLevel: LogLevel;
+      runtimeConfig: unknown;
+      optionalCallbacks?: readonly OptionalCallbackName[];
+      optionalSubscriptions?: readonly SubscriptionName[];
+      chainConnect?: boolean;
+    }
+  | { kind: "setLogLevel"; level: LogLevel }
+  | { kind: "frame"; bytes: Uint8Array }
+  | { kind: "disconnect"; requestId: number }
+  | { kind: "cancelLogin" }
+  | { kind: "callbackResponse"; requestId: number; ok: true; value: unknown }
+  | { kind: "callbackResponse"; requestId: number; ok: false; error: string }
+  | { kind: "subscriptionItem"; subId: number; value: unknown }
+  | { kind: "chainConnectAck"; connId: number; ok: true }
+  | { kind: "chainConnectAck"; connId: number; ok: false; error: string }
+  | { kind: "chainResponse"; connId: number; json: string }
+  | { kind: "dispose" };
+
+export type WorkerToMain =
+  | { kind: "loaded" }
+  | { kind: "ready" }
+  | { kind: "fatalError"; error: string }
+  | { kind: "frameError"; error: string }
+  | { kind: "disposeError"; error: string }
+  | { kind: "frame"; bytes: Uint8Array }
+  | { kind: "disconnectResponse"; requestId: number; ok: true }
+  | { kind: "disconnectResponse"; requestId: number; ok: false; error: string }
+  | {
+      kind: "callbackRequest";
+      requestId: number;
+      name: CallbackName;
+      args: CallbackArgs;
+    }
+  | {
+      kind: "subscriptionStart";
+      subId: number;
+      name: SubscriptionName;
+      payload: Uint8Array | null;
+    }
+  | { kind: "subscriptionStop"; subId: number }
+  | { kind: "chainConnectStart"; connId: number; genesisHash: string }
+  | { kind: "chainSend"; connId: number; request: string }
+  | { kind: "chainClose"; connId: number };
diff --git a/js/packages/truapi-host-wasm/src/worker-runtime.ts b/js/packages/truapi-host-wasm/src/worker-runtime.ts
new file mode 100644
index 00000000..f1413d46
--- /dev/null
+++ b/js/packages/truapi-host-wasm/src/worker-runtime.ts
@@ -0,0 +1,341 @@
+/// <reference lib="webworker" />
+// Worker entrypoint. Loads the web-targeted truapi-server WASM bundle and
+// bridges every host callback over postMessage. The main thread keeps the
+// state that needs DOM access (localStorage, prompts) while the CPU-heavy
+// smoldot/dispatcher work runs here off the page main thread.
+
+import type {
+  CallbackName,
+  MainToWorker,
+  OptionalCallbackName,
+  SubscriptionName,
+  WorkerToMain,
+} from "./worker-protocol.js";
+import { errorMessage } from "./error-message.js";
+import { SUBSCRIPTION_DISPATCH } from "./subscription-table.js";
+
+interface WasmCore {
+  receiveFromProduct(frame: Uint8Array): Promise<void>;
+  disconnect(): Promise<void>;
+  cancelLogin(): void;
+  dispose(): void;
+  free(): void;
+}
+
+interface WasmModuleShape {
+  default: (input?: unknown) => Promise<unknown>;
+  WasmTrUApiCore: new (callbacks: unknown, runtimeConfig: unknown) => WasmCore;
+  setLogLevel?: (level: string) => void;
+}
+
+// Resolved at runtime, the wasm-pack artifact lives outside `src/` so a
+// static import would leak into the TS rootDir. The relative path is
+// resolved against `dist/worker-runtime.js` once compiled. Indirected
+// through a variable so TS skips the static module-existence check.
+const WASM_WEB_PATH = "./wasm/web/truapi_server.js";
+const wasmModulePromise = import(
+  /* @vite-ignore */ WASM_WEB_PATH
+) as Promise<WasmModuleShape>;
+
+const ctx = self as unknown as DedicatedWorkerGlobalScope;
+
+function postToMain(msg: WorkerToMain): void {
+  ctx.postMessage(msg);
+}
+
+let nextRequestId = 0;
+const pendingCallbacks = new Map<
+  number,
+  (
+    result: { ok: true; value: unknown } | { ok: false; error: string },
+  ) => void
+>();
+
+let nextSubId = 0;
+const subscriptionItemListeners = new Map<
+  number,
+  (value: unknown) => void
+>();
+
+let nextConnId = 0;
+type ChainConnectAck = { ok: true } | { ok: false; error: string };
+const chainConnectAcks = new Map<number, (ack: ChainConnectAck) => void>();
+const chainResponseListeners = new Map<number, (json: string) => void>();
+
+function callbackRequest(
+  name: CallbackName,
+  args: readonly unknown[],
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const requestId = ++nextRequestId;
+    pendingCallbacks.set(requestId, (r) => {
+      if (r.ok) resolve(r.value);
+      else reject(new Error(r.error));
+    });
+    postToMain({ kind: "callbackRequest", requestId, name, args });
+  });
+}
+
+function startSubscription<T>(
+  name: SubscriptionName,
+  payload: Uint8Array | null,
+  sendItem: (value: T) => void,
+): () => void {
+  const subId = ++nextSubId;
+  subscriptionItemListeners.set(subId, sendItem as (value: unknown) => void);
+  postToMain({ kind: "subscriptionStart", subId, name, payload });
+  return () => {
+    subscriptionItemListeners.delete(subId);
+    postToMain({ kind: "subscriptionStop", subId });
+  };
+}
+
+interface WorkerChainConnection {
+  send(request: string): void;
+  close(): void;
+}
+
+function chainConnect(
+  genesisHash: string,
+  onResponse: (json: string) => void,
+): Promise<WorkerChainConnection | null> {
+  const connId = ++nextConnId;
+  return new Promise((resolve, reject) => {
+    chainConnectAcks.set(connId, (ack) => {
+      if (!ack.ok) {
+        chainResponseListeners.delete(connId);
+        reject(new Error(ack.error));
+        return;
+      }
+      resolve({
+        send(request: string) {
+          postToMain({ kind: "chainSend", connId, request });
+        },
+        close() {
+          chainResponseListeners.delete(connId);
+          postToMain({ kind: "chainClose", connId });
+        },
+      });
+    });
+    chainResponseListeners.set(connId, onResponse);
+    postToMain({ kind: "chainConnectStart", connId, genesisHash });
+  });
+}
+
+type RawCallbackFn = (...args: never[]) => unknown;
+
+const requiredRawCallbacks: Record<string, RawCallbackFn> = {
+  navigateTo: (url: string) => callbackRequest("navigateTo", [url]),
+  pushNotification: (payload: Uint8Array) =>
+    callbackRequest("pushNotification", [payload]),
+  devicePermission: (payload: Uint8Array) =>
+    callbackRequest("devicePermission", [payload]) as Promise<boolean>,
+  remotePermission: (payload: Uint8Array) =>
+    callbackRequest("remotePermission", [payload]) as Promise<boolean>,
+  featureSupported: (payload: Uint8Array) =>
+    callbackRequest("featureSupported", [payload]) as Promise<boolean>,
+  localStorageRead: (key: string) =>
+    callbackRequest("localStorageRead", [key]) as Promise<
+      Uint8Array | null | undefined
+    >,
+  localStorageWrite: (key: string, value: Uint8Array) =>
+    callbackRequest("localStorageWrite", [key, value]),
+  localStorageClear: (key: string) =>
+    callbackRequest("localStorageClear", [key]),
+};
+
+const optionalRawCallbacks: Record<OptionalCallbackName, RawCallbackFn> = {
+  cancelNotification: (id: number) =>
+    callbackRequest("cancelNotification", [id]),
+  // Fire-and-forget notification: the wasm core ignores the returned promise.
+  authStateChanged: (state: unknown) =>
+    void callbackRequest("authStateChanged", [state]).catch(() => {}),
+  readSession: () =>
+    callbackRequest("readSession", []) as Promise<
+      Uint8Array | null | undefined
+    >,
+  writeSession: (value: Uint8Array) =>
+    callbackRequest("writeSession", [value]),
+  clearSession: () => callbackRequest("clearSession", []),
+  confirmSignPayload: (payload: Uint8Array) =>
+    callbackRequest("confirmSignPayload", [payload]) as Promise<boolean>,
+  confirmSignRaw: (payload: Uint8Array) =>
+    callbackRequest("confirmSignRaw", [payload]) as Promise<boolean>,
+  confirmCreateTransaction: (payload: Uint8Array) =>
+    callbackRequest("confirmCreateTransaction", [payload]) as Promise<boolean>,
+  confirmAccountAlias: (payload: Uint8Array) =>
+    callbackRequest("confirmAccountAlias", [payload]) as Promise<boolean>,
+  confirmResourceAllocation: (payload: Uint8Array) =>
+    callbackRequest("confirmResourceAllocation", [payload]) as Promise<boolean>,
+  confirmPreimageSubmit: (size: number) =>
+    callbackRequest("confirmPreimageSubmit", [size]) as Promise<void>,
+  submitPreimage: (value: Uint8Array) =>
+    callbackRequest("submitPreimage", [value]) as Promise<Uint8Array>,
+};
+
+function buildRawCallbacks(msg: Extract<MainToWorker, { kind: "init" }>) {
+  const callbacks: Record<string, unknown> = { ...requiredRawCallbacks };
+  for (const name of msg.optionalCallbacks ?? []) {
+    callbacks[name] = optionalRawCallbacks[name];
+  }
+  const optionalSubscriptions = new Set(msg.optionalSubscriptions ?? []);
+  for (const entry of SUBSCRIPTION_DISPATCH) {
+    if (!optionalSubscriptions.has(entry.protocol)) continue;
+    callbacks[entry.callback] =
+      entry.payload === "required"
+        ? (payload: Uint8Array, sendItem: (value: unknown) => void) =>
+            startSubscription(entry.protocol, payload, sendItem)
+        : (sendItem: (value: unknown) => void) =>
+            startSubscription(entry.protocol, null, sendItem);
+  }
+  if (msg.chainConnect) {
+    callbacks.chainConnect = chainConnect;
+  }
+  callbacks.emitFrame = (frame: Uint8Array): void => {
+    postToMain({ kind: "frame", bytes: frame });
+  };
+  callbacks.dispose = (): void => {
+    // Main thread terminates the worker, no separate cleanup needed here.
+  };
+  return callbacks;
+}
+
+let core: WasmCore | null = null;
+let wasm: WasmModuleShape | null = null;
+
+(async () => {
+  try {
+    wasm = await wasmModulePromise;
+    await wasm.default();
+    postToMain({ kind: "loaded" });
+  } catch (err) {
+    postToMain({ kind: "fatalError", error: errorMessage(err) });
+  }
+})();
+
+ctx.addEventListener("message", (ev: MessageEvent<MainToWorker>) => {
+  const msg = ev.data;
+  switch (msg.kind) {
+    case "init":
+      if (!wasm) {
+        postToMain({
+          kind: "fatalError",
+          error: "init received before WASM loaded",
+        });
+        break;
+      }
+      if (core) {
+        postToMain({
+          kind: "fatalError",
+          error: "init: core already initialized",
+        });
+        break;
+      }
+      wasm.setLogLevel?.(msg.logLevel);
+      try {
+        core = new wasm.WasmTrUApiCore(buildRawCallbacks(msg), msg.runtimeConfig);
+        postToMain({ kind: "ready" });
+      } catch (err) {
+        postToMain({ kind: "fatalError", error: `init: ${errorMessage(err)}` });
+      }
+      break;
+    case "setLogLevel":
+      wasm?.setLogLevel?.(msg.level);
+      break;
+    case "frame":
+      void handleFrame(msg.bytes);
+      break;
+    case "disconnect":
+      void handleDisconnect(msg.requestId);
+      break;
+    case "cancelLogin":
+      core?.cancelLogin();
+      break;
+    case "callbackResponse": {
+      const cb = pendingCallbacks.get(msg.requestId);
+      if (cb) {
+        pendingCallbacks.delete(msg.requestId);
+        cb(
+          msg.ok
+            ? { ok: true, value: msg.value }
+            : { ok: false, error: msg.error },
+        );
+      }
+      break;
+    }
+    case "subscriptionItem": {
+      const listener = subscriptionItemListeners.get(msg.subId);
+      if (listener) listener(msg.value);
+      break;
+    }
+    case "chainConnectAck": {
+      const cb = chainConnectAcks.get(msg.connId);
+      if (cb) {
+        chainConnectAcks.delete(msg.connId);
+        cb(msg.ok ? { ok: true } : { ok: false, error: msg.error });
+      }
+      break;
+    }
+    case "chainResponse": {
+      const listener = chainResponseListeners.get(msg.connId);
+      if (listener) listener(msg.json);
+      break;
+    }
+    case "dispose":
+      try {
+        core?.dispose();
+        core?.free();
+      } catch (err) {
+        postToMain({ kind: "disposeError", error: errorMessage(err) });
+      }
+      core = null;
+      break;
+    default: {
+      const { kind } = msg as { kind?: unknown };
+      console.warn(
+        `[truapi worker-runtime] unknown message kind: ${String(kind)}`,
+      );
+    }
+  }
+});
+
+async function handleDisconnect(requestId: number): Promise<void> {
+  if (!core) {
+    postToMain({
+      kind: "disconnectResponse",
+      requestId,
+      ok: false,
+      error: "disconnect received before core is ready",
+    });
+    return;
+  }
+  try {
+    await core.disconnect();
+    postToMain({ kind: "disconnectResponse", requestId, ok: true });
+  } catch (err) {
+    postToMain({
+      kind: "disconnectResponse",
+      requestId,
+      ok: false,
+      error: errorMessage(err),
+    });
+  }
+}
+
+async function handleFrame(bytes: Uint8Array): Promise<void> {
+  if (!core) {
+    postToMain({
+      kind: "frameError",
+      error: "frame received before core is ready",
+    });
+    return;
+  }
+  try {
+    await core.receiveFromProduct(bytes);
+  } catch (err) {
+    postToMain({
+      kind: "frameError",
+      error: errorMessage(err),
+    });
+  }
+}
diff --git a/js/packages/truapi-host-wasm/test/create-iframe-host.test.mjs b/js/packages/truapi-host-wasm/test/create-iframe-host.test.mjs
new file mode 100644
index 00000000..4659f4d4
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/create-iframe-host.test.mjs
@@ -0,0 +1,261 @@
+// Verify that `createIframeHost` hands a MessagePort back through `onPort`,
+// constructs an iframe with the expected attributes, and posts the
+// `truapi-init` handshake after the iframe reports readiness.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createIframeHost } from "../dist/web/index.js";
+
+function setupFakeDom() {
+  // Track listeners on the synthetic `window` and the iframe so the
+  // test can simulate the iframe `load` event after construction.
+  const iframeListeners = new Map();
+  const windowListeners = new Map();
+  const windowRemove = test.mock.fn();
+  const contentPostMessage = test.mock.fn();
+
+  const contentWindow = {
+    postMessage: contentPostMessage,
+  };
+
+  const iframe = {
+    style: {},
+    setAttribute: test.mock.fn(),
+    addEventListener: (name, fn) => {
+      iframeListeners.set(name, fn);
+    },
+    removeEventListener: () => {},
+    remove: test.mock.fn(),
+    referrerPolicy: "",
+    credentialless: false,
+    src: "",
+    contentWindow,
+  };
+
+  const container = {
+    appendChild: test.mock.fn(),
+  };
+
+  // Spy on both MessageChannel ports so dispose() teardown is observable.
+  const port1 = { postMessage: test.mock.fn(), close: test.mock.fn() };
+  const port2 = { postMessage: test.mock.fn(), close: test.mock.fn() };
+  globalThis.MessageChannel = class {
+    constructor() {
+      this.port1 = port1;
+      this.port2 = port2;
+    }
+  };
+
+  globalThis.document = {
+    createElement: (tag) => {
+      assert.equal(tag, "iframe");
+      return iframe;
+    },
+  };
+  globalThis.window = {
+    location: { href: "http://localhost:5174/" },
+    addEventListener: (name, fn) => {
+      windowListeners.set(name, fn);
+    },
+    removeEventListener: windowRemove,
+  };
+
+  return {
+    iframe,
+    container,
+    contentPostMessage,
+    contentWindow,
+    iframeListeners,
+    windowListeners,
+    windowRemove,
+    port1,
+    port2,
+  };
+}
+
+function teardownFakeDom() {
+  delete globalThis.document;
+  delete globalThis.window;
+  delete globalThis.MessageChannel;
+}
+
+test("createIframeHost hands back a MessagePort and configures the iframe", () => {
+  const {
+    iframe,
+    container,
+    iframeListeners,
+    windowRemove,
+    port1,
+    port2,
+  } = setupFakeDom();
+
+  try {
+    let receivedPort = null;
+    const host = createIframeHost({
+      iframeUrl: "http://localhost:5174/",
+      container,
+      onPort: (port) => {
+        receivedPort = port;
+      },
+    });
+
+    assert.ok(receivedPort, "onPort must fire synchronously");
+    assert.equal(typeof receivedPort.postMessage, "function");
+    assert.equal(container.appendChild.mock.callCount(), 1);
+    assert.equal(host.iframe, iframe);
+    assert.equal(iframe.credentialless, true);
+    assert.equal(iframe.src, "http://localhost:5174/");
+    assert.equal(
+      iframeListeners.has("load"),
+      false,
+      "port transfer waits for explicit iframe readiness",
+    );
+
+    host.dispose();
+    assert.equal(iframe.remove.mock.callCount(), 1);
+    assert.equal(
+      windowRemove.mock.callCount(),
+      1,
+      "dispose removes the window message listener",
+    );
+    assert.equal(windowRemove.mock.calls[0].arguments[0], "message");
+    assert.equal(
+      port1.close.mock.callCount(),
+      1,
+      "host port closed on dispose",
+    );
+    assert.equal(
+      port2.close.mock.callCount(),
+      1,
+      "product port closed on dispose",
+    );
+  } finally {
+    teardownFakeDom();
+  }
+});
+
+test("createIframeHost sends truapi-init on a same-origin playground-ready message", () => {
+  const { contentPostMessage, windowListeners, contentWindow } = setupFakeDom();
+
+  try {
+    createIframeHost({
+      iframeUrl: "http://localhost:5174/",
+      container: { appendChild: () => {} },
+      onPort: () => {},
+    });
+
+    const onMessage = windowListeners.get("message");
+    assert.ok(onMessage, "window message listener must be registered");
+
+    // Wrong source is dropped.
+    onMessage({
+      source: { other: true },
+      origin: "http://localhost:5174",
+      data: { type: "truapi-playground-ready" },
+    });
+    assert.equal(
+      contentPostMessage.mock.callCount(),
+      0,
+      "wrong source dropped",
+    );
+
+    // Wrong origin is dropped.
+    onMessage({
+      source: contentWindow,
+      origin: "http://evil.example",
+      data: { type: "truapi-playground-ready" },
+    });
+    assert.equal(
+      contentPostMessage.mock.callCount(),
+      0,
+      "wrong origin dropped",
+    );
+
+    // Correct source + origin triggers the init handshake.
+    onMessage({
+      source: contentWindow,
+      origin: "http://localhost:5174",
+      data: { type: "truapi-playground-ready" },
+    });
+    assert.equal(contentPostMessage.mock.callCount(), 1, "ready triggers init");
+    const [body, origin] = contentPostMessage.mock.calls[0].arguments;
+    assert.deepEqual(body, { type: "truapi-init" });
+    assert.equal(origin, "*");
+
+    // The handshake is idempotent across repeated ready events too.
+    onMessage({
+      source: contentWindow,
+      origin: "http://localhost:5174",
+      data: { type: "truapi-playground-ready" },
+    });
+    assert.equal(contentPostMessage.mock.callCount(), 1, "init sent only once");
+  } finally {
+    teardownFakeDom();
+  }
+});
+
+test("createIframeHost accepts playground-ready from a credentialless opaque origin", () => {
+  const { contentPostMessage, windowListeners, contentWindow } = setupFakeDom();
+
+  try {
+    createIframeHost({
+      iframeUrl: "http://localhost:5174/",
+      container: { appendChild: () => {} },
+      onPort: () => {},
+    });
+
+    const onMessage = windowListeners.get("message");
+    assert.ok(onMessage, "window message listener must be registered");
+
+    onMessage({
+      source: contentWindow,
+      origin: "null",
+      data: { type: "truapi-playground-ready" },
+    });
+    assert.equal(
+      contentPostMessage.mock.callCount(),
+      1,
+      "opaque credentialless origin triggers init",
+    );
+    const [, origin] = contentPostMessage.mock.calls[0].arguments;
+    assert.equal(origin, "*");
+  } finally {
+    teardownFakeDom();
+  }
+});
+
+test("createIframeHost rejects a mismatched allowedOrigin", () => {
+  setupFakeDom();
+  try {
+    assert.throws(
+      () =>
+        createIframeHost({
+          iframeUrl: "http://localhost:5174/",
+          container: { appendChild: () => {} },
+          onPort: () => {},
+          allowedOrigin: "http://localhost:9999",
+        }),
+      /origin policy mismatch/,
+    );
+  } finally {
+    teardownFakeDom();
+  }
+});
+
+test("createIframeHost rejects non-http(s) iframe URLs", () => {
+  setupFakeDom();
+  try {
+    assert.throws(
+      () =>
+        createIframeHost({
+          iframeUrl: "file:///etc/passwd",
+          container: { appendChild: () => {} },
+          onPort: () => {},
+        }),
+      /only allows http\(s\)/,
+    );
+  } finally {
+    teardownFakeDom();
+  }
+});
diff --git a/js/packages/truapi-host-wasm/test/dispatcher-roundtrip.test.mjs b/js/packages/truapi-host-wasm/test/dispatcher-roundtrip.test.mjs
new file mode 100644
index 00000000..3b6d7bbc
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/dispatcher-roundtrip.test.mjs
@@ -0,0 +1,205 @@
+// Smoke test that the dispatcher re-export from @parity/truapi-host-wasm
+// routes inbound request frames to a registered handler and emits a
+// response frame back through the provider, end-to-end.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { encodeWireMessage, decodeWireMessage } from "@parity/truapi";
+import { createHostServer } from "../dist/index.js";
+
+function makeRecordingProvider() {
+  const listeners = new Set();
+  const closeListeners = new Set();
+  const sent = [];
+  return {
+    sent,
+    provider: {
+      postMessage(bytes) {
+        sent.push(bytes);
+      },
+      subscribe(callback) {
+        listeners.add(callback);
+        return () => listeners.delete(callback);
+      },
+      subscribeClose(callback) {
+        closeListeners.add(callback);
+        return () => closeListeners.delete(callback);
+      },
+      dispose() {
+        listeners.clear();
+        closeListeners.clear();
+      },
+    },
+    deliver(message) {
+      for (const listener of [...listeners]) listener(message);
+    },
+    triggerClose(error) {
+      for (const listener of [...closeListeners]) listener(error);
+    },
+  };
+}
+
+test("createHostServer dispatches a request id to the matching entry and emits a response", async () => {
+  const requestId = 7;
+  const responseId = 8;
+  const { provider, sent, deliver } = makeRecordingProvider();
+
+  const entries = [
+    {
+      kind: "request",
+      ids: { request: requestId, response: responseId },
+      async handle(ctx, payload) {
+        assert.equal(typeof ctx.requestId, "string");
+        // Echo with one extra byte so the test asserts that the right
+        // bytes flowed through.
+        const out = new Uint8Array(payload.length + 1);
+        out.set(payload);
+        out[payload.length] = 42;
+        return out;
+      },
+    },
+  ];
+
+  const server = createHostServer(provider, entries);
+
+  const inboundFrame = encodeWireMessage({
+    requestId: "req-1",
+    payload: { id: requestId, value: new Uint8Array([1, 2, 3]) },
+  });
+  assert.ok(inboundFrame.isOk(), "inbound frame must encode");
+  deliver(inboundFrame.value);
+
+  // Allow the handler microtask + send to resolve.
+  await new Promise((r) => setImmediate(r));
+
+  assert.equal(sent.length, 1, "exactly one response emitted");
+  const decoded = decodeWireMessage(sent[0]);
+  assert.ok(decoded.isOk(), "response frame must decode");
+  assert.equal(decoded.value.requestId, "req-1");
+  assert.equal(decoded.value.payload.id, responseId);
+  assert.deepEqual(
+    Array.from(decoded.value.payload.value),
+    [1, 2, 3, 42],
+    "payload should echo + extra byte",
+  );
+
+  server.dispose();
+});
+
+test("a rejecting request handler triggers onRequestHandlerError and emits no frame", async () => {
+  const { provider, sent, deliver } = makeRecordingProvider();
+
+  const errors = [];
+  const entries = [
+    {
+      kind: "request",
+      ids: { request: 7, response: 8 },
+      async handle() {
+        throw new Error("handler boom");
+      },
+    },
+  ];
+  const server = createHostServer(provider, entries, {
+    onRequestHandlerError: (ids, error, ctx) => {
+      errors.push({ ids, error, ctx });
+    },
+  });
+
+  const frame = encodeWireMessage({
+    requestId: "req-err",
+    payload: { id: 7, value: new Uint8Array([1]) },
+  });
+  assert.ok(frame.isOk());
+  deliver(frame.value);
+  await new Promise((r) => setImmediate(r));
+
+  assert.equal(errors.length, 1, "onRequestHandlerError fired once");
+  assert.equal(errors[0].error.message, "handler boom");
+  assert.deepEqual(errors[0].ids, { request: 7, response: 8 });
+  assert.equal(errors[0].ctx.requestId, "req-err");
+  assert.equal(sent.length, 0, "no response frame on handler rejection");
+
+  server.dispose();
+});
+
+test("a frame with an unregistered id triggers onUnknownFrame", () => {
+  const { provider, sent, deliver } = makeRecordingProvider();
+
+  const unknown = [];
+  const server = createHostServer(provider, [], {
+    onUnknownFrame: (payload) => unknown.push(payload),
+  });
+
+  const frame = encodeWireMessage({
+    requestId: "req-unknown",
+    payload: { id: 200, value: new Uint8Array([9, 9]) },
+  });
+  assert.ok(frame.isOk());
+  deliver(frame.value);
+
+  assert.equal(unknown.length, 1, "onUnknownFrame fired once");
+  assert.equal(unknown[0].id, 200);
+  assert.deepEqual(Array.from(unknown[0].value), [9, 9]);
+  assert.equal(sent.length, 0, "no frame emitted for an unknown id");
+
+  server.dispose();
+});
+
+test("a truncated/garbage buffer is dropped without throwing or sending", () => {
+  const { provider, sent, deliver } = makeRecordingProvider();
+
+  const unknown = [];
+  const handlerErrors = [];
+  const server = createHostServer(provider, [], {
+    onUnknownFrame: (payload) => unknown.push(payload),
+    onRequestHandlerError: (_ids, error) => handlerErrors.push(error),
+  });
+
+  // A compact-length prefix that promises more bytes than exist.
+  assert.doesNotThrow(() => deliver(new Uint8Array([0xff, 0xff, 0xff, 0xff])));
+
+  assert.equal(sent.length, 0, "no frame emitted for a garbage buffer");
+  assert.equal(unknown.length, 0, "decode failure is not an unknown frame");
+  assert.equal(
+    handlerErrors.length,
+    0,
+    "decode failure does not reach handlers",
+  );
+
+  server.dispose();
+});
+
+test("firing the provider close callback disposes the server", async () => {
+  const recording = makeRecordingProvider();
+  const { provider, sent, deliver, triggerClose } = recording;
+
+  let handled = 0;
+  const entries = [
+    {
+      kind: "request",
+      ids: { request: 7, response: 8 },
+      async handle(_ctx, payload) {
+        handled += 1;
+        return payload;
+      },
+    },
+  ];
+  const server = createHostServer(provider, entries);
+
+  triggerClose(new Error("provider gone"));
+
+  const frame = encodeWireMessage({
+    requestId: "after-close",
+    payload: { id: 7, value: new Uint8Array([1]) },
+  });
+  assert.ok(frame.isOk());
+  deliver(frame.value);
+  await new Promise((r) => setImmediate(r));
+
+  assert.equal(handled, 0, "inbound frames are ignored after close");
+  assert.equal(sent.length, 0, "no frames emitted after close");
+
+  // dispose remains idempotent after a close-driven teardown.
+  server.dispose();
+});
diff --git a/js/packages/truapi-host-wasm/test/node-wasm-provider.test.mjs b/js/packages/truapi-host-wasm/test/node-wasm-provider.test.mjs
new file mode 100644
index 00000000..70354c11
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/node-wasm-provider.test.mjs
@@ -0,0 +1,225 @@
+// Smoke test that `createNodeWasmProvider` instantiates the WASM core,
+// returns a usable `Provider`, and disposes cleanly without leaking
+// resources back to the caller.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  encodeWireMessage,
+  decodeWireMessage,
+  VersionedHostFeatureSupportedRequest,
+  HostFeatureSupportedResponse,
+  GenericError,
+  scale as S,
+} from "@parity/truapi";
+import { SYSTEM_FEATURE_SUPPORTED } from "@parity/truapi/wire-table";
+
+import { createNodeWasmProvider } from "../dist/index.js";
+
+function makeCallbacks(overrides = {}) {
+  const noopSubscribe = () => () => {};
+  return {
+    navigateTo: async () => {},
+    pushNotification: async () => 0,
+    devicePermission: async () => false,
+    remotePermission: async () => false,
+    featureSupported: async () => false,
+    localStorageRead: async () => undefined,
+    localStorageWrite: async () => {},
+    localStorageClear: async () => {},
+    clearSession: async () => {},
+    preimageLookupSubscribe: noopSubscribe,
+    dispose: () => {},
+    ...overrides,
+  };
+}
+
+function runtimeConfig(overrides = {}) {
+  return {
+    productLabel: "dotli",
+    productId: "dotli.dot",
+    siteId: "dot.li",
+    hostName: "Polkadot Web",
+    hostIcon: "https://dot.li/dotli.png",
+    hostVersion: "0.5.0",
+    platformType: "node",
+    platformVersion: process.versions.node,
+    peopleChainGenesisHash:
+      "0xa22a2424d2cbf561eaecf7da8b1b548fa9d1939f60265e942b1049616a012f71",
+    pairingDeeplinkScheme: "polkadotapp",
+    ...overrides,
+  };
+}
+
+test("createNodeWasmProvider returns a usable Provider", async () => {
+  const provider = await createNodeWasmProvider(makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+  assert.equal(typeof provider.postMessage, "function");
+  assert.equal(typeof provider.subscribe, "function");
+  assert.equal(typeof provider.disconnect, "function");
+  assert.equal(typeof provider.dispose, "function");
+
+  // Subscribe and immediately unsubscribe to exercise the listener
+  // bookkeeping without needing a valid frame.
+  const unsubscribe = provider.subscribe(() => {});
+  unsubscribe();
+
+  provider.dispose();
+});
+
+test("createNodeWasmProvider exposes core disconnect", async () => {
+  let clears = 0;
+  const provider = await createNodeWasmProvider(
+    makeCallbacks({
+      clearSession: async () => {
+        clears += 1;
+      },
+    }),
+    {
+      runtimeConfig: runtimeConfig(),
+    },
+  );
+
+  await provider.disconnect();
+
+  assert.equal(clears, 1);
+  provider.dispose();
+});
+
+test("createNodeWasmProvider validates runtimeConfig in the WASM core", async () => {
+  await assert.rejects(
+    () =>
+      createNodeWasmProvider(makeCallbacks(), {
+        runtimeConfig: runtimeConfig({
+          peopleChainGenesisHash: "0x1234",
+        }),
+      }),
+    /runtimeConfig\.peopleChainGenesisHash: expected 32-byte hex string/,
+  );
+});
+
+test("createNodeWasmProvider requires runtimeConfig", async () => {
+  await assert.rejects(
+    () => createNodeWasmProvider(makeCallbacks(), undefined),
+    /runtimeConfig is required/,
+  );
+});
+
+test("createNodeWasmProvider rejects empty runtime config identity fields", async () => {
+  await assert.rejects(
+    () =>
+      createNodeWasmProvider(makeCallbacks(), {
+        runtimeConfig: runtimeConfig({
+          productId: " ",
+        }),
+      }),
+    /runtimeConfig\.productId must not be empty/,
+  );
+});
+
+test("createNodeWasmProvider rejects non-HTTPS runtime host icons", async () => {
+  await assert.rejects(
+    () =>
+      createNodeWasmProvider(makeCallbacks(), {
+        runtimeConfig: runtimeConfig({
+          hostIcon: "http://localhost:3000/dotli.png",
+        }),
+      }),
+    /runtimeConfig\.hostIcon must use https scheme/,
+  );
+});
+
+test("createNodeWasmProvider dispose is idempotent", async () => {
+  const provider = await createNodeWasmProvider(makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+  const closes = [];
+  provider.subscribeClose((error) => closes.push(error));
+  provider.dispose();
+  // Second call must not throw.
+  provider.dispose();
+  assert.equal(closes.length, 1);
+  assert.match(closes[0].message, /disposed/);
+
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+});
+
+test("createNodeWasmProvider round-trips a featureSupported request through the WASM core", async () => {
+  const callbacks = makeCallbacks();
+  callbacks.featureSupported = async () => true;
+  const provider = await createNodeWasmProvider(callbacks, {
+    runtimeConfig: runtimeConfig(),
+  });
+
+  const frames = [];
+  provider.subscribe((bytes) => frames.push(bytes));
+
+  const payload = VersionedHostFeatureSupportedRequest.enc({
+    tag: "V1",
+    value: { tag: "Chain", value: { genesisHash: "0x00" } },
+  });
+  const inbound = encodeWireMessage({
+    requestId: "rt-1",
+    payload: { id: SYSTEM_FEATURE_SUPPORTED.request, value: payload },
+  });
+  assert.ok(inbound.isOk(), "request frame must encode");
+  provider.postMessage(inbound.value);
+
+  // Let the WASM dispatch + host callback + emit cycle settle.
+  await new Promise((r) => setTimeout(r, 50));
+
+  assert.equal(frames.length, 1, "exactly one response frame emitted");
+  const decoded = decodeWireMessage(frames[0]);
+  assert.ok(decoded.isOk(), "response frame must decode");
+  assert.equal(decoded.value.requestId, "rt-1");
+  assert.equal(decoded.value.payload.id, SYSTEM_FEATURE_SUPPORTED.response);
+
+  const responseCodec = S.indexedTaggedUnion({
+    V1: [0, S.Result(HostFeatureSupportedResponse, GenericError)],
+  });
+  const response = responseCodec.dec(decoded.value.payload.value);
+  assert.deepEqual(response, {
+    tag: "V1",
+    value: { success: true, value: { supported: true } },
+  });
+
+  provider.dispose();
+});
+
+test("createNodeWasmProvider surfaces a rejected receiveFromProduct through subscribeClose", async () => {
+  const provider = await createNodeWasmProvider(makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+
+  const closes = [];
+  provider.subscribeClose((error) => closes.push(error));
+  const frames = [];
+  provider.subscribe((bytes) => frames.push(bytes));
+
+  // A garbage buffer the core cannot decode rejects receiveFromProduct.
+  provider.postMessage(new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff]));
+  await new Promise((r) => setTimeout(r, 50));
+
+  assert.equal(closes.length, 1, "close listener fires once on decode failure");
+  assert.ok(closes[0] instanceof Error);
+  assert.equal(frames.length, 0, "no response frame on a rejected frame");
+
+  // Close is terminal: further frames are dropped and close fires only once.
+  provider.postMessage(new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff]));
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(closes.length, 1, "close listener does not fire again");
+
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+
+  provider.dispose();
+});
diff --git a/js/packages/truapi-host-wasm/test/preload-bridge.test.mjs b/js/packages/truapi-host-wasm/test/preload-bridge.test.mjs
new file mode 100644
index 00000000..68df840e
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/preload-bridge.test.mjs
@@ -0,0 +1,147 @@
+// Verify `createElectronProvider` adapts an Electron-style port into a
+// TrUAPI Provider: subscribers receive inbound binary frames, outbound
+// frames flow back through `port.postMessage`, and `dispose` closes the
+// port and clears listeners.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createElectronProvider } from "../dist/electron/index.js";
+
+function makeFakePort() {
+  const messageListeners = new Set();
+  const closeListeners = new Set();
+  const sent = [];
+  const offCalls = [];
+  let closed = false;
+  return {
+    sent,
+    offCalls,
+    isClosed: () => closed,
+    deliverMessage(data) {
+      for (const listener of [...messageListeners]) listener({ data });
+    },
+    deliverClose() {
+      for (const listener of [...closeListeners]) listener();
+    },
+    api: {
+      postMessage(message) {
+        sent.push(message);
+      },
+      on(event, handler) {
+        if (event === "message") messageListeners.add(handler);
+        else if (event === "close") closeListeners.add(handler);
+        return this;
+      },
+      off(event, handler) {
+        offCalls.push(event);
+        if (event === "message") messageListeners.delete(handler);
+        else if (event === "close") closeListeners.delete(handler);
+        return this;
+      },
+      start() {},
+      close() {
+        closed = true;
+      },
+    },
+  };
+}
+
+test("createElectronProvider forwards inbound frames to subscribers and outbound frames to the port", () => {
+  const fake = makeFakePort();
+  const provider = createElectronProvider({ port: fake.api });
+
+  const received = [];
+  const unsubscribe = provider.subscribe((message) => {
+    received.push(message);
+  });
+
+  const inbound = new Uint8Array([10, 20, 30]);
+  fake.deliverMessage(inbound);
+  // Non-binary frames are ignored.
+  fake.deliverMessage({ type: "ignored" });
+
+  assert.equal(received.length, 1);
+  assert.deepEqual(Array.from(received[0]), [10, 20, 30]);
+
+  const outbound = new Uint8Array([1, 2]);
+  provider.postMessage(outbound);
+  assert.equal(fake.sent.length, 1);
+  assert.deepEqual(Array.from(fake.sent[0]), [1, 2]);
+
+  unsubscribe();
+  fake.deliverMessage(new Uint8Array([99]));
+  // Unsubscribed, length should not grow.
+  assert.equal(received.length, 1);
+
+  provider.dispose();
+  assert.equal(fake.isClosed(), true, "dispose closes the underlying port");
+});
+
+test("createElectronProvider notifies close subscribers when the port closes", () => {
+  const fake = makeFakePort();
+  const provider = createElectronProvider({ port: fake.api });
+
+  const closes = [];
+  provider.subscribeClose((error) => closes.push(error));
+
+  fake.deliverClose();
+  assert.equal(closes.length, 1);
+  assert.ok(closes[0] instanceof Error);
+
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+
+  provider.dispose();
+});
+
+test("dispose removes both port listeners and blocks further traffic", () => {
+  const fake = makeFakePort();
+  const provider = createElectronProvider({ port: fake.api });
+
+  const received = [];
+  provider.subscribe((message) => received.push(message));
+
+  provider.dispose();
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+  assert.deepEqual(
+    [...fake.offCalls].sort(),
+    ["close", "message"],
+    "dispose detaches both the message and close handlers",
+  );
+
+  // postMessage after dispose is a no-op.
+  provider.postMessage(new Uint8Array([1, 2]));
+  assert.equal(fake.sent.length, 0, "no frames sent after dispose");
+
+  // Inbound frames after dispose never reach subscribers.
+  fake.deliverMessage(new Uint8Array([3, 4]));
+  assert.equal(received.length, 0, "no frames delivered after dispose");
+});
+
+test("a peer-initiated close detaches port listeners and blocks postMessage", () => {
+  const fake = makeFakePort();
+  const provider = createElectronProvider({ port: fake.api });
+
+  provider.subscribeClose(() => {});
+  fake.deliverClose();
+
+  assert.deepEqual(
+    [...fake.offCalls].sort(),
+    ["close", "message"],
+    "peer close detaches both handlers",
+  );
+
+  // postMessage after a peer-initiated close is a no-op.
+  provider.postMessage(new Uint8Array([5]));
+  assert.equal(fake.sent.length, 0, "no frames sent after a peer close");
+
+  provider.dispose();
+});
diff --git a/js/packages/truapi-host-wasm/test/typed-callbacks.test.mjs b/js/packages/truapi-host-wasm/test/typed-callbacks.test.mjs
new file mode 100644
index 00000000..bfea6719
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/typed-callbacks.test.mjs
@@ -0,0 +1,269 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  HostDevicePermissionRequest,
+  HostFeatureSupportedRequest,
+  HostPushNotificationRequest,
+  RemotePermissionRequest,
+} from "@parity/truapi";
+
+import {
+  createUnavailableCallbacks,
+  createWasmRawCallbacks,
+} from "../dist/index.js";
+
+const GENESIS = `0x${"11".repeat(32)}`;
+
+function settle() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+test("createUnavailableCallbacks rejects storage write paths", async () => {
+  const callbacks = createUnavailableCallbacks();
+
+  await assert.rejects(
+    () => callbacks.localStorageWrite("key", new Uint8Array([1])),
+    /localStorageWrite unavailable/,
+  );
+  await assert.rejects(
+    () => callbacks.localStorageClear("key"),
+    /localStorageClear unavailable/,
+  );
+  assert.equal(await callbacks.localStorageRead("key"), undefined);
+});
+
+test("createWasmRawCallbacks decodes SCALE request callbacks into typed host calls", async () => {
+  const writes = [];
+  const clears = [];
+  const cancelled = [];
+  const raw = createWasmRawCallbacks({
+    pushNotification: async (notification) => ({
+      id: notification.text.length,
+    }),
+    cancelNotification: async (id) => {
+      cancelled.push(id);
+    },
+    devicePermission: async (request) => ({ granted: request === "Camera" }),
+    remotePermission: async (request) => ({
+      granted: request.permission.tag === "ChainSubmit",
+    }),
+    featureSupported: async (request) => ({
+      supported:
+        request.tag === "Chain" && request.value.genesisHash === GENESIS,
+    }),
+    read: async (key) => new TextEncoder().encode(`read:${key}`),
+    write: async (key, value) => {
+      writes.push([key, [...value]]);
+    },
+    clear: async (key) => {
+      clears.push(key);
+    },
+  });
+
+  assert.equal(
+    await raw.pushNotification(
+      HostPushNotificationRequest.enc({
+        text: "hello",
+        deeplink: undefined,
+        scheduledAt: undefined,
+      }),
+    ),
+    5,
+  );
+  assert.equal(
+    await raw.devicePermission(HostDevicePermissionRequest.enc("Camera")),
+    true,
+  );
+  assert.equal(
+    await raw.remotePermission(
+      RemotePermissionRequest.enc({ permission: { tag: "ChainSubmit" } }),
+    ),
+    true,
+  );
+  assert.equal(
+    await raw.featureSupported(
+      HostFeatureSupportedRequest.enc({
+        tag: "Chain",
+        value: { genesisHash: GENESIS },
+      }),
+    ),
+    true,
+  );
+  assert.deepEqual(
+    await raw.localStorageRead("session"),
+    new TextEncoder().encode("read:session"),
+  );
+
+  await raw.localStorageWrite("session", new Uint8Array([1, 2, 3]));
+  await raw.localStorageClear("session");
+  await raw.cancelNotification?.(9);
+
+  assert.deepEqual(writes, [["session", [1, 2, 3]]]);
+  assert.deepEqual(clears, ["session"]);
+  assert.deepEqual(cancelled, [9]);
+});
+
+test("createWasmRawCallbacks bridges lifecycle, confirmations, and preimage callbacks", async () => {
+  const calls = [];
+  async function* sessionTicks() {
+    yield { success: true, value: undefined };
+    yield { success: true, value: undefined };
+  }
+  async function* preimages() {
+    yield { success: true, value: undefined };
+    yield { success: true, value: new Uint8Array([4, 5, 6]) };
+  }
+
+  const raw = createWasmRawCallbacks({
+    authStateChanged: (state) => {
+      calls.push(["authStateChanged", state]);
+    },
+    readSession: async () => new Uint8Array([1, 2, 3]),
+    writeSession: async (value) => {
+      calls.push(["writeSession", [...value]]);
+    },
+    clearSession: async () => {
+      calls.push(["clearSession"]);
+    },
+    subscribeSessionStore: () => sessionTicks(),
+    confirmSignPayload: async (payload) => payload[0] === 1,
+    confirmSignRaw: async (payload) => payload[0] === 2,
+    confirmCreateTransaction: async (payload) => payload[0] === 3,
+    confirmAccountAlias: async (payload) => payload[0] === 4,
+    confirmResourceAllocation: async (payload) => payload[0] === 5,
+    confirmPreimageSubmit: async (size) => {
+      calls.push(["confirmPreimageSubmit", size]);
+    },
+    submitPreimage: async (value) => {
+      calls.push(["submitPreimage", [...value]]);
+      return new Uint8Array([7, 8, 9]);
+    },
+    lookupPreimage: (key) => {
+      calls.push(["lookupPreimage", [...key]]);
+      return preimages();
+    },
+  });
+
+  const sessionEvents = [];
+  const disposeSession = raw.subscribeSessionStore?.(() =>
+    sessionEvents.push("tick"),
+  );
+  const preimageEvents = [];
+  const disposePreimages = raw.preimageLookupSubscribe(
+    new Uint8Array([9]),
+    (value) => preimageEvents.push(value ? [...value] : null),
+  );
+
+  raw.authStateChanged?.({
+    tag: "Pairing",
+    value: { deeplink: "polkadotapp://example" },
+  });
+  assert.deepEqual(await raw.readSession?.(), new Uint8Array([1, 2, 3]));
+  await raw.writeSession?.(new Uint8Array([3, 2, 1]));
+  await raw.clearSession?.();
+  assert.equal(await raw.confirmSignPayload?.(new Uint8Array([1])), true);
+  assert.equal(await raw.confirmSignRaw?.(new Uint8Array([2])), true);
+  assert.equal(await raw.confirmCreateTransaction?.(new Uint8Array([3])), true);
+  assert.equal(await raw.confirmAccountAlias?.(new Uint8Array([4])), true);
+  assert.equal(
+    await raw.confirmResourceAllocation?.(new Uint8Array([5])),
+    true,
+  );
+  await raw.confirmPreimageSubmit(42);
+  assert.deepEqual(
+    await raw.submitPreimage(new Uint8Array([6])),
+    new Uint8Array([7, 8, 9]),
+  );
+
+  await settle();
+  await settle();
+
+  assert.deepEqual(sessionEvents, ["tick", "tick"]);
+  assert.deepEqual(preimageEvents, [null, [4, 5, 6]]);
+  assert.deepEqual(calls, [
+    ["lookupPreimage", [9]],
+    [
+      "authStateChanged",
+      { tag: "Pairing", value: { deeplink: "polkadotapp://example" } },
+    ],
+    ["writeSession", [3, 2, 1]],
+    ["clearSession"],
+    ["confirmPreimageSubmit", 42n],
+    ["submitPreimage", [6]],
+  ]);
+
+  disposeSession?.();
+  disposePreimages?.();
+});
+
+test("createWasmRawCallbacks default session-store subscription emits current tick", () => {
+  const raw = createWasmRawCallbacks({});
+  const ticks = [];
+  raw.subscribeSessionStore?.(() => ticks.push("tick"));
+  assert.deepEqual(ticks, ["tick"]);
+});
+
+test("createWasmRawCallbacks default theme and preimage subscriptions emit current values", () => {
+  const raw = createWasmRawCallbacks({});
+  const themes = [];
+  raw.themeSubscribe?.((theme) => themes.push(theme));
+  assert.deepEqual(themes, ["Dark"]);
+
+  const preimages = [];
+  raw.preimageLookupSubscribe(new Uint8Array([1]), (value) =>
+    preimages.push(value),
+  );
+  assert.deepEqual(preimages, [undefined]);
+});
+
+test("createWasmRawCallbacks adapts typed result subscriptions", async () => {
+  async function* themes() {
+    yield { success: true, value: "Dark" };
+    yield { success: true, value: "Light" };
+  }
+
+  const raw = createWasmRawCallbacks({
+    subscribeTheme: () => themes(),
+  });
+  const seen = [];
+  const dispose = raw.themeSubscribe?.((theme) => seen.push(theme));
+
+  await settle();
+  await settle();
+
+  assert.deepEqual(seen, ["Dark", "Light"]);
+  dispose?.();
+});
+
+test("createWasmRawCallbacks bridges typed chain connections", async () => {
+  const sent = [];
+  const responses = ['{"jsonrpc":"2.0","id":1,"result":"ok"}'];
+  const raw = createWasmRawCallbacks({
+    connect: async (genesisHash) => {
+      assert.deepEqual([...genesisHash], Array(32).fill(0x11));
+      return {
+        send(request) {
+          sent.push(request);
+        },
+        async *responses() {
+          yield* responses;
+        },
+      };
+    },
+  });
+
+  assert.equal(typeof raw.chainConnect, "function");
+  const received = [];
+  const connection = await raw.chainConnect?.(GENESIS, (json) =>
+    received.push(json),
+  );
+  assert.ok(connection);
+
+  connection.send('{"jsonrpc":"2.0","id":1,"method":"system_health"}');
+  await settle();
+
+  assert.deepEqual(sent, ['{"jsonrpc":"2.0","id":1,"method":"system_health"}']);
+  assert.deepEqual(received, responses);
+  connection.close();
+});
diff --git a/js/packages/truapi-host-wasm/test/worker-protocol.test.mjs b/js/packages/truapi-host-wasm/test/worker-protocol.test.mjs
new file mode 100644
index 00000000..ece703d8
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/worker-protocol.test.mjs
@@ -0,0 +1,33 @@
+// Sanity test that the worker-protocol module is importable and exports
+// what `createWebWorkerProvider` (from @parity/truapi-host-wasm/web) expects. The
+// real web worker entry-point loads a browser-only WASM bundle, so we
+// cannot boot it under Node; this test verifies the wire-shape of the
+// shared protocol contract instead.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import * as shared from "../dist/index.js";
+import * as workerProtocol from "../dist/worker-protocol.js";
+
+test("worker-protocol exports callback-name tables", () => {
+  assert.deepEqual(Object.keys(workerProtocol), [
+    "CALLBACK_NAMES",
+    "OPTIONAL_CALLBACK_NAMES",
+  ]);
+  assert.ok(workerProtocol.CALLBACK_NAMES.includes("navigateTo"));
+  assert.ok(workerProtocol.OPTIONAL_CALLBACK_NAMES.includes("readSession"));
+  assert.ok(!workerProtocol.OPTIONAL_CALLBACK_NAMES.includes("navigateTo"));
+});
+
+test("@parity/truapi-host-wasm exposes the documented surface", () => {
+  // Dispatcher re-export from @parity/truapi-host.
+  assert.equal(typeof shared.createHostServer, "function");
+  assert.equal(typeof shared.toFlatResponsePayload, "function");
+  assert.equal(typeof shared.toResponsePayload, "function");
+
+  // WASM provider helpers.
+  assert.equal(typeof shared.createWasmProvider, "function");
+  assert.equal(typeof shared.createNodeWasmProvider, "function");
+  assert.equal(typeof shared.createUnavailableCallbacks, "function");
+});
diff --git a/js/packages/truapi-host-wasm/test/worker-provider.test.mjs b/js/packages/truapi-host-wasm/test/worker-provider.test.mjs
new file mode 100644
index 00000000..6cf6f753
--- /dev/null
+++ b/js/packages/truapi-host-wasm/test/worker-provider.test.mjs
@@ -0,0 +1,591 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { HostPushNotificationRequest } from "../../truapi/dist/index.js";
+import { createWasmRawCallbacks } from "../dist/index.js";
+import { createWebWorkerProvider } from "../dist/web/index.js";
+
+class FakeWorker {
+  constructor() {
+    this.listeners = new Map();
+    this.messages = [];
+    this.terminated = false;
+  }
+
+  addEventListener(name, fn) {
+    const listeners = this.listeners.get(name) ?? new Set();
+    listeners.add(fn);
+    this.listeners.set(name, listeners);
+  }
+
+  removeEventListener(name, fn) {
+    this.listeners.get(name)?.delete(fn);
+  }
+
+  postMessage(message) {
+    this.messages.push(message);
+  }
+
+  terminate() {
+    this.terminated = true;
+  }
+
+  emit(message) {
+    for (const listener of this.listeners.get("message") ?? []) {
+      listener({ data: message });
+    }
+  }
+
+  emitError(message) {
+    for (const listener of this.listeners.get("error") ?? []) {
+      listener({ message });
+    }
+  }
+
+  emitMessageError() {
+    for (const listener of this.listeners.get("messageerror") ?? []) {
+      listener({ data: null });
+    }
+  }
+}
+
+function makeCallbacks(overrides = {}) {
+  return {
+    navigateTo: async () => {},
+    pushNotification: async () => 0,
+    devicePermission: async () => false,
+    remotePermission: async () => false,
+    featureSupported: async () => false,
+    localStorageRead: async () => undefined,
+    localStorageWrite: async () => {},
+    localStorageClear: async () => {},
+    ...overrides,
+  };
+}
+
+function runtimeConfig(overrides = {}) {
+  return {
+    productLabel: "dotli",
+    productId: "dotli.dot",
+    siteId: "dot.li",
+    hostName: "Polkadot Web",
+    hostIcon: "https://dot.li/dotli.png",
+    hostVersion: "0.5.0",
+    platformType: "node",
+    platformVersion: process.versions.node,
+    peopleChainGenesisHash:
+      "0xa22a2424d2cbf561eaecf7da8b1b548fa9d1939f60265e942b1049616a012f71",
+    pairingDeeplinkScheme: "polkadotapp",
+    ...overrides,
+  };
+}
+
+async function settle() {
+  await new Promise((resolve) => setImmediate(resolve));
+}
+
+async function readyProvider(worker, options = {}) {
+  const {
+    createWebWorkerProvider: createProvider = createWebWorkerProvider,
+    ...providerOptions
+  } = options;
+  const providerPromise = createProvider(worker, makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+    ...providerOptions,
+  });
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  return providerPromise;
+}
+
+test("createWebWorkerProvider advertises only supplied optional hooks", async () => {
+  const worker = new FakeWorker();
+  const config = runtimeConfig();
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      clearSession: async () => {},
+      readSession: async () => new Uint8Array([1]),
+      authStateChanged: () => {},
+      subscribeSessionStore: () => () => {},
+      preimageLookupSubscribe: () => () => {},
+      chainConnect: () => ({ send: () => {}, close: () => {} }),
+    }),
+    {
+      logLevel: "debug",
+      runtimeConfig: config,
+    },
+  );
+
+  worker.emit({ kind: "loaded" });
+  assert.equal(worker.messages.length, 1);
+  assert.deepEqual(worker.messages[0], {
+    kind: "init",
+    logLevel: "debug",
+    runtimeConfig: config,
+    optionalCallbacks: ["authStateChanged", "readSession", "clearSession"],
+    optionalSubscriptions: ["sessionStoreSubscribe", "preimageLookupSubscribe"],
+    chainConnect: true,
+  });
+
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+  assert.equal(typeof provider.disconnect, "function");
+  assert.equal(typeof provider.cancelLogin, "function");
+
+  provider.dispose();
+});
+
+test("dev global setLogLevel updates every live worker provider", async () => {
+  const previous = globalThis.__truapi;
+  delete globalThis.__truapi;
+  const firstWorker = new FakeWorker();
+  const secondWorker = new FakeWorker();
+  const first = await readyProvider(firstWorker);
+  const second = await readyProvider(secondWorker);
+
+  globalThis.__truapi.setLogLevel("debug");
+
+  assert.deepEqual(firstWorker.messages.at(-1), {
+    kind: "setLogLevel",
+    level: "debug",
+  });
+  assert.deepEqual(secondWorker.messages.at(-1), {
+    kind: "setLogLevel",
+    level: "debug",
+  });
+  assert.equal(globalThis.__truapi.getLogLevel(), "debug");
+  assert.equal(globalThis.__truapi.getProviderCount(), 2);
+
+  globalThis.__truapi.setLogLevel("off");
+  first.dispose();
+  second.dispose();
+  if (previous === undefined) {
+    delete globalThis.__truapi;
+  } else {
+    globalThis.__truapi = previous;
+  }
+});
+
+test("dev global setLogLevel applies to providers created later", async () => {
+  const previous = globalThis.__truapi;
+  delete globalThis.__truapi;
+  const moduleUrl = `../dist/web/create-worker-host-runtime.js?dev-global-${Date.now()}`;
+  const { createWebWorkerProvider: freshCreateWebWorkerProvider } =
+    await import(moduleUrl);
+
+  assert.equal(typeof globalThis.__truapi.setLogLevel, "function");
+  assert.equal(globalThis.__truapi.getProviderCount(), 0);
+  globalThis.__truapi.setLogLevel("trace");
+
+  const firstWorker = new FakeWorker();
+  const first = await readyProvider(firstWorker, {
+    createWebWorkerProvider: freshCreateWebWorkerProvider,
+  });
+  first.dispose();
+
+  const secondWorker = new FakeWorker();
+  const second = await readyProvider(secondWorker, {
+    createWebWorkerProvider: freshCreateWebWorkerProvider,
+  });
+
+  assert.equal(secondWorker.messages[0].kind, "init");
+  assert.equal(secondWorker.messages[0].logLevel, "trace");
+  assert.deepEqual(secondWorker.messages.at(-1), {
+    kind: "setLogLevel",
+    level: "trace",
+  });
+
+  second.dispose();
+  globalThis.__truapi.setLogLevel("off");
+  if (previous === undefined) {
+    delete globalThis.__truapi;
+  } else {
+    globalThis.__truapi = previous;
+  }
+});
+
+test("dev global setLogLevel persists the level to localStorage", async () => {
+  const previousGlobal = globalThis.__truapi;
+  const previousStorage = globalThis.localStorage;
+  delete globalThis.__truapi;
+  const store = new Map();
+  globalThis.localStorage = {
+    getItem: (key) => (store.has(key) ? store.get(key) : null),
+    setItem: (key, value) => store.set(key, String(value)),
+  };
+
+  const worker = new FakeWorker();
+  const provider = await readyProvider(worker);
+
+  globalThis.__truapi.setLogLevel("debug");
+  assert.equal(store.get("truapi:logLevel"), "debug");
+
+  globalThis.__truapi.setLogLevel("off");
+  assert.equal(store.get("truapi:logLevel"), "off");
+
+  provider.dispose();
+  globalThis.localStorage = previousStorage;
+  if (previousGlobal === undefined) {
+    delete globalThis.__truapi;
+  } else {
+    globalThis.__truapi = previousGlobal;
+  }
+});
+
+test("worker provider resolves disconnect responses", async () => {
+  const worker = new FakeWorker();
+  const providerPromise = createWebWorkerProvider(worker, makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  const disconnect = provider.disconnect();
+  const msg = worker.messages.at(-1);
+  assert.equal(msg.kind, "disconnect");
+  assert.equal(typeof msg.requestId, "number");
+
+  worker.emit({
+    kind: "disconnectResponse",
+    requestId: msg.requestId,
+    ok: true,
+  });
+  await disconnect;
+
+  provider.dispose();
+});
+
+test("worker provider dispatches optional callback requests to host hooks", async () => {
+  const worker = new FakeWorker();
+  let clears = 0;
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      clearSession: async () => {
+        clears += 1;
+      },
+    }),
+    {
+      runtimeConfig: runtimeConfig(),
+    },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "callbackRequest",
+    requestId: 7,
+    name: "clearSession",
+    args: [],
+  });
+  await settle();
+
+  assert.equal(clears, 1);
+  assert.deepEqual(worker.messages.at(-1), {
+    kind: "callbackResponse",
+    requestId: 7,
+    ok: true,
+    value: undefined,
+  });
+
+  provider.dispose();
+});
+
+test("worker provider forwards authStateChanged callback requests", async () => {
+  const worker = new FakeWorker();
+  const states = [];
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      authStateChanged: (state) => {
+        states.push(state);
+      },
+    }),
+    {
+      runtimeConfig: runtimeConfig(),
+    },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "callbackRequest",
+    requestId: 3,
+    name: "authStateChanged",
+    args: [
+      {
+        tag: "Connected",
+        value: {
+          connected: true,
+          publicKey: new Uint8Array([1, 2]),
+          liteUsername: "alice",
+        },
+      },
+    ],
+  });
+  await settle();
+
+  assert.deepEqual(states, [
+    {
+      tag: "Connected",
+      value: {
+        connected: true,
+        publicKey: new Uint8Array([1, 2]),
+        liteUsername: "alice",
+      },
+    },
+  ]);
+  assert.deepEqual(worker.messages.at(-1), {
+    kind: "callbackResponse",
+    requestId: 3,
+    ok: true,
+    value: undefined,
+  });
+
+  provider.dispose();
+});
+
+test("worker provider posts cancelLogin to the worker", async () => {
+  const worker = new FakeWorker();
+  const provider = await readyProvider(worker);
+
+  provider.cancelLogin();
+
+  assert.deepEqual(worker.messages.at(-1), { kind: "cancelLogin" });
+  provider.dispose();
+});
+
+test("worker fault terminates the worker and runs the full teardown", async () => {
+  const worker = new FakeWorker();
+  let subscriptionDisposes = 0;
+  let chainCloses = 0;
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      subscribeSessionStore: () => () => {
+        subscriptionDisposes += 1;
+      },
+      chainConnect: () => ({
+        send: () => {},
+        close: () => {
+          chainCloses += 1;
+        },
+      }),
+    }),
+    { runtimeConfig: runtimeConfig() },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "subscriptionStart",
+    subId: 1,
+    name: "sessionStoreSubscribe",
+    payload: null,
+  });
+  worker.emit({ kind: "chainConnectStart", connId: 1, genesisHash: "0xab" });
+  await settle();
+
+  const closes = [];
+  provider.subscribeClose((error) => closes.push(error));
+
+  worker.emitError("boom");
+
+  assert.equal(worker.terminated, true);
+  assert.equal(subscriptionDisposes, 1);
+  assert.equal(chainCloses, 1);
+  assert.equal(closes.length, 1);
+  assert.match(closes[0].message, /boom/);
+
+  // The fault teardown is terminal; a second fault is a no-op.
+  worker.emitError("again");
+  assert.equal(closes.length, 1);
+
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+  assert.match(lateClose.message, /boom/);
+});
+
+test("worker fatalError during init rejects provider creation", async () => {
+  const worker = new FakeWorker();
+  const providerPromise = createWebWorkerProvider(worker, makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+
+  worker.emit({ kind: "fatalError", error: "bad wasm" });
+
+  await assert.rejects(providerPromise, /worker init reported error: bad wasm/);
+  assert.equal(worker.terminated, true);
+});
+
+test("worker frameError after init closes the provider", async () => {
+  const worker = new FakeWorker();
+  const provider = await readyProvider(worker);
+  const closes = [];
+  provider.subscribeClose((error) => closes.push(error));
+
+  worker.emit({ kind: "frameError", error: "bad frame" });
+
+  assert.equal(worker.terminated, true);
+  assert.equal(closes.length, 1);
+  assert.match(closes[0].message, /worker frame error: bad frame/);
+
+  let lateClose = null;
+  provider.subscribeClose((error) => {
+    lateClose = error;
+  });
+  assert.ok(lateClose instanceof Error);
+});
+
+test("worker provider routes payload-carrying subscriptions by name", async () => {
+  const worker = new FakeWorker();
+  const keys = [];
+  let push;
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      preimageLookupSubscribe: (key, sendItem) => {
+        keys.push(key);
+        push = sendItem;
+        return () => {};
+      },
+    }),
+    { runtimeConfig: runtimeConfig() },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "subscriptionStart",
+    subId: 4,
+    name: "preimageLookupSubscribe",
+    payload: new Uint8Array([9, 9]),
+  });
+
+  assert.deepEqual(keys, [new Uint8Array([9, 9])]);
+  push(new Uint8Array([1]));
+  assert.deepEqual(worker.messages.at(-1), {
+    kind: "subscriptionItem",
+    subId: 4,
+    value: new Uint8Array([1]),
+  });
+
+  provider.dispose();
+});
+
+test("unknown subscription names never fall through to another callback", async () => {
+  const worker = new FakeWorker();
+  let preimageStarts = 0;
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      preimageLookupSubscribe: () => {
+        preimageStarts += 1;
+        return () => {};
+      },
+    }),
+    { runtimeConfig: runtimeConfig() },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "subscriptionStart",
+    subId: 5,
+    name: "someFutureSubscribe",
+    payload: new Uint8Array([1, 2, 3]),
+  });
+
+  assert.equal(preimageStarts, 0);
+  assert.equal(
+    worker.messages.some((m) => m.kind === "subscriptionItem"),
+    false,
+  );
+
+  provider.dispose();
+});
+
+test("payload-carrying subscription without payload is not dispatched", async () => {
+  const worker = new FakeWorker();
+  let preimageStarts = 0;
+  const providerPromise = createWebWorkerProvider(
+    worker,
+    makeCallbacks({
+      preimageLookupSubscribe: () => {
+        preimageStarts += 1;
+        return () => {};
+      },
+    }),
+    { runtimeConfig: runtimeConfig() },
+  );
+  worker.emit({ kind: "loaded" });
+  worker.emit({ kind: "ready" });
+  const provider = await providerPromise;
+
+  worker.emit({
+    kind: "subscriptionStart",
+    subId: 6,
+    name: "preimageLookupSubscribe",
+    payload: null,
+  });
+
+  assert.equal(preimageStarts, 0);
+
+  provider.dispose();
+});
+
+test("createWebWorkerProvider rejects when init times out", async () => {
+  const worker = new FakeWorker();
+  const providerPromise = createWebWorkerProvider(worker, makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+    initTimeoutMs: 20,
+  });
+  worker.emit({ kind: "loaded" });
+  await assert.rejects(providerPromise, /worker init timed out after 20ms/);
+  assert.equal(worker.terminated, true);
+});
+
+test("createWebWorkerProvider rejects on messageerror during init", async () => {
+  const worker = new FakeWorker();
+  const providerPromise = createWebWorkerProvider(worker, makeCallbacks(), {
+    runtimeConfig: runtimeConfig(),
+  });
+  worker.emitMessageError();
+  await assert.rejects(providerPromise, /could not be deserialized/);
+  assert.equal(worker.terminated, true);
+});
+
+test("typed callbacks decode raw v01 push notification payloads", async () => {
+  let notification;
+  const callbacks = createWasmRawCallbacks({
+    pushNotification: async (request) => {
+      notification = request;
+      return { id: 42 };
+    },
+  });
+
+  const id = await callbacks.pushNotification(
+    HostPushNotificationRequest.enc({
+      text: "Hello!",
+      deeplink: undefined,
+      scheduledAt: undefined,
+    }),
+  );
+
+  assert.equal(id, 42);
+  assert.deepEqual(notification, {
+    text: "Hello!",
+    deeplink: undefined,
+    scheduledAt: undefined,
+  });
+});
diff --git a/js/packages/truapi-host-wasm/tsconfig.json b/js/packages/truapi-host-wasm/tsconfig.json
new file mode 100644
index 00000000..8a51c612
--- /dev/null
+++ b/js/packages/truapi-host-wasm/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "composite": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "DOM", "WebWorker"]
+  },
+  "include": ["src"],
+  "references": [{ "path": "../truapi" }, { "path": "../truapi-host" }]
+}
diff --git a/js/packages/truapi-host/package.json b/js/packages/truapi-host/package.json
index 343626e7..4e131ab6 100644
--- a/js/packages/truapi-host/package.json
+++ b/js/packages/truapi-host/package.json
@@ -29,7 +29,7 @@
   },
   "scripts": {
     "ensure-generated": "./scripts/ensure-generated.sh",
-    "build": "tsc",
+    "build": "tsc -b",
     "prebuild": "npm run ensure-generated",
     "codegen": "cargo run -p truapi-codegen -- --input ../../../target/doc/truapi.json --output ../truapi/src/generated --host-output src/generated",
     "typecheck": "npm run build",
diff --git a/js/packages/truapi-host/test/result-subscription.test.mjs b/js/packages/truapi-host/test/result-subscription.test.mjs
index 1bd12952..d15ae3e5 100644
--- a/js/packages/truapi-host/test/result-subscription.test.mjs
+++ b/js/packages/truapi-host/test/result-subscription.test.mjs
@@ -94,7 +94,7 @@ await new Promise((resolveTest, rejectTest) => {
 
   const server = createTrUApiServer(b, makeStubHandlers({ payment: paymentStub }));
   const received = [];
-  client.payment.balanceSubscribe().subscribe({
+  client.payment.balanceSubscribe({ request: {} }).subscribe({
     next(item) {
       received.push(item);
     },
diff --git a/js/packages/truapi-host/test/versioned-roundtrip.test.mjs b/js/packages/truapi-host/test/versioned-roundtrip.test.mjs
index cd69a91c..9569bf02 100644
--- a/js/packages/truapi-host/test/versioned-roundtrip.test.mjs
+++ b/js/packages/truapi-host/test/versioned-roundtrip.test.mjs
@@ -118,8 +118,7 @@ function makeStubHandlers(partial) {
   const transport = createTransport(a);
   const client = createClient(transport);
 
-  const sampleRequest = {
-    account: { dotNsIdentifier: "alice.dot", derivationIndex: 0 },
+  const samplePayload = {
     blockHash: "0x" + "00".repeat(32),
     blockNumber: "0x10",
     era: "0x00",
@@ -132,6 +131,10 @@ function makeStubHandlers(partial) {
     signedExtensions: [],
     version: 4,
   };
+  const sampleRequest = {
+    account: { dotNsIdentifier: "alice.dot", derivationIndex: 0 },
+    payload: samplePayload,
+  };
   const sampleSignature = "0x" + "ab".repeat(32);
 
   let observedRequest;
@@ -155,11 +158,11 @@ function makeStubHandlers(partial) {
   assert.equal(result.value.signature, sampleSignature);
   // SCALE decode reifies optional fields, so compare key-by-key on the
   // input set rather than deepEqual on the whole shape.
-  for (const [key, expected] of Object.entries(sampleRequest)) {
+  for (const [key, expected] of Object.entries(samplePayload)) {
     assert.deepEqual(
-      observedRequest.value[key],
+      observedRequest.value.payload[key],
       expected,
-      `signPayload request.value.${key} mismatch`,
+      `signPayload request.value.payload.${key} mismatch`,
     );
   }
 
diff --git a/js/packages/truapi-host/tsconfig.json b/js/packages/truapi-host/tsconfig.json
index 71725ac1..0238f57b 100644
--- a/js/packages/truapi-host/tsconfig.json
+++ b/js/packages/truapi-host/tsconfig.json
@@ -3,6 +3,7 @@
     "target": "ES2022",
     "module": "ES2022",
     "moduleResolution": "bundler",
+    "composite": true,
     "declaration": true,
     "outDir": "dist",
     "rootDir": "src",
@@ -12,5 +13,6 @@
     "esModuleInterop": true,
     "skipLibCheck": true
   },
-  "include": ["src"]
+  "include": ["src"],
+  "references": [{ "path": "../truapi" }]
 }
diff --git a/js/packages/truapi/README.md b/js/packages/truapi/README.md
index 06aa67fd..34be9f17 100644
--- a/js/packages/truapi/README.md
+++ b/js/packages/truapi/README.md
@@ -77,7 +77,7 @@ Frames are SCALE encoded:
 [requestId: SCALE str][discriminant: u8][payload bytes...]
 ```
 
-The discriminant table is generated from Rust `#[wire(request_id = N)]` and `#[wire(start_id = N)]` annotations and is written to `src/generated/wire-table.ts`.
+The discriminant table is generated from Rust `#[wire(request_id = N)]` and `#[wire(start_id = N)]` annotations and is written to `src/generated/wire-table.ts`. The package also exports a reverse lookup for debug labels: `WIRE_TAG_BY_ID` (discriminant → `<method>_<kind>` tag) and `describeWireId(id)` (falls back to `wire_<id>` for unknown discriminants).
 
 ## Generated files
 
diff --git a/js/packages/truapi/package.json b/js/packages/truapi/package.json
index 46ae9d73..befc9fb6 100644
--- a/js/packages/truapi/package.json
+++ b/js/packages/truapi/package.json
@@ -62,7 +62,7 @@
   },
   "scripts": {
     "ensure-generated": "./scripts/ensure-generated.sh",
-    "build": "tsc",
+    "build": "tsc -b",
     "prebuild": "npm run ensure-generated",
     "codegen": "cargo run -p truapi-codegen -- --input ../../../target/doc/truapi.json --output src/generated --playground-output src/playground --explorer-output src/explorer",
     "typecheck": "npm run build",
@@ -73,6 +73,7 @@
     "typescript": "^6.0"
   },
   "dependencies": {
+    "@noble/hashes": "^2.2.0",
     "neverthrow": "^8.2.0",
     "scale-ts": "^1.6.1"
   }
diff --git a/js/packages/truapi/src/index.ts b/js/packages/truapi/src/index.ts
index bc6bcef2..99411af8 100644
--- a/js/packages/truapi/src/index.ts
+++ b/js/packages/truapi/src/index.ts
@@ -12,14 +12,17 @@ export type {
   TrUApiTransport,
 } from "./transport.js";
 export type { CreateTransportOptions } from "./client.js";
+export type { WebSocketProviderOptions } from "./transport.js";
 export {
   SubscriptionError,
   createIframeProvider,
   createMessagePortProvider,
+  createWebSocketProvider,
   decodeWireMessage,
   encodeWireMessage,
 } from "./transport.js";
 export { createTransport } from "./client.js";
+export { WIRE_TAG_BY_ID, describeWireId } from "./wire-tags.js";
 export * as scale from "./scale.js";
 export type { Codec, HexString } from "./scale.js";
 export * from "./generated/index.js";
diff --git a/js/packages/truapi/src/scale.ts b/js/packages/truapi/src/scale.ts
index ac92039b..f0d1cc89 100644
--- a/js/packages/truapi/src/scale.ts
+++ b/js/packages/truapi/src/scale.ts
@@ -11,9 +11,14 @@ import {
   createCodec,
   createDecoder,
   enhanceCodec,
+  str as scaleStr,
   u8,
   type Codec,
 } from "scale-ts";
+import {
+  bytesToHex as encodeHex,
+  hexToBytes as decodeHex,
+} from "@noble/hashes/utils.js";
 
 export type { Codec };
 export type { ResultPayload } from "scale-ts";
@@ -79,22 +84,12 @@ export function toHexString(value: string): HexString {
 
 /** Encode a byte array as a lower-case hex string with a `0x` prefix. */
 export function bytesToHex(bytes: Uint8Array): HexString {
-  let hex = "0x";
-  for (let i = 0; i < bytes.length; i++) {
-    hex += bytes[i]!.toString(16).padStart(2, "0");
-  }
-  return hex as HexString;
+  return `0x${encodeHex(bytes)}`;
 }
 
 /** Decode a hex string into a byte array. Tolerates a missing `0x` prefix. */
 export function hexToBytes(hex: string): Uint8Array {
-  const start = hex.startsWith("0x") ? 2 : 0;
-  const length = (hex.length - start) >> 1;
-  const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i++) {
-    bytes[i] = parseInt(hex.substring(start + i * 2, start + i * 2 + 2), 16);
-  }
-  return bytes;
+  return decodeHex(hex.startsWith("0x") ? hex.slice(2) : hex);
 }
 
 /**
@@ -123,6 +118,44 @@ export function TaggedUnion<O extends TaggedUnionCodecs>(
   return Enum(inner) as unknown as Codec<TaggedUnionValue<O>>;
 }
 
+/**
+ * Wire codec for Rust `CallError<D>`, projected to the public domain error `D`.
+ *
+ * Generated TypeScript APIs expose only the domain error union in
+ * `ResultAsync<Ok, D>`. The Rust host still wraps that value in
+ * `CallError::Domain` on the wire so framework errors can share the response
+ * channel. Encoding always emits `Domain`; decoding returns the inner domain
+ * value and throws for framework-level failures that have no public `D` shape.
+ */
+export function CallError<D>(domain: Codec<D>): Codec<D> {
+  return createCodec(
+    (value: D) => {
+      const payload = domain.enc(value);
+      const out = new Uint8Array(payload.length + 1);
+      out[0] = 0;
+      out.set(payload, 1);
+      return out;
+    },
+    createDecoder((input) => {
+      const tag = u8.dec(input);
+      switch (tag) {
+        case 0:
+          return domain.dec(input);
+        case 1:
+          throw new Error("Host denied the request");
+        case 2:
+          throw new Error("Host does not support this request");
+        case 3:
+          throw new Error(`Malformed request frame: ${scaleStr.dec(input)}`);
+        case 4:
+          throw new Error(`Host failure: ${scaleStr.dec(input)}`);
+        default:
+          throw new Error(`Unknown CallError discriminant: ${tag}`);
+      }
+    }),
+  );
+}
+
 type TaggedUnionCodecs = {
   [Sym: symbol]: never;
   [Num: number]: never;
diff --git a/js/packages/truapi/src/transport.ts b/js/packages/truapi/src/transport.ts
index 8a92133e..a60c3737 100644
--- a/js/packages/truapi/src/transport.ts
+++ b/js/packages/truapi/src/transport.ts
@@ -9,6 +9,12 @@ function toError(error: unknown): Error {
   return error instanceof Error ? error : new Error(String(error));
 }
 
+function toWebSocketPayload(message: Uint8Array): Uint8Array<ArrayBuffer> {
+  const copy: Uint8Array<ArrayBuffer> = new Uint8Array(message.byteLength);
+  copy.set(message);
+  return copy;
+}
+
 /**
  * Handle returned by TrUAPI subscription APIs.
  **/
@@ -277,6 +283,10 @@ export interface Provider {
 
   /**
    * Register a callback for provider-level close or failure events.
+   *
+   * Providers keep a terminal close reason. The callback fires at most once
+   * for an active subscription, and fires immediately when registered after
+   * the provider has already closed.
    **/
   subscribeClose?(callback: (error: Error) => void): () => void;
 
@@ -580,3 +590,102 @@ export function createMessagePortProvider(
     },
   };
 }
+
+/**
+ * Options accepted by `createWebSocketProvider`.
+ **/
+export interface WebSocketProviderOptions {
+  /**
+   * Override the `WebSocket` constructor. Useful for non-browser runtimes
+   * (Node, tests) where the global isn't available.
+   **/
+  WebSocket?: typeof WebSocket;
+}
+
+/**
+ * Create a provider backed by a binary WebSocket. Used by products that
+ * connect through the native host's localhost WS bridge, the host exposes
+ * an endpoint shaped like `ws://127.0.0.1:<port>/?t=<token>` and the product
+ * passes that URL straight to this constructor.
+ **/
+export function createWebSocketProvider(
+  url: string,
+  options: WebSocketProviderOptions = {},
+): Provider {
+  const WebSocketCtor = options.WebSocket ?? globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("WebSocket constructor not available in this environment");
+  }
+
+  const base = createBaseProvider();
+  const socket = new WebSocketCtor(url);
+  socket.binaryType = "arraybuffer";
+
+  const pending: Uint8Array[] = [];
+  base.onClose(() => {
+    pending.length = 0;
+  });
+
+  socket.onopen = () => {
+    for (const msg of pending) {
+      try {
+        socket.send(toWebSocketPayload(msg));
+      } catch (error) {
+        base.close(error);
+        return;
+      }
+    }
+    pending.length = 0;
+  };
+
+  socket.onmessage = (event: MessageEvent) => {
+    const data = event.data;
+    if (!(data instanceof ArrayBuffer)) {
+      return;
+    }
+    base.deliver(new Uint8Array(data));
+  };
+
+  socket.onerror = () => {
+    base.close(new Error("websocket error"));
+  };
+
+  socket.onclose = (event: CloseEvent) => {
+    base.close(
+      new Error(
+        `websocket closed (code=${event.code}, reason=${event.reason || "unknown"})`,
+      ),
+    );
+  };
+
+  return {
+    postMessage(message) {
+      const error = base.closed();
+      if (error) {
+        throw error;
+      }
+      if (socket.readyState === WebSocketCtor.OPEN) {
+        try {
+          socket.send(toWebSocketPayload(message));
+        } catch (error) {
+          base.close(error);
+          throw toError(error);
+        }
+      } else if (socket.readyState === WebSocketCtor.CONNECTING) {
+        pending.push(message);
+      } else {
+        throw new Error("websocket not open");
+      }
+    },
+    subscribe: base.subscribe,
+    subscribeClose: base.subscribeClose,
+    dispose() {
+      base.close(new Error("websocket provider disposed"));
+      try {
+        socket.close();
+      } catch {
+        // ignore duplicate close during shutdown
+      }
+    },
+  };
+}
diff --git a/js/packages/truapi/src/wire-tags.ts b/js/packages/truapi/src/wire-tags.ts
new file mode 100644
index 00000000..8fa6d20a
--- /dev/null
+++ b/js/packages/truapi/src/wire-tags.ts
@@ -0,0 +1,32 @@
+// Reverse lookup over the generated wire table, used to label wire frames
+// in debug logs. The frame-kind keys (`request`, `start`, ...) are derived
+// from the table rows themselves rather than hardcoded.
+
+import * as WireTable from "./generated/wire-table.js";
+
+/**
+ * Frame tag (`<method>_<kind>`, e.g. `system_handshake_request`) keyed by
+ * wire discriminant, precomputed from the generated wire table.
+ **/
+export const WIRE_TAG_BY_ID: ReadonlyMap<number, string> = (() => {
+  const map = new Map<number, string>();
+  for (const [name, row] of Object.entries(WireTable)) {
+    if (typeof row !== "object" || row === null) {
+      continue;
+    }
+    for (const [kind, id] of Object.entries(row)) {
+      if (typeof id === "number") {
+        map.set(id, `${name.toLowerCase()}_${kind}`);
+      }
+    }
+  }
+  return map;
+})();
+
+/**
+ * Human-readable label for a wire discriminant; `wire_<id>` when the id is
+ * not in the wire table.
+ **/
+export function describeWireId(id: number): string {
+  return WIRE_TAG_BY_ID.get(id) ?? `wire_${String(id)}`;
+}
diff --git a/js/packages/truapi/test/ws-provider.test.mjs b/js/packages/truapi/test/ws-provider.test.mjs
new file mode 100644
index 00000000..0775e051
--- /dev/null
+++ b/js/packages/truapi/test/ws-provider.test.mjs
@@ -0,0 +1,279 @@
+// Smoke test for `createWebSocketProvider` against a stubbed WebSocket
+// constructor. Verifies the open/queue lifecycle, the close fan-out, and
+// that double-registration of the same listener is independent (Set semantics).
+
+import assert from "node:assert/strict";
+
+import { createWebSocketProvider } from "../dist/transport.js";
+
+function makeStubWebSocket(opts = {}) {
+  // Records what the provider did to its socket so the tests can assert.
+  const sent = [];
+  let openHandler = null;
+  let messageHandler = null;
+  let closeHandler = null;
+  let errorHandler = null;
+  let readyState = 0; // CONNECTING
+  let sendThrows = opts.sendThrows ?? false;
+
+  class StubWebSocket {
+    static get CONNECTING() {
+      return 0;
+    }
+    static get OPEN() {
+      return 1;
+    }
+    static get CLOSING() {
+      return 2;
+    }
+    static get CLOSED() {
+      return 3;
+    }
+
+    binaryType = "";
+
+    set onopen(fn) {
+      openHandler = fn;
+    }
+    set onmessage(fn) {
+      messageHandler = fn;
+    }
+    set onclose(fn) {
+      closeHandler = fn;
+    }
+    set onerror(fn) {
+      errorHandler = fn;
+    }
+
+    get readyState() {
+      return readyState;
+    }
+
+    send(bytes) {
+      if (sendThrows) throw new Error("send failed");
+      sent.push(bytes);
+    }
+    close() {
+      readyState = 3;
+      if (closeHandler) closeHandler({ code: 1000, reason: "" });
+    }
+  }
+
+  return {
+    StubWebSocket,
+    sent,
+    open() {
+      readyState = 1;
+      if (openHandler) openHandler();
+    },
+    setReadyState(state) {
+      readyState = state;
+    },
+    setSendThrows(value) {
+      sendThrows = value;
+    },
+    deliver(data) {
+      if (messageHandler) {
+        messageHandler({ data });
+      }
+    },
+    inbound(bytes) {
+      if (messageHandler) {
+        messageHandler({ data: bytes.buffer });
+      }
+    },
+    triggerClose(code, reason) {
+      readyState = 3;
+      if (closeHandler) closeHandler({ code, reason });
+    },
+    triggerError() {
+      if (errorHandler) errorHandler();
+    },
+  };
+}
+
+// 1. queues outbound while connecting; flushes on open
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+
+  provider.postMessage(new Uint8Array([1, 2, 3]));
+  provider.postMessage(new Uint8Array([4, 5]));
+  assert.equal(stub.sent.length, 0, "nothing sent while CONNECTING");
+
+  stub.open();
+  assert.deepEqual(
+    stub.sent.map((b) => Array.from(b)),
+    [
+      [1, 2, 3],
+      [4, 5],
+    ],
+    "queued frames flush in order on open",
+  );
+}
+
+// 2. fan-out: every active listener receives every inbound frame
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+
+  const received = [];
+  const a = (bytes) => received.push(["a", Array.from(bytes)]);
+  const b = (bytes) => received.push(["b", Array.from(bytes)]);
+  const unsubA = provider.subscribe(a);
+  provider.subscribe(b);
+
+  stub.inbound(new Uint8Array([0xaa]));
+  unsubA();
+  stub.inbound(new Uint8Array([0xbb]));
+
+  assert.deepEqual(received, [
+    ["a", [0xaa]],
+    ["b", [0xaa]],
+    ["b", [0xbb]],
+  ]);
+}
+
+// 3. subscribe is set-based: re-registering the same callback is idempotent
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+
+  let count = 0;
+  const cb = () => {
+    count += 1;
+  };
+  const unsub1 = provider.subscribe(cb);
+  const unsub2 = provider.subscribe(cb);
+  stub.inbound(new Uint8Array([1]));
+  assert.equal(count, 1, "duplicate registration counts as one listener");
+
+  unsub1();
+  unsub2();
+  stub.inbound(new Uint8Array([2]));
+  assert.equal(count, 1, "unsubscribed listener is silent");
+}
+
+// 4. subscribeClose fires once on socket close; late subscribers see the stored error
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+
+  const errors = [];
+  provider.subscribeClose((err) => errors.push(err));
+  stub.triggerClose(1006, "abnormal");
+  assert.equal(errors.length, 1);
+  assert.match(errors[0].message, /websocket closed/);
+
+  let late = null;
+  provider.subscribeClose((err) => {
+    late = err;
+  });
+  assert.equal(late, errors[0], "late subscriber receives the stored close error");
+}
+
+// 5. postMessage after close throws the stored error
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+  stub.triggerClose(1000, "");
+  assert.throws(
+    () => provider.postMessage(new Uint8Array([1])),
+    /websocket closed/,
+  );
+}
+
+// 6. triggerError() surfaces a /websocket error/ through subscribeClose
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+
+  const errors = [];
+  provider.subscribeClose((err) => errors.push(err));
+  stub.triggerError();
+  assert.equal(errors.length, 1);
+  assert.match(errors[0].message, /websocket error/);
+}
+
+// 7. non-ArrayBuffer inbound payloads are dropped without firing listeners
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+
+  let count = 0;
+  provider.subscribe(() => {
+    count += 1;
+  });
+  stub.deliver("not-an-arraybuffer");
+  stub.deliver({ some: "object" });
+  assert.equal(count, 0, "non-ArrayBuffer frames are ignored");
+
+  // A real ArrayBuffer still flows through.
+  stub.inbound(new Uint8Array([7]));
+  assert.equal(count, 1, "ArrayBuffer frames still deliver");
+}
+
+// 8. postMessage while readyState is CLOSING (2) throws /websocket not open/
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+  stub.open();
+  stub.setReadyState(2); // CLOSING
+  assert.throws(
+    () => provider.postMessage(new Uint8Array([1])),
+    /websocket not open/,
+  );
+}
+
+// 9. a send that throws during the onopen flush closes the provider
+{
+  const stub = makeStubWebSocket();
+  const provider = createWebSocketProvider("ws://127.0.0.1:0/?t=token", {
+    WebSocket: stub.StubWebSocket,
+  });
+
+  const errors = [];
+  provider.subscribeClose((err) => errors.push(err));
+
+  // Queue a frame while CONNECTING, then make the socket throw on send and
+  // open it so the flush hits the failing send path.
+  provider.postMessage(new Uint8Array([1, 2, 3]));
+  stub.setSendThrows(true);
+  stub.open();
+
+  assert.equal(
+    errors.length,
+    1,
+    "flush failure surfaces through subscribeClose",
+  );
+  assert.match(errors[0].message, /send failed/);
+  assert.throws(
+    () => provider.postMessage(new Uint8Array([4])),
+    /send failed/,
+    "provider is closed after the failed flush",
+  );
+}
+
+console.log("createWebSocketProvider tests passed");
diff --git a/js/packages/truapi/tsconfig.json b/js/packages/truapi/tsconfig.json
index 71725ac1..2b8ac495 100644
--- a/js/packages/truapi/tsconfig.json
+++ b/js/packages/truapi/tsconfig.json
@@ -3,6 +3,7 @@
     "target": "ES2022",
     "module": "ES2022",
     "moduleResolution": "bundler",
+    "composite": true,
     "declaration": true,
     "outDir": "dist",
     "rootDir": "src",
diff --git a/package-lock.json b/package-lock.json
index a194a5b2..50a7efb2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,6 +21,7 @@
       "version": "0.3.0",
       "license": "MIT",
       "dependencies": {
+        "@noble/hashes": "^2.2.0",
         "neverthrow": "^8.2.0",
         "scale-ts": "^1.6.1"
       },
@@ -41,6 +42,18 @@
         "typescript": "^5.7"
       }
     },
+    "js/packages/truapi-host-wasm": {
+      "name": "@parity/truapi-host-wasm",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "@parity/truapi": "file:../truapi",
+        "@parity/truapi-host": "file:../truapi-host"
+      },
+      "devDependencies": {
+        "typescript": "^5.7"
+      }
+    },
     "js/packages/truapi/node_modules/typescript": {
       "version": "6.0.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
@@ -433,6 +446,18 @@
         "node": ">=6 <7 || >=8"
       }
     },
+    "node_modules/@noble/hashes": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-2.2.0.tgz",
+      "integrity": "sha512-IYqDGiTXab6FniAgnSdZwgWbomxpy9FtYvLKs7wCUs2a8RkITG+DFGO1DM9cr+E3/RgADRpFjrKVaJ1z6sjtEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.19.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -479,6 +504,10 @@
       "resolved": "js/packages/truapi-host",
       "link": true
     },
+    "node_modules/@parity/truapi-host-wasm": {
+      "resolved": "js/packages/truapi-host-wasm",
+      "link": true
+    },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
       "version": "4.60.3",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.3.tgz",
diff --git a/playground/src/components/DiagnosisView.tsx b/playground/src/components/DiagnosisView.tsx
index 2c401efd..842588e8 100644
--- a/playground/src/components/DiagnosisView.tsx
+++ b/playground/src/components/DiagnosisView.tsx
@@ -72,13 +72,17 @@ export function DiagnosisView({
     };
   }, [services, testResults]);
 
+  const reportMarkdown = useMemo(
+    () =>
+      hasResults && !isRunning
+        ? renderReportMarkdown(services, testResults)
+        : "",
+    [hasResults, isRunning, services, testResults],
+  );
+
   const handleCopyReport = async () => {
     try {
-      // Rendered on demand: the full report is only needed on copy, not on
-      // every per-method result update during a run.
-      await navigator.clipboard.writeText(
-        renderReportMarkdown(services, testResults),
-      );
+      await navigator.clipboard.writeText(reportMarkdown);
       setCopied(true);
       setTimeout(() => setCopied(false), 1500);
     } catch {
@@ -92,7 +96,7 @@ export function DiagnosisView({
   // Copy the report to the clipboard first as a fallback if the body is
   // truncated.
   const handleSubmitReport = () => {
-    const report = renderReportMarkdown(services, testResults);
+    const report = reportMarkdown;
     void navigator.clipboard?.writeText(report).catch(() => {});
     const url = reportIssueUrl(report, detectHostMode());
     try {
@@ -123,11 +127,12 @@ export function DiagnosisView({
           <span className="panel__label">About</span>
         </div>
         <p className="panel__desc">
-          Runs every TrUAPI method against the connected host to build a coverage
-          report — which methods work, which fail, and which aren&apos;t wired
-          yet. Methods run one at a time, in order; those that need your approval
-          (signing, permission and resource requests) wait on your response
-          before the run continues. When it finishes, copy the report below.
+          Runs every TrUAPI method against the connected host to build a
+          coverage report — which methods work, which fail, and which
+          aren&apos;t wired yet. Methods run one at a time, in order; those that
+          need your approval (signing, permission and resource requests) wait on
+          your response before the run continues. When it finishes, copy the
+          report below.
         </p>
         <p className="diag__callout">
           Before you start: make sure you are <strong>logged in</strong>, and
@@ -145,7 +150,12 @@ export function DiagnosisView({
             Stop
           </button>
         ) : (
-          <button type="button" className="btn btn--primary" onClick={onRun}>
+          <button
+            type="button"
+            className="btn btn--primary"
+            data-testid="diagnosis-run"
+            onClick={onRun}
+          >
             <span className="btn__glyph">▶</span>
             Run diagnosis
           </button>
@@ -153,6 +163,7 @@ export function DiagnosisView({
         {hasResults && (
           <span
             className="autotest__summary"
+            data-testid="diagnosis-summary"
             data-has-fail={!isRunning && failCount > 0}
           >
             {passCount} success · {failCount} failed
@@ -160,9 +171,17 @@ export function DiagnosisView({
         )}
         {hasResults && !isRunning && (
           <div className="diag__report-actions">
+            <pre
+              hidden
+              data-testid="diagnosis-report-markdown"
+              data-report-ready={reportMarkdown.length > 0}
+            >
+              {reportMarkdown}
+            </pre>
             <button
               type="button"
               className="autotest__report-copy"
+              data-testid="diagnosis-copy-report"
               onClick={handleCopyReport}
             >
               {copied ? "Copied ✓" : "Copy report"}
@@ -188,6 +207,7 @@ export function DiagnosisView({
               <div key={r.id}>
                 <div
                   className="diag__row"
+                  data-testid="diagnosis-row"
                   data-status={r.status}
                   data-expandable={expandable}
                   onClick={
diff --git a/playground/src/components/ServiceTable.tsx b/playground/src/components/ServiceTable.tsx
index 1ea9ab52..45c0a516 100644
--- a/playground/src/components/ServiceTable.tsx
+++ b/playground/src/components/ServiceTable.tsx
@@ -30,6 +30,7 @@ export function ServiceTable({
       <button
         type="button"
         className="method method--autotest"
+        data-testid="diagnosis-entry"
         data-active={isDiagnosisActive}
         data-supported="true"
         onClick={() => onSelect(DIAGNOSIS_ID, "")}
diff --git a/playground/src/lib/auto-test.ts b/playground/src/lib/auto-test.ts
index edce4141..64786dcb 100644
--- a/playground/src/lib/auto-test.ts
+++ b/playground/src/lib/auto-test.ts
@@ -1,8 +1,4 @@
-import {
-  runExample,
-  type LogEntry,
-  type RunResult,
-} from "./example-runner";
+import { runExample, type LogEntry, type RunResult } from "./example-runner";
 import { getClient } from "./transport";
 import type { MethodInfo, ServiceInfo } from "./services";
 
@@ -18,6 +14,7 @@ export interface TestEntry {
 
 const UNARY_TIMEOUT_MS = 10_000;
 const SIGNING_TIMEOUT_MS = 30_000;
+const SSO_TIMEOUT_MS = 60_000;
 
 // Services skipped wholesale in the diagnosis until hosts wire them up.
 const SKIPPED_SERVICES = new Set(["Coin Payment"]);
@@ -36,6 +33,10 @@ const LONG_TIMEOUT_METHODS = new Set([
   "Preimage/submit",
 ]);
 
+const METHOD_TIMEOUT_MS = new Map<string, number>([
+  ["Account/get_account_alias", SSO_TIMEOUT_MS],
+]);
+
 type RunOneOpts = {
   serviceName: string;
   method: MethodInfo;
@@ -63,9 +64,9 @@ async function runOne({
   const source = method.exampleSource;
   const logs: LogEntry[] = [];
   const onLog = (entry: LogEntry) => logs.push(entry);
-  const timeoutMs = LONG_TIMEOUT_METHODS.has(id)
-    ? SIGNING_TIMEOUT_MS
-    : UNARY_TIMEOUT_MS;
+  const timeoutMs =
+    METHOD_TIMEOUT_MS.get(id) ??
+    (LONG_TIMEOUT_METHODS.has(id) ? SIGNING_TIMEOUT_MS : UNARY_TIMEOUT_MS);
 
   // The example decides pass/fail explicitly: it resolves on success and throws
   // (via `assert(...)` or any uncaught error) on failure. `console.*` is pure
diff --git a/playground/src/lib/diagnosis-report.ts b/playground/src/lib/diagnosis-report.ts
index eb307211..0dcda973 100644
--- a/playground/src/lib/diagnosis-report.ts
+++ b/playground/src/lib/diagnosis-report.ts
@@ -66,10 +66,9 @@ export function renderReportMarkdown(
   return lines.join("\n");
 }
 
-// The failure reason for a method, flattened to a single escaped table cell.
-// Only failures carry details; other statuses leave the cell empty.
+// Method output flattened to a single escaped table cell.
 function detailCell(entry: TestEntry | undefined): string {
-  if (entry?.status !== "fail" || entry.output == null) return "";
+  if (entry?.output == null) return "";
   return entry.output.replace(/\s+/g, " ").replace(/\|/g, "\\|").trim();
 }
 
diff --git a/playground/src/lib/example-runner.ts b/playground/src/lib/example-runner.ts
index 898c138b..67384d7f 100644
--- a/playground/src/lib/example-runner.ts
+++ b/playground/src/lib/example-runner.ts
@@ -76,11 +76,10 @@ export async function runExample(opts: {
   client: TrUApiClient;
   onLog: (entry: LogEntry) => void;
 }): Promise<RunResult> {
-  const { source, client, onLog } = opts;
-
+  const { client, onLog } = opts;
   let js: string;
   try {
-    js = transform(source, { transforms: ["typescript"] }).code;
+    js = transform(opts.source, { transforms: ["typescript"] }).code;
   } catch (err) {
     throw new ExampleSyntaxError(
       err instanceof Error ? err.message : String(err),
diff --git a/playground/src/lib/transport.ts b/playground/src/lib/transport.ts
index 458a21f6..ea15681f 100644
--- a/playground/src/lib/transport.ts
+++ b/playground/src/lib/transport.ts
@@ -1,6 +1,5 @@
 import {
   createClient,
-  createIframeProvider,
   createMessagePortProvider,
   createTransport,
   type Provider,
@@ -48,6 +47,61 @@ async function waitForWebviewPort(
   );
 }
 
+function waitForIframePort(
+  hostOrigin: string,
+  signal?: AbortSignal,
+  timeoutMs = 20_000,
+): Promise<MessagePort> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    const cleanup = () => {
+      window.removeEventListener("message", onMessage);
+      signal?.removeEventListener("abort", onAbort);
+      if (timer !== null) clearTimeout(timer);
+    };
+    const finish = (port: MessagePort) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(port);
+    };
+    const fail = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const onAbort = () => fail(new Error("waitForIframePort aborted"));
+    const onMessage = (event: MessageEvent) => {
+      if (event.source !== window.parent) return;
+      if (event.origin !== hostOrigin) return;
+      if (event.data?.type !== "truapi-init") return;
+      const port = event.ports[0];
+      if (!port) {
+        fail(new Error("truapi-init did not include a MessagePort"));
+        return;
+      }
+      finish(port);
+    };
+
+    window.addEventListener("message", onMessage);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timer = setTimeout(
+      () =>
+        fail(
+          new Error(
+            `Timed out waiting for iframe MessagePort (${timeoutMs}ms)`,
+          ),
+        ),
+      timeoutMs,
+    );
+
+    window.parent.postMessage({ type: "truapi-playground-ready" }, hostOrigin);
+  });
+}
+
 /** Origin used as the `targetOrigin` argument for outbound `postMessage`
  * frames. `document.referrer` is the URL of the parent document that loaded
  * the iframe, so its origin is the host that's expected to receive our
@@ -76,7 +130,16 @@ function createSandboxProvider(): Provider {
           "the playground must be embedded by a host that sends a Referer header.",
       );
     }
-    return createIframeProvider({ target: window.parent, hostOrigin });
+    const portController = new AbortController();
+    const provider = createMessagePortProvider(
+      waitForIframePort(hostOrigin, portController.signal),
+    );
+    const baseDispose = provider.dispose;
+    provider.dispose = () => {
+      portController.abort();
+      baseDispose?.();
+    };
+    return provider;
   }
   if (isWebview()) {
     const portController = new AbortController();
diff --git a/playground/tests/e2e/handshake.spec.ts b/playground/tests/e2e/handshake.spec.ts
index b5711404..1b5d2ecb 100644
--- a/playground/tests/e2e/handshake.spec.ts
+++ b/playground/tests/e2e/handshake.spec.ts
@@ -11,7 +11,9 @@ test.describe("handshake", () => {
     await waitForOnline(frame);
 
     // Once connected, the splash unmounts and the service rail mounts.
-    // The Auto-Test entry button is the simplest stable proof of that.
-    await expect(frame.locator(".method--autotest")).toBeVisible();
+    // The diagnosis entry is the simplest stable proof of that.
+    await expect(
+      frame.getByRole("button", { name: /Diagnosis Full host coverage report/ }),
+    ).toBeVisible();
   });
 });
diff --git a/playground/tests/e2e/helpers.ts b/playground/tests/e2e/helpers.ts
index 5256bf4b..a5cc3801 100644
--- a/playground/tests/e2e/helpers.ts
+++ b/playground/tests/e2e/helpers.ts
@@ -12,7 +12,7 @@ export async function openPlaygroundInDotli(page: Page): Promise<FrameLocator> {
   // dotli renders an additional hidden iframe (host.localhost:5173?mode=direct)
   // alongside the proxied playground; scope to the playground src so the
   // FrameLocator is unique under Playwright strict mode.
-  const frame = page.frameLocator('iframe[src="http://localhost:3000"]');
+  const frame = page.frameLocator('iframe[src^="http://localhost:3000"]');
   // The playground renders the masthead once mounted; the status chip is
   // there from the first render in either splash or shell mode.
   await expect(frame.locator(".status")).toBeVisible({ timeout: 30_000 });
diff --git a/playground/tests/e2e/login-modal.spec.ts b/playground/tests/e2e/login-modal.spec.ts
new file mode 100644
index 00000000..5fcf2db3
--- /dev/null
+++ b/playground/tests/e2e/login-modal.spec.ts
@@ -0,0 +1,68 @@
+import { expect, test, type Page } from "@playwright/test";
+import { openPlaygroundInDotli, waitForOnline } from "./helpers";
+
+/**
+ * The login pairing UI is driven by the Rust core's ordered auth-state
+ * stream. This spec pins the two failure modes of the event-soup era:
+ * a boot-time disconnected tick closing the just-opened pairing modal,
+ * and a dismissed modal leaving the login flow polling forever.
+ */
+test.describe("login pairing modal", () => {
+  test("stays open while pairing, cancels on close, reopens on retry", async ({
+    page,
+  }) => {
+    const subscribeSends: number[] = [];
+    page.on("console", (msg) => {
+      const text = msg.text();
+      if (
+        text.includes("chainSend") &&
+        text.includes("statement_subscribeStatement")
+      ) {
+        subscribeSends.push(Date.now());
+      }
+    });
+    await page.addInitScript(() => {
+      try {
+        localStorage.setItem("truapi:logLevel", "debug");
+      } catch {
+        /* storage unavailable */
+      }
+    });
+
+    const frame = await openPlaygroundInDotli(page);
+    await waitForOnline(frame);
+
+    // Opening the login modal renders the pairing QR from the core's
+    // `Pairing` auth state.
+    await openPairingModal(page);
+
+    // The modal must survive the first seconds of pairing: the freshly
+    // booted core's session-store sync must not tear it down.
+    await page.waitForTimeout(5_000);
+    await expect(page.locator("#auth-modal-backdrop.open")).toBeVisible();
+    await expect(page.locator("#auth-modal-qr canvas")).toBeVisible();
+
+    // While pairing, the core polls the statement store with ~2s
+    // snapshot queries.
+    expect(subscribeSends.length).toBeGreaterThanOrEqual(2);
+
+    // Closing the modal cancels the login in the core: polling stops.
+    await page.locator("#auth-modal-close").click();
+    await expect(page.locator("#auth-modal-backdrop.open")).toBeHidden();
+    await page.waitForTimeout(1_000); // grace for an in-flight tick
+    const sendsAtCancel = subscribeSends.length;
+    await page.waitForTimeout(6_000);
+    expect(subscribeSends.length).toBe(sendsAtCancel);
+
+    // Retry opens a fresh pairing modal.
+    await openPairingModal(page);
+  });
+});
+
+async function openPairingModal(page: Page): Promise<void> {
+  await page.locator("#auth-button").click();
+  await expect(page.locator("#auth-modal-backdrop.open")).toBeVisible();
+  await expect(page.locator("#auth-modal-qr canvas")).toBeVisible({
+    timeout: 15_000,
+  });
+}
diff --git a/playground/tests/e2e/subscription.spec.ts b/playground/tests/e2e/subscription.spec.ts
index df3b82ec..303c718f 100644
--- a/playground/tests/e2e/subscription.spec.ts
+++ b/playground/tests/e2e/subscription.spec.ts
@@ -19,10 +19,7 @@ test.describe("subscription", () => {
     await expect(entries.first()).toBeVisible({ timeout: 6_000 });
     await expect(frame.locator('[data-testid="error-display"]')).toHaveCount(0);
 
-    // Once the first event is delivered the run completes and the Run button
-    // returns (no long-lived stream to Stop).
-    await expect(
-      frame.locator('[data-testid="subscribe-button"]'),
-    ).toBeVisible();
+    const text = await entries.first().innerText();
+    expect(text).toContain("connection status:");
   });
 });
diff --git a/playground/tests/e2e/unary.spec.ts b/playground/tests/e2e/unary.spec.ts
index d375fb2e..a429b5f9 100644
--- a/playground/tests/e2e/unary.spec.ts
+++ b/playground/tests/e2e/unary.spec.ts
@@ -2,11 +2,11 @@ import { expect, test } from "@playwright/test";
 import { openPlaygroundInDotli, selectMethod, waitForOnline } from "./helpers";
 
 test.describe("unary call", () => {
-  test("get_account runs to completion without error", async ({ page }) => {
+  test("feature_supported runs to completion without login", async ({ page }) => {
     const frame = await openPlaygroundInDotli(page);
     await waitForOnline(frame);
 
-    await selectMethod(frame, "Account", "get_account");
+    await selectMethod(frame, "System", "feature_supported");
 
     // Click `Run example`. The button is keyed on `data-testid` so it
     // is robust to label/glyph changes.
@@ -20,6 +20,6 @@ test.describe("unary call", () => {
     await expect(frame.locator('[data-testid="error-display"]')).toHaveCount(0);
 
     const text = await entries.first().innerText();
-    expect(text.trim().length).toBeGreaterThan(0);
+    expect(text).toContain("feature supported:");
   });
 });
diff --git a/rust/crates/truapi-codegen/.gitignore b/rust/crates/truapi-codegen/.gitignore
new file mode 100644
index 00000000..7a478389
--- /dev/null
+++ b/rust/crates/truapi-codegen/.gitignore
@@ -0,0 +1,2 @@
+# Mismatch dumps written by tests/golden_rust_emit.rs for local inspection.
+tests/golden/*.actual
diff --git a/rust/crates/truapi-codegen/Cargo.toml b/rust/crates/truapi-codegen/Cargo.toml
index c6d3ef3c..c376346e 100644
--- a/rust/crates/truapi-codegen/Cargo.toml
+++ b/rust/crates/truapi-codegen/Cargo.toml
@@ -17,3 +17,6 @@ anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 indoc = "2"
 convert_case = "0.6"
+
+[dev-dependencies]
+tempfile = "3"
diff --git a/rust/crates/truapi-codegen/src/main.rs b/rust/crates/truapi-codegen/src/main.rs
index b4d118fe..45b325ee 100644
--- a/rust/crates/truapi-codegen/src/main.rs
+++ b/rust/crates/truapi-codegen/src/main.rs
@@ -1,7 +1,10 @@
 use anyhow::{Context, Result};
 use clap::Parser;
+use std::path::PathBuf;
 use std::str::FromStr;
 
+mod platform;
+mod rust;
 mod rustdoc;
 mod ts;
 
@@ -50,6 +53,27 @@ struct Cli {
     #[arg(long)]
     host_output: Option<String>,
 
+    /// Output directory for the generated Rust dispatcher / wire-table (optional).
+    ///
+    /// When set, emits `dispatcher.rs` and `wire_table.rs` for the
+    /// `truapi-server` crate to include.
+    #[arg(long)]
+    rust_output: Option<PathBuf>,
+
+    /// Path to rustdoc JSON for the `truapi-platform` crate (optional).
+    ///
+    /// When provided together with `--platform-ts-output`, walks the
+    /// platform crate's capability traits and emits the typed TS
+    /// `HostCallbacks` surface so all host implementations (TS, Kotlin via
+    /// UniFFI, Swift via UniFFI) track the same Rust source.
+    #[arg(long)]
+    platform_input: Option<String>,
+
+    /// Output directory for the generated typed `HostCallbacks` TypeScript
+    /// surface (optional). Only honored when `--platform-input` is also set.
+    #[arg(long)]
+    platform_ts_output: Option<String>,
+
     /// Output directory for generated explorer metadata (optional). When set,
     /// writes `codegen/types.ts` with the DataType list consumed by the
     /// explorer site.
@@ -122,6 +146,24 @@ fn main() -> Result<()> {
         ts::generate_host(&api, path).with_context(|| format!("writing host package to {path}"))?;
         println!("Generated host package in {path}");
     }
+    if let Some(path) = &cli.rust_output {
+        rust::generate(&api, path)
+            .with_context(|| format!("writing Rust dispatcher to {}", path.display()))?;
+        println!("Wrote Rust dispatcher to {}", path.display());
+    }
+    if let (Some(input), Some(output)) = (&cli.platform_input, &cli.platform_ts_output) {
+        let json = std::fs::read_to_string(input)
+            .with_context(|| format!("reading platform rustdoc JSON from {input}"))?;
+        let krate =
+            rustdoc::parse(&json).with_context(|| format!("parsing platform rustdoc {input}"))?;
+        let definition = platform::extract(&krate)
+            .with_context(|| format!("extracting platform definition from {input}"))?;
+        ts::generate_host_callbacks(&definition, output)
+            .with_context(|| format!("writing host callbacks TS to {output}"))?;
+        println!("Generated typed HostCallbacks TS surface in {output}");
+    } else if cli.platform_input.is_some() != cli.platform_ts_output.is_some() {
+        anyhow::bail!("--platform-input and --platform-ts-output must be provided together");
+    }
     if let Some(path) = &cli.explorer_output {
         ts::generate_explorer(&api, path, client_version)
             .with_context(|| format!("writing explorer metadata to {path}"))?;
diff --git a/rust/crates/truapi-codegen/src/platform.rs b/rust/crates/truapi-codegen/src/platform.rs
new file mode 100644
index 00000000..96d938ae
--- /dev/null
+++ b/rust/crates/truapi-codegen/src/platform.rs
@@ -0,0 +1,654 @@
+//! Parse `truapi-platform`-style "plain capability traits" from rustdoc JSON.
+//!
+//! Unlike the `truapi` API crate, the platform crate has no `#[wire(id = N)]`
+//! annotations: it is a set of host-facing capability traits whose methods
+//! are typed `async fn`-style (`impl Future<Output = T> + Send`) or plain
+//! synchronous functions returning trait objects / `BoxStream`. This module
+//! walks the rustdoc index for every public trait in the platform crate and
+//! produces a [`PlatformDefinition`] the TS emitter can render directly.
+
+use std::collections::BTreeSet;
+
+use anyhow::{Context, Result, bail};
+
+use crate::rustdoc::{
+    Crate, Item, NameContext, TypeDef, TypeDefKind, TypeRef, VariantFields, clean_docs,
+    extract_enum, extract_struct, resolve_type, summarize_json,
+};
+
+/// Top-level extracted shape of a `truapi-platform`-style crate.
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformDefinition {
+    /// Capability traits sorted alphabetically by name.
+    pub traits: Vec<PlatformTrait>,
+    /// Local structs and enums referenced from trait method signatures,
+    /// sorted alphabetically by name. Emitted alongside the trait interfaces
+    /// so the generated TS does not have to import them from the API client.
+    pub types: Vec<TypeDef>,
+    /// Composite super-trait (`Platform: Storage + Navigation + ...`), if any.
+    pub super_trait: Option<PlatformSuperTrait>,
+}
+
+/// Single capability trait extracted from the platform crate.
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformTrait {
+    /// Trait name as it appears in source.
+    pub name: String,
+    /// Rustdoc comment on the trait.
+    pub docs: Option<String>,
+    /// Methods declared on the trait, in declaration order.
+    pub methods: Vec<PlatformMethod>,
+}
+
+/// A trait method on a capability trait.
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformMethod {
+    /// Method name as it appears in source.
+    pub name: String,
+    /// Rustdoc comment on the method.
+    pub docs: Option<String>,
+    /// Parameter list with names preserved (excluding `&self`).
+    pub params: Vec<PlatformParam>,
+    /// Return shape decoded from the method signature.
+    pub return_shape: PlatformReturn,
+    /// Whether the trait provides a default body, making the method optional
+    /// for host implementations.
+    pub has_default: bool,
+}
+
+/// Method parameter (name + type).
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformParam {
+    /// Parameter name as written in the trait method signature.
+    pub name: String,
+    /// Parameter type expressed as a [`TypeRef`].
+    pub type_ref: TypeRef,
+}
+
+/// Return shape after stripping `impl Future + Send` / `Box<dyn _>` wrappers.
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformReturn {
+    /// Whether the method returns `impl Future<...> + Send` (i.e. is async).
+    pub is_async: bool,
+    /// Unwrapped inner shape.
+    pub inner: PlatformInner,
+}
+
+/// Classification of the unwrapped return type.
+#[derive(Debug, PartialEq, Eq)]
+pub enum PlatformInner {
+    /// `()` (or no return).
+    Unit,
+    /// `Result<Ok, Err>`. The TS surface returns `Promise<Ok>` and rejects with `Err`.
+    Result { ok: TypeRef, err: TypeRef },
+    /// `BoxStream<'static, T>`, a stream of `T` items.
+    Stream(TypeRef),
+    /// `Box<dyn TraitName>`, a trait object handle to a named trait.
+    TraitObject(String),
+    /// Any other concrete type, returned as-is.
+    Plain(TypeRef),
+}
+
+/// Composite super-trait that aggregates capability traits.
+#[derive(Debug, PartialEq, Eq)]
+pub struct PlatformSuperTrait {
+    /// Name of the super-trait (e.g. `Platform`).
+    pub name: String,
+    /// Rustdoc comment on the super-trait.
+    pub docs: Option<String>,
+    /// Capability trait names this super-trait composes, in source order.
+    pub composes: Vec<String>,
+}
+
+/// Walk the platform crate and extract every public trait + its methods.
+pub fn extract(krate: &Crate) -> Result<PlatformDefinition> {
+    let trait_ids = collect_local_trait_ids(krate);
+    let names = NameContext::default();
+
+    let mut traits = Vec::new();
+    let mut super_trait = None;
+    for item_id in &trait_ids {
+        let item = krate
+            .index
+            .get(item_id)
+            .with_context(|| format!("Missing rustdoc item `{item_id}` for trait"))?;
+        let name = item
+            .name
+            .as_ref()
+            .cloned()
+            .with_context(|| format!("Trait `{item_id}` has no name"))?;
+        let trait_inner = item
+            .inner
+            .get("trait")
+            .with_context(|| format!("Trait `{name}` missing rustdoc trait body"))?;
+
+        if is_super_trait(trait_inner) {
+            if super_trait.is_some() {
+                bail!("Multiple super-traits with method-less bodies found; only one is supported");
+            }
+            super_trait = Some(extract_super_trait(&name, item, trait_inner)?);
+            continue;
+        }
+
+        traits.push(extract_capability_trait(
+            &name,
+            item,
+            trait_inner,
+            krate,
+            &names,
+        )?);
+    }
+
+    traits.sort_by(|a, b| a.name.cmp(&b.name));
+    let types = collect_referenced_local_types(krate, &traits, &names)?;
+
+    Ok(PlatformDefinition {
+        traits,
+        types,
+        super_trait,
+    })
+}
+
+/// Extract every local struct or enum whose name appears in a trait method
+/// signature.
+fn collect_referenced_local_types(
+    krate: &Crate,
+    traits: &[PlatformTrait],
+    names: &NameContext,
+) -> Result<Vec<TypeDef>> {
+    let mut referenced = BTreeSet::new();
+    for trait_def in traits {
+        for method in &trait_def.methods {
+            for param in &method.params {
+                collect_named_types(&param.type_ref, &mut referenced);
+            }
+            match &method.return_shape.inner {
+                // Err types never reach the TS signature (errors throw), so
+                // their names are not emitted either.
+                PlatformInner::Result { ok, .. } => collect_named_types(ok, &mut referenced),
+                PlatformInner::Stream(inner) | PlatformInner::Plain(inner) => {
+                    collect_named_types(inner, &mut referenced)
+                }
+                PlatformInner::TraitObject(_) | PlatformInner::Unit => {}
+            }
+        }
+    }
+
+    // Local types can reference further local types from their fields or
+    // variant payloads (e.g. `AuthState::Connected(SessionUiInfo)`), so keep
+    // extracting until the referenced set stops growing.
+    let mut types: Vec<TypeDef> = Vec::new();
+    let mut extracted: BTreeSet<String> = BTreeSet::new();
+    loop {
+        let mut grew = false;
+        for (item_id, item_path) in &krate.paths {
+            if item_path.crate_id != 0 || !matches!(item_path.kind.as_str(), "struct" | "enum") {
+                continue;
+            }
+            let Some(name) = item_path.path.last() else {
+                continue;
+            };
+            if !referenced.contains(name) || extracted.contains(name) {
+                continue;
+            }
+            let item = krate.index.get(item_id).with_context(|| {
+                format!(
+                    "Missing rustdoc item `{item_id}` for {} `{name}`",
+                    item_path.kind
+                )
+            })?;
+            let module_path = item_path.path[..item_path.path.len() - 1].to_vec();
+            let type_def = if item_path.kind == "struct" {
+                extract_struct(item_id, item, krate, names, module_path)?
+            } else {
+                extract_enum(item_id, item, krate, names, module_path)?
+            };
+            collect_type_def_references(&type_def, &mut referenced);
+            extracted.insert(name.clone());
+            types.push(type_def);
+            grew = true;
+        }
+        if !grew {
+            break;
+        }
+    }
+    types.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(types)
+}
+
+/// Collect named types referenced from a local type's fields or variants.
+fn collect_type_def_references(type_def: &TypeDef, out: &mut BTreeSet<String>) {
+    match &type_def.kind {
+        TypeDefKind::Alias(ty) => collect_named_types(ty, out),
+        TypeDefKind::Struct(fields) => {
+            for field in fields {
+                collect_named_types(&field.type_ref, out);
+            }
+        }
+        TypeDefKind::TupleStruct(types) => {
+            for ty in types {
+                collect_named_types(ty, out);
+            }
+        }
+        TypeDefKind::Enum(variants) => {
+            for variant in variants {
+                match &variant.fields {
+                    VariantFields::Unit => {}
+                    VariantFields::Unnamed(types) => {
+                        for ty in types {
+                            collect_named_types(ty, out);
+                        }
+                    }
+                    VariantFields::Named(fields) => {
+                        for field in fields {
+                            collect_named_types(&field.type_ref, out);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn collect_named_types(ty: &TypeRef, out: &mut BTreeSet<String>) {
+    match ty {
+        TypeRef::Named { name, args } => {
+            out.insert(name.clone());
+            for arg in args {
+                collect_named_types(arg, out);
+            }
+        }
+        TypeRef::Vec(inner) | TypeRef::Option(inner) | TypeRef::Array(inner, _) => {
+            collect_named_types(inner, out)
+        }
+        TypeRef::Tuple(items) => {
+            for item in items {
+                collect_named_types(item, out);
+            }
+        }
+        TypeRef::Primitive(_) | TypeRef::Generic(_) | TypeRef::Unit => {}
+    }
+}
+
+fn collect_local_trait_ids(krate: &Crate) -> BTreeSet<String> {
+    let mut out = BTreeSet::new();
+    for (item_id, item_path) in &krate.paths {
+        if item_path.crate_id != 0 || item_path.kind != "trait" {
+            continue;
+        }
+        out.insert(item_id.clone());
+    }
+    out
+}
+
+fn is_super_trait(trait_inner: &serde_json::Value) -> bool {
+    let no_methods = trait_inner
+        .get("items")
+        .and_then(|value| value.as_array())
+        .map(|arr| arr.is_empty())
+        .unwrap_or(true);
+
+    let has_local_trait_bound = trait_inner
+        .get("bounds")
+        .and_then(|value| value.as_array())
+        .map(|bounds| {
+            bounds.iter().any(|bound| {
+                bound
+                    .get("trait_bound")
+                    .and_then(|tb| tb.get("trait"))
+                    .and_then(|t| t.get("path"))
+                    .and_then(|p| p.as_str())
+                    .map(|name| name != "Send" && name != "Sync")
+                    .unwrap_or(false)
+            })
+        })
+        .unwrap_or(false);
+
+    no_methods && has_local_trait_bound
+}
+
+fn extract_super_trait(
+    name: &str,
+    item: &Item,
+    trait_inner: &serde_json::Value,
+) -> Result<PlatformSuperTrait> {
+    let bounds = trait_inner
+        .get("bounds")
+        .and_then(|value| value.as_array())
+        .with_context(|| format!("Super-trait `{name}` missing rustdoc bounds"))?;
+
+    let mut composes = Vec::new();
+    for bound in bounds {
+        let Some(path) = bound
+            .get("trait_bound")
+            .and_then(|tb| tb.get("trait"))
+            .and_then(|t| t.get("path"))
+            .and_then(|p| p.as_str())
+        else {
+            continue;
+        };
+        if path == "Send" || path == "Sync" {
+            continue;
+        }
+        composes.push(path.to_string());
+    }
+
+    Ok(PlatformSuperTrait {
+        name: name.to_string(),
+        docs: clean_docs(item.docs.as_deref()),
+        composes,
+    })
+}
+
+fn extract_capability_trait(
+    name: &str,
+    item: &Item,
+    trait_inner: &serde_json::Value,
+    krate: &Crate,
+    names: &NameContext,
+) -> Result<PlatformTrait> {
+    let item_ids = trait_inner
+        .get("items")
+        .and_then(|value| value.as_array())
+        .with_context(|| format!("Trait `{name}` missing rustdoc items array"))?;
+
+    let mut methods = Vec::new();
+    for method_id in item_ids {
+        let method_id = value_to_id(method_id)
+            .with_context(|| format!("Trait `{name}` contained a non-item method id"))?;
+        let method_item = krate
+            .index
+            .get(&method_id)
+            .with_context(|| format!("Trait `{name}` references missing item `{method_id}`"))?;
+        if let Some(method) = extract_method(method_item, names)? {
+            methods.push(method);
+        }
+    }
+
+    Ok(PlatformTrait {
+        name: name.to_string(),
+        docs: clean_docs(item.docs.as_deref()),
+        methods,
+    })
+}
+
+fn extract_method(item: &Item, names: &NameContext) -> Result<Option<PlatformMethod>> {
+    let Some(fn_inner) = item.inner.get("function") else {
+        return Ok(None);
+    };
+    let name = item
+        .name
+        .as_ref()
+        .cloned()
+        .with_context(|| "Method item has no name".to_string())?;
+    let sig = fn_inner
+        .get("sig")
+        .with_context(|| format!("Method `{name}` missing rustdoc signature"))?;
+
+    let mut params = Vec::new();
+    if let Some(inputs) = sig.get("inputs").and_then(|value| value.as_array()) {
+        for input in inputs {
+            let arr = input
+                .as_array()
+                .with_context(|| format!("Method `{name}` has an invalid input entry"))?;
+            let param_name = arr
+                .first()
+                .and_then(|value| value.as_str())
+                .with_context(|| format!("Method `{name}` has an unnamed input"))?
+                .to_string();
+            if param_name == "self" {
+                continue;
+            }
+            let ty = arr.get(1).with_context(|| {
+                format!("Method `{name}` input `{param_name}` is missing a type")
+            })?;
+            let type_ref = resolve_type(ty, names).with_context(|| {
+                format!("Method `{name}` input `{param_name}` has an unsupported type")
+            })?;
+            params.push(PlatformParam {
+                name: param_name,
+                type_ref,
+            });
+        }
+    }
+
+    let return_shape = resolve_return(sig.get("output"), names)
+        .with_context(|| format!("Method `{name}` has an unsupported return type"))?;
+    let has_default = fn_inner
+        .get("has_body")
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false);
+
+    Ok(Some(PlatformMethod {
+        name,
+        docs: clean_docs(item.docs.as_deref()),
+        params,
+        return_shape,
+        has_default,
+    }))
+}
+
+fn resolve_return(
+    output: Option<&serde_json::Value>,
+    names: &NameContext,
+) -> Result<PlatformReturn> {
+    let Some(output) = output else {
+        return Ok(PlatformReturn {
+            is_async: false,
+            inner: PlatformInner::Unit,
+        });
+    };
+    if output.is_null() {
+        return Ok(PlatformReturn {
+            is_async: false,
+            inner: PlatformInner::Unit,
+        });
+    }
+
+    if let Some(future_output) = extract_impl_future_output(output) {
+        let inner = resolve_inner_shape(&future_output, names)?;
+        return Ok(PlatformReturn {
+            is_async: true,
+            inner,
+        });
+    }
+
+    let inner = resolve_inner_shape(output, names)?;
+    Ok(PlatformReturn {
+        is_async: false,
+        inner,
+    })
+}
+
+fn extract_impl_future_output(output: &serde_json::Value) -> Option<serde_json::Value> {
+    let bounds = output.get("impl_trait")?.as_array()?;
+    for bound in bounds {
+        // Skip non-trait bounds (outlives, `use<..>` captures) instead of
+        // aborting: a `Future` trait bound may come after them.
+        let Some(trait_obj) = bound.get("trait_bound").and_then(|tb| tb.get("trait")) else {
+            continue;
+        };
+        if trait_obj.get("path").and_then(|p| p.as_str()) != Some("Future") {
+            continue;
+        }
+        let constraints = trait_obj
+            .get("args")?
+            .get("angle_bracketed")?
+            .get("constraints")?
+            .as_array()?;
+        for constraint in constraints {
+            if constraint.get("name")?.as_str()? != "Output" {
+                continue;
+            }
+            let ty = constraint.get("binding")?.get("equality")?.get("type")?;
+            return Some(ty.clone());
+        }
+    }
+    None
+}
+
+fn resolve_inner_shape(ty: &serde_json::Value, names: &NameContext) -> Result<PlatformInner> {
+    // `()` tuple.
+    if let Some(arr) = ty.get("tuple").and_then(|v| v.as_array())
+        && arr.is_empty()
+    {
+        return Ok(PlatformInner::Unit);
+    }
+
+    if let Some(resolved) = ty.get("resolved_path") {
+        let path = resolved
+            .get("path")
+            .and_then(|v| v.as_str())
+            .unwrap_or_default();
+        let leaf = path.rsplit("::").next().unwrap_or(path);
+
+        match leaf {
+            "Result" => {
+                let ok =
+                    generic_arg(resolved, 0).context("Result<...> return type missing ok arg")?;
+                let err =
+                    generic_arg(resolved, 1).context("Result<...> return type missing err arg")?;
+                let ok_ref = resolve_inner_type(&ok, names)?;
+                let err_ref = resolve_inner_type(&err, names)?;
+                return Ok(PlatformInner::Result {
+                    ok: ok_ref,
+                    err: err_ref,
+                });
+            }
+            "BoxStream" => {
+                // `BoxStream<'a, T>`: the lifetime arg is filtered out by
+                // `generic_arg` (it has no `type` field), so the first
+                // remaining positional arg is the item type.
+                let item =
+                    generic_arg(resolved, 0).context("BoxStream<'a, T> missing item type")?;
+                return Ok(PlatformInner::Stream(resolve_type(&item, names)?));
+            }
+            "Box" => {
+                // `Box<dyn TraitName>` or `Box<T>`.
+                if let Some(arg) = generic_arg(resolved, 0)
+                    && let Some(dyn_trait) = arg.get("dyn_trait")
+                {
+                    let trait_name = dyn_trait
+                        .get("traits")
+                        .and_then(|t| t.as_array())
+                        .and_then(|arr| arr.first())
+                        .and_then(|first| first.get("trait"))
+                        .and_then(|trait_obj| trait_obj.get("path"))
+                        .and_then(|p| p.as_str())
+                        .context("Box<dyn Trait> missing trait path")?
+                        .rsplit("::")
+                        .next()
+                        .unwrap_or_default()
+                        .to_string();
+                    return Ok(PlatformInner::TraitObject(trait_name));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    let resolved_ref = resolve_type(ty, names)
+        .with_context(|| format!("Unsupported return shape: {}", summarize_json(ty)))?;
+    Ok(PlatformInner::Plain(resolved_ref))
+}
+
+/// Resolve a positional type. Recognises `Box<dyn TraitName>` and folds it
+/// into a `TypeRef::Named { name: TraitName, args: [] }` so it survives
+/// through to TS emission without `rustdoc.rs` having to model dyn traits.
+fn resolve_inner_type(ty: &serde_json::Value, names: &NameContext) -> Result<TypeRef> {
+    if let Some(resolved) = ty.get("resolved_path")
+        && resolved
+            .get("path")
+            .and_then(|v| v.as_str())
+            .map(|p| p.rsplit("::").next().unwrap_or(p) == "Box")
+            .unwrap_or(false)
+        && let Some(arg) = generic_arg(resolved, 0)
+        && let Some(dyn_trait) = arg.get("dyn_trait")
+    {
+        let trait_name = dyn_trait
+            .get("traits")
+            .and_then(|t| t.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|first| first.get("trait"))
+            .and_then(|trait_obj| trait_obj.get("path"))
+            .and_then(|p| p.as_str())
+            .context("Box<dyn Trait> missing trait path")?
+            .rsplit("::")
+            .next()
+            .unwrap_or_default()
+            .to_string();
+        return Ok(TypeRef::Named {
+            name: trait_name,
+            args: Vec::new(),
+        });
+    }
+    resolve_type(ty, names)
+}
+
+fn generic_arg(resolved: &serde_json::Value, index: usize) -> Option<serde_json::Value> {
+    resolved
+        .get("args")?
+        .get("angle_bracketed")?
+        .get("args")?
+        .as_array()?
+        .iter()
+        .filter_map(|entry| entry.get("type").cloned())
+        .nth(index)
+}
+
+fn value_to_id(value: &serde_json::Value) -> Result<String> {
+    if let Some(id) = value.as_str() {
+        return Ok(id.to_string());
+    }
+    if let Some(id) = value.as_u64() {
+        return Ok(id.to_string());
+    }
+    bail!("Expected rustdoc item id, got non-id value")
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    /// A non-trait bound (e.g. an outlives or `use<..>` capture bound)
+    /// preceding the `Future` bound must be skipped, not misclassify the
+    /// method as synchronous.
+    #[test]
+    fn extract_impl_future_output_skips_non_trait_bounds() {
+        let output = json!({
+            "impl_trait": [
+                { "outlives": "'static" },
+                {
+                    "trait_bound": {
+                        "trait": {
+                            "path": "Future",
+                            "args": {
+                                "angle_bracketed": {
+                                    "args": [],
+                                    "constraints": [
+                                        {
+                                            "name": "Output",
+                                            "binding": {
+                                                "equality": {
+                                                    "type": { "primitive": "u8" }
+                                                }
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                },
+                { "trait_bound": { "trait": { "path": "Send" } } }
+            ]
+        });
+
+        assert_eq!(
+            extract_impl_future_output(&output),
+            Some(json!({ "primitive": "u8" }))
+        );
+    }
+}
diff --git a/rust/crates/truapi-codegen/src/rust.rs b/rust/crates/truapi-codegen/src/rust.rs
new file mode 100644
index 00000000..e623d7bd
--- /dev/null
+++ b/rust/crates/truapi-codegen/src/rust.rs
@@ -0,0 +1,574 @@
+//! Rust code generation from extracted API definitions.
+//!
+//! Emits the server-side wire dispatcher (`dispatcher.rs`) and the
+//! discriminant lookup table (`wire_table.rs`). The generated files are
+//! intended to be included in the `truapi-server` crate.
+
+use std::fs;
+use std::path::Path;
+
+use anyhow::Result;
+
+use crate::rustdoc::*;
+
+mod dispatcher;
+mod wire_table;
+
+pub use dispatcher::generate_dispatcher;
+pub use wire_table::generate_wire_table;
+
+/// Generates the Rust wire dispatcher and wire-table sources into `output_dir`.
+pub fn generate(api: &ApiDefinition, output_dir: &Path) -> Result<()> {
+    fs::create_dir_all(output_dir)?;
+    let dispatcher = generate_dispatcher(api)?;
+    fs::write(output_dir.join("dispatcher.rs"), dispatcher)?;
+    let wire_table = generate_wire_table(api)?;
+    fs::write(output_dir.join("wire_table.rs"), wire_table)?;
+    Ok(())
+}
+
+/// Trait -> versioned-module mapping. Trait names are PascalCase
+/// (`JsonRpc`, `LocalStorage`); module names are snake_case
+/// (`jsonrpc`, `local_storage`). The mapping is irregular enough
+/// (e.g. `JsonRpc` -> `jsonrpc`) that it is hardcoded.
+const TRAIT_MODULE_MAP: &[(&str, &str)] = &[
+    ("Account", "account"),
+    ("Chain", "chain"),
+    ("Chat", "chat"),
+    ("Entropy", "entropy"),
+    ("JsonRpc", "jsonrpc"),
+    ("LocalStorage", "local_storage"),
+    ("Payment", "payment"),
+    ("Permissions", "permissions"),
+    ("Preimage", "preimage"),
+    ("ResourceAllocation", "resource_allocation"),
+    ("Signing", "signing"),
+    ("StatementStore", "statement_store"),
+    ("System", "system"),
+    ("Theme", "theme"),
+];
+
+/// Returns the versioned-module name for a trait, falling back to a
+/// snake_case conversion of the trait name when no explicit mapping is
+/// declared. New traits should be added to [`TRAIT_MODULE_MAP`] so the
+/// emission stays deterministic.
+fn module_for_trait(trait_name: &str) -> String {
+    for (name, module) in TRAIT_MODULE_MAP {
+        if *name == trait_name {
+            return (*module).to_string();
+        }
+    }
+    snake_case(trait_name)
+}
+
+/// Returns the wire-protocol method name for a trait/method pair, used both
+/// as the dispatcher's registration key and as the prefix of the action tag
+/// (`{wire_method}_{request|response|...}`). The form is
+/// `{trait_snake}_{method}` so collisions between sibling traits (e.g.
+/// `StatementStore::submit` and `Preimage::submit`) become distinct keys
+/// (`statement_store_submit`, `preimage_submit`).
+pub(crate) fn wire_method_name(trait_name: &str, method_name: &str) -> String {
+    format!("{}_{}", snake_case(trait_name), method_name)
+}
+
+/// The `SCREAMING_SNAKE_CASE` const name holding a wire method's ids.
+pub(crate) fn const_name(wire_method: &str) -> String {
+    wire_method.to_uppercase()
+}
+
+/// Const name for a trait/method pair's wire ids. The single naming
+/// algorithm shared by the Rust and TS wire-table emitters, so both
+/// generated surfaces agree on const names.
+pub(crate) fn wire_const_name(trait_name: &str, method_name: &str) -> String {
+    const_name(&wire_method_name(trait_name, method_name))
+}
+
+/// Convert a PascalCase identifier into snake_case.
+fn snake_case(name: &str) -> String {
+    let mut out = String::with_capacity(name.len() + 4);
+    for (idx, ch) in name.chars().enumerate() {
+        if ch.is_ascii_uppercase() {
+            if idx != 0 {
+                out.push('_');
+            }
+            out.push(ch.to_ascii_lowercase());
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_request_method(name: &str, request_id: u8) -> MethodDef {
+        MethodDef {
+            name: name.to_string(),
+            kind: MethodKind::Request,
+            params: vec![ParamDef {
+                name: "request".to_string(),
+                type_ref: TypeRef::Named {
+                    name: "ReqWrapper".to_string(),
+                    args: vec![],
+                },
+            }],
+            return_type: ReturnType::Result {
+                ok: TypeRef::Named {
+                    name: "RespWrapper".to_string(),
+                    args: vec![],
+                },
+                err: TypeRef::Named {
+                    name: "CallError".to_string(),
+                    args: vec![TypeRef::Named {
+                        name: "ErrWrapper".to_string(),
+                        args: vec![],
+                    }],
+                },
+            },
+            wire: WireAttrs {
+                request_id: Some(request_id),
+                response_id: None,
+                start_id: None,
+                stop_id: None,
+                interrupt_id: None,
+                receive_id: None,
+            },
+            docs: None,
+        }
+    }
+
+    fn make_subscription_method(name: &str, start_id: u8) -> MethodDef {
+        MethodDef {
+            name: name.to_string(),
+            kind: MethodKind::Subscription,
+            params: vec![],
+            return_type: ReturnType::Subscription(TypeRef::Named {
+                name: "ItemWrapper".to_string(),
+                args: vec![],
+            }),
+            wire: WireAttrs {
+                request_id: None,
+                response_id: None,
+                start_id: Some(start_id),
+                stop_id: None,
+                interrupt_id: None,
+                receive_id: None,
+            },
+            docs: None,
+        }
+    }
+
+    fn parse_entries(src: &str) -> Vec<(u8, String)> {
+        // Each method's ids are emitted as a named const, e.g.
+        //   pub const PREIMAGE_SUBMIT: RequestFrameIds = RequestFrameIds {
+        //       request_id: 68,
+        //       response_id: 69,
+        //   };
+        // Reconstruct the `(id, "{method}_{suffix}")` pairs the assertions use,
+        // mirroring the parser in `tests/wire_table_ts_parity.rs`.
+        let mut out = Vec::new();
+        let mut lines = src.lines();
+        while let Some(line) = lines.next() {
+            let Some(rest) = line.trim().strip_prefix("pub const ") else {
+                continue;
+            };
+            let Some(colon) = rest.find(':') else {
+                continue;
+            };
+            let is_sub = rest.contains("SubscriptionFrameIds");
+            // Skip non-id consts (e.g. `WIRE_TABLE: &[WireEntry]`).
+            if !is_sub && !rest.contains("RequestFrameIds") {
+                continue;
+            }
+            let method = rest[..colon].trim().to_ascii_lowercase();
+
+            let mut ids: std::collections::BTreeMap<&str, u8> = std::collections::BTreeMap::new();
+            for inner in lines.by_ref() {
+                let t = inner.trim();
+                if t.starts_with("};") {
+                    break;
+                }
+                if let Some((field, val)) = t.split_once(':') {
+                    let id = val.trim().trim_end_matches(',').parse::<u8>().unwrap();
+                    ids.insert(field.trim(), id);
+                }
+            }
+
+            let suffixes: &[(&str, &str)] = if is_sub {
+                &[
+                    ("start_id", "start"),
+                    ("stop_id", "stop"),
+                    ("interrupt_id", "interrupt"),
+                    ("receive_id", "receive"),
+                ]
+            } else {
+                &[("request_id", "request"), ("response_id", "response")]
+            };
+            for (field, suffix) in suffixes {
+                out.push((ids[field], format!("{method}_{suffix}")));
+            }
+        }
+        out
+    }
+
+    /// A single subscription method must reserve four consecutive wire
+    /// ids (start/stop/interrupt/receive) even when no sibling methods
+    /// exist to mask off-by-one errors.
+    #[test]
+    fn wire_table_subscribe_method_reserves_four_ids() {
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Account".to_string(),
+                module_path: Vec::new(),
+                methods: vec![make_subscription_method("connection_status_subscribe", 18)],
+                docs: None,
+            }],
+            public_trait_order: vec!["Account".to_string()],
+            types: vec![],
+        };
+
+        let src = generate_wire_table(&api).expect("generate_wire_table");
+        let entries = parse_entries(&src);
+        assert_eq!(
+            entries,
+            vec![
+                (18, "account_connection_status_subscribe_start".into()),
+                (19, "account_connection_status_subscribe_stop".into()),
+                (20, "account_connection_status_subscribe_interrupt".into()),
+                (21, "account_connection_status_subscribe_receive".into()),
+            ],
+        );
+    }
+
+    /// Two traits each declaring a method named `submit` must produce two
+    /// distinct, non-colliding wire method keys; the emitter prefixes by
+    /// the snake_case trait name (e.g. `statement_store_submit` /
+    /// `preimage_submit`).
+    #[test]
+    fn collision_safe_when_two_traits_share_method_name() {
+        let api = ApiDefinition {
+            traits: vec![
+                TraitDef {
+                    name: "StatementStore".to_string(),
+                    module_path: Vec::new(),
+                    methods: vec![make_request_method("submit", 62)],
+                    docs: None,
+                },
+                TraitDef {
+                    name: "Preimage".to_string(),
+                    module_path: Vec::new(),
+                    methods: vec![make_request_method("submit", 68)],
+                    docs: None,
+                },
+            ],
+            public_trait_order: vec!["StatementStore".to_string(), "Preimage".to_string()],
+            types: vec![],
+        };
+
+        let dispatcher = generate_dispatcher(&api).expect("dispatcher");
+        assert!(
+            dispatcher.contains("wire_table::STATEMENT_STORE_SUBMIT"),
+            "dispatcher missing prefixed StatementStore const:\n{dispatcher}"
+        );
+        assert!(
+            dispatcher.contains("wire_table::PREIMAGE_SUBMIT"),
+            "dispatcher missing prefixed Preimage const:\n{dispatcher}"
+        );
+
+        let table = generate_wire_table(&api).expect("wire_table");
+        let entries = parse_entries(&table);
+        assert!(
+            entries
+                .iter()
+                .any(|(_, tag)| tag == "statement_store_submit_request"),
+            "wire_table missing prefixed StatementStore tag:\n{table}"
+        );
+        assert!(
+            entries
+                .iter()
+                .any(|(_, tag)| tag == "preimage_submit_request"),
+            "wire_table missing prefixed Preimage tag:\n{table}"
+        );
+    }
+
+    /// If a future change ever produces the same wire method key from two
+    /// different (trait, method) pairs, both emitters must fail loudly
+    /// rather than silently overwrite a handler.
+    #[test]
+    fn wire_table_rejects_method_name_collision() {
+        // `Foo::bar_baz` and `FooBar::baz` both snake-case to
+        // `foo_bar_baz`. The emitter must reject the pair.
+        let api = ApiDefinition {
+            traits: vec![
+                TraitDef {
+                    name: "Foo".to_string(),
+                    module_path: Vec::new(),
+                    methods: vec![make_request_method("bar_baz", 10)],
+                    docs: None,
+                },
+                TraitDef {
+                    name: "FooBar".to_string(),
+                    module_path: Vec::new(),
+                    methods: vec![make_request_method("baz", 12)],
+                    docs: None,
+                },
+            ],
+            public_trait_order: vec!["Foo".to_string(), "FooBar".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("duplicate wire method name must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("wire method name `foo_bar_baz` reused"),
+            "unexpected error message: {msg}",
+        );
+
+        let err = generate_dispatcher(&api).expect_err("duplicate wire method name must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("Wire method name `foo_bar_baz` registered twice"),
+            "unexpected dispatcher error message: {msg}",
+        );
+    }
+
+    /// Emission must be deterministic: running the codegen twice on the
+    /// same API produces byte-identical output.
+    #[test]
+    fn idempotent_emission() {
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![make_request_method("request_device_permission", 8)],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+
+        let dispatcher_a = generate_dispatcher(&api).expect("dispatcher a");
+        let dispatcher_b = generate_dispatcher(&api).expect("dispatcher b");
+        assert_eq!(dispatcher_a, dispatcher_b);
+
+        let table_a = generate_wire_table(&api).expect("wire_table a");
+        let table_b = generate_wire_table(&api).expect("wire_table b");
+        assert_eq!(table_a, table_b);
+    }
+
+    /// Methods with a `#[wire(request_id = N)]` annotation get a 2-id
+    /// slot (request/response). Methods with `#[wire(start_id = N)]`
+    /// get a 4-id slot (start/stop/interrupt/receive). The emitter
+    /// must enforce that, and reject collisions.
+    #[test]
+    fn wire_table_rejects_collisions() {
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![
+                    make_request_method("alpha", 10),
+                    make_request_method("beta", 10),
+                ],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("duplicate ids must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("wire id 10 reused"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// `wire_const_name` is the single naming algorithm for wire-id consts;
+    /// the TS and Rust emitters both call it. Pin its behavior on digits
+    /// (kept attached) and consecutive capitals (split per letter) so the
+    /// two generated surfaces can never drift apart.
+    #[test]
+    fn wire_const_name_pins_digits_and_acronyms() {
+        assert_eq!(wire_const_name("Preimage", "submit"), "PREIMAGE_SUBMIT");
+        assert_eq!(wire_const_name("Signing", "sign_v2"), "SIGNING_SIGN_V2");
+        assert_eq!(
+            wire_const_name("HTTPServer", "serve"),
+            "H_T_T_P_SERVER_SERVE"
+        );
+        assert_eq!(
+            wire_const_name("StatementStore", "create_proof"),
+            "STATEMENT_STORE_CREATE_PROOF"
+        );
+    }
+
+    #[test]
+    fn module_for_trait_maps_irregular_names() {
+        assert_eq!(module_for_trait("JsonRpc"), "jsonrpc");
+        assert_eq!(module_for_trait("LocalStorage"), "local_storage");
+        assert_eq!(
+            module_for_trait("ResourceAllocation"),
+            "resource_allocation"
+        );
+        assert_eq!(module_for_trait("Account"), "account");
+    }
+
+    /// A request-kind method must not carry subscription wire ids. The
+    /// emitter rejects `start_id` / `stop_id` / `interrupt_id` / `receive_id`
+    /// on a `MethodKind::Request`.
+    #[test]
+    fn wire_table_request_with_subscription_id_errors() {
+        let mut method = make_request_method("alpha", 10);
+        method.wire.start_id = Some(99);
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("request kind + start_id must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("must not use subscription wire ids"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// A subscription-kind method must not carry request wire ids.
+    #[test]
+    fn wire_table_subscription_with_request_id_errors() {
+        let mut method = make_subscription_method("connection_status_subscribe", 18);
+        method.wire.request_id = Some(99);
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Account".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Account".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("subscription kind + request_id must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("must not use request wire ids"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// A request-kind method missing the mandatory `request_id` annotation
+    /// must fail emission, not silently default to 0.
+    #[test]
+    fn wire_table_missing_request_id_errors() {
+        let mut method = make_request_method("alpha", 10);
+        method.wire.request_id = None;
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("missing request_id annotation must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("missing #[wire(request_id"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// Subscription-kind method missing `start_id` is similarly rejected.
+    #[test]
+    fn wire_table_missing_start_id_errors() {
+        let mut method = make_subscription_method("connection_status_subscribe", 18);
+        method.wire.start_id = None;
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Account".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Account".to_string()],
+            types: vec![],
+        };
+        let err = generate_wire_table(&api).expect_err("missing start_id annotation must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("missing #[wire(start_id"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// The dispatcher expects each method to take exactly one versioned
+    /// wrapper parameter (plus `&self` and `&CallContext`, which are
+    /// elided from `params`). A method with two params errors out.
+    #[test]
+    fn dispatcher_multi_param_method_errors() {
+        let mut method = make_request_method("alpha", 10);
+        method.params.push(ParamDef {
+            name: "extra".to_string(),
+            type_ref: TypeRef::Named {
+                name: "ExtraWrapper".to_string(),
+                args: vec![],
+            },
+        });
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+        let err = generate_dispatcher(&api).expect_err("two-param method must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("expected at most one request parameter"),
+            "unexpected error message: {msg}",
+        );
+    }
+
+    /// The response wrapper extraction expects a `TypeRef::Named` with no
+    /// generic args. Anything else (primitives, tuples, generics) errors.
+    #[test]
+    fn dispatcher_non_named_root_response_errors() {
+        let mut method = make_request_method("alpha", 10);
+        method.return_type = ReturnType::Result {
+            ok: TypeRef::Primitive("u32".to_string()),
+            err: TypeRef::Named {
+                name: "CallError".to_string(),
+                args: vec![TypeRef::Named {
+                    name: "ErrWrapper".to_string(),
+                    args: vec![],
+                }],
+            },
+        };
+        let api = ApiDefinition {
+            traits: vec![TraitDef {
+                name: "Permissions".to_string(),
+                module_path: Vec::new(),
+                methods: vec![method],
+                docs: None,
+            }],
+            public_trait_order: vec!["Permissions".to_string()],
+            types: vec![],
+        };
+        let err = generate_dispatcher(&api).expect_err("primitive response must error");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("response is not a versioned wrapper"),
+            "unexpected error message: {msg}",
+        );
+    }
+}
diff --git a/rust/crates/truapi-codegen/src/rust/dispatcher.rs b/rust/crates/truapi-codegen/src/rust/dispatcher.rs
new file mode 100644
index 00000000..5989acfa
--- /dev/null
+++ b/rust/crates/truapi-codegen/src/rust/dispatcher.rs
@@ -0,0 +1,461 @@
+//! Emits `dispatcher.rs`: the server-side wire dispatcher that routes
+//! incoming frames to the host trait implementation.
+//!
+//! For each method the emitter produces an `on_request` (or
+//! `on_subscription`) registration that:
+//! 1. SCALE-decodes the versioned request wrapper from the wire bytes.
+//! 2. Calls the host trait method (which receives the wrapper directly
+//!    and matches `_::V1(inner)` internally).
+//! 3. SCALE-encodes the versioned response wrapper back onto the wire.
+//!
+//! The generated file expects to live inside a `truapi-server` crate
+//! and references `crate::dispatcher::Dispatcher`. The codegen itself
+//! does not compile the output; string-diff golden tests guard it.
+
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::fmt::Write;
+
+use anyhow::{Result, bail};
+use indoc::{formatdoc, indoc, writedoc};
+
+use crate::rustdoc::*;
+
+use super::{const_name, module_for_trait, wire_method_name};
+
+/// Emit the contents of `dispatcher.rs`.
+pub fn generate_dispatcher(api: &ApiDefinition) -> Result<String> {
+    let traits = order_traits(api)?;
+
+    // Reject any duplicate wire method name across traits before emission, so
+    // a future addition can't silently overwrite a handler in the HashMap.
+    let mut seen: BTreeSet<String> = BTreeSet::new();
+    for trait_def in &traits {
+        for method in &trait_def.methods {
+            let key = wire_method_name(&trait_def.name, &method.name);
+            if !seen.insert(key.clone()) {
+                bail!(
+                    "Wire method name `{key}` registered twice; \
+                     change `{}::{}` or its sibling trait to disambiguate",
+                    trait_def.name,
+                    method.name
+                );
+            }
+        }
+    }
+
+    let mut modules = Vec::with_capacity(traits.len());
+    for trait_def in &traits {
+        modules.push(ModuleEmission::build(trait_def)?);
+    }
+
+    let mut out = String::new();
+    write_header(&mut out);
+    write_imports(&mut out, &traits);
+    writeln!(out).unwrap();
+    write_top_register(&mut out, &traits);
+
+    for module in &modules {
+        writeln!(out).unwrap();
+        out.push_str(&module.code);
+    }
+
+    Ok(out)
+}
+
+/// Returns the traits to emit, in the order declared by the top-level
+/// `TrUApi` super-trait. Falls back to alphabetical order if the
+/// extractor did not record a public ordering (e.g. synthetic tests).
+fn order_traits(api: &ApiDefinition) -> Result<Vec<&TraitDef>> {
+    let by_name: BTreeMap<&str, &TraitDef> =
+        api.traits.iter().map(|t| (t.name.as_str(), t)).collect();
+
+    if api.public_trait_order.is_empty() {
+        return Ok(api.traits.iter().collect());
+    }
+
+    let mut ordered = Vec::with_capacity(api.public_trait_order.len());
+    for name in &api.public_trait_order {
+        let Some(trait_def) = by_name.get(name.as_str()) else {
+            bail!("trait `{name}` appears in TrUApi but was not extracted");
+        };
+        ordered.push(*trait_def);
+    }
+    Ok(ordered)
+}
+
+struct ModuleEmission {
+    code: String,
+}
+
+impl ModuleEmission {
+    fn build(trait_def: &TraitDef) -> Result<Self> {
+        let module = module_for_trait(&trait_def.name);
+
+        let mut methods = Vec::with_capacity(trait_def.methods.len());
+        for method in &trait_def.methods {
+            let wire_method = wire_method_name(&trait_def.name, &method.name);
+            methods.push(MethodEmission::build(&module, &wire_method, method)?);
+        }
+
+        let fn_name = format!("register_{module}");
+        let trait_name = &trait_def.name;
+        let mut code = String::new();
+        writedoc!(
+            code,
+            r#"
+            fn {fn_name}<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+            where
+                P: {trait_name} + Send + Sync + 'static,
+            {{
+            "#
+        )
+        .unwrap();
+        let last = methods.len().saturating_sub(1);
+        for (idx, method) in methods.iter().enumerate() {
+            let host_expr = if idx == last { "host" } else { "host.clone()" };
+            method.write(&mut code, host_expr);
+        }
+        writeln!(code, "}}").unwrap();
+
+        Ok(ModuleEmission { code })
+    }
+}
+
+struct MethodEmission {
+    /// Rust method name on the host trait (used for the `host.<name>(...)` call).
+    name: String,
+    /// Fully-qualified wire method name (`{trait_snake}_{method}`); uppercased
+    /// to the `wire_table` const this method registers against.
+    wire_name: String,
+    module: String,
+    kind: MethodKind,
+    request_wrapper: Option<String>,
+    response_wrapper: Option<String>,
+    item_wrapper: Option<String>,
+}
+
+impl MethodEmission {
+    fn build(module: &str, wire_method: &str, method: &MethodDef) -> Result<Self> {
+        let request_wrapper = match method.params.as_slice() {
+            [] => None,
+            [param] => match &param.type_ref {
+                TypeRef::Named { name, args } if args.is_empty() => Some(name.clone()),
+                _ => bail!(
+                    "Method `{}`: expected a single versioned-wrapper request parameter",
+                    method.name
+                ),
+            },
+            _ => bail!(
+                "Method `{}`: expected at most one request parameter (got {})",
+                method.name,
+                method.params.len()
+            ),
+        };
+
+        let (response_wrapper, item_wrapper) = match &method.return_type {
+            // `Result<(), _>` returns produce an empty wire payload.
+            // The trait method is called for its side effects and the
+            // dispatcher encodes `()` (zero bytes) on success.
+            ReturnType::Result {
+                ok: TypeRef::Unit, ..
+            } => (None, None),
+            ReturnType::Result { ok, .. } => (
+                Some(named_root(ok).ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "Method `{}`: response is not a versioned wrapper",
+                        method.name
+                    )
+                })?),
+                None,
+            ),
+            ReturnType::Subscription(item) => (
+                None,
+                Some(named_root(item).ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "Method `{}`: subscription item is not a versioned wrapper",
+                        method.name
+                    )
+                })?),
+            ),
+            ReturnType::ResultSubscription { item, .. } => (
+                None,
+                Some(named_root(item).ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "Method `{}`: subscription item is not a versioned wrapper",
+                        method.name
+                    )
+                })?),
+            ),
+        };
+
+        Ok(MethodEmission {
+            name: method.name.clone(),
+            wire_name: wire_method.to_string(),
+            module: module.to_string(),
+            kind: method.kind,
+            request_wrapper,
+            response_wrapper,
+            item_wrapper,
+        })
+    }
+
+    fn write(&self, out: &mut String, host_expr: &str) {
+        match self.kind {
+            MethodKind::Request => self.write_request(out, host_expr),
+            MethodKind::Subscription | MethodKind::ResultSubscription => {
+                self.write_subscription(out, host_expr)
+            }
+        }
+    }
+
+    fn write_request(&self, out: &mut String, host_expr: &str) {
+        let module = &self.module;
+        let method = &self.name;
+        let ids = const_name(&self.wire_name);
+
+        write_indented(
+            out,
+            4,
+            &formatdoc! {
+                r#"
+                {{
+                    let host = {host_expr};
+                    dispatcher.on_request(wire_table::{ids}, move |request_id: String, bytes: Vec<u8>| {{
+                        let host = host.clone();
+                        Box::pin(async move {{
+                "#
+            },
+        );
+        let call_args = if let Some(request) = &self.request_wrapper {
+            write_indented(
+                out,
+                16,
+                &formatdoc! {
+                    r#"
+                    let request: versioned::{module}::{request} =
+                        Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                    "#
+                },
+            );
+            "&cx, request"
+        } else {
+            writeln!(out, "                let _ = bytes;").unwrap();
+            "&cx"
+        };
+        writeln!(
+            out,
+            "                let cx = CallContext::with_request_id(request_id.clone());"
+        )
+        .unwrap();
+        match &self.response_wrapper {
+            Some(response) => write_indented(
+                out,
+                16,
+                &formatdoc! {
+                    r#"
+                    let response: versioned::{module}::{response} = match host.{method}({call_args}).await {{
+                        Ok(value) => value,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    }};
+                    Ok(encode_ok_payload(response))
+                    "#
+                },
+            ),
+            None => write_indented(
+                out,
+                16,
+                &formatdoc! {
+                    r#"
+                    match host.{method}({call_args}).await {{
+                        Ok(()) => Ok(encode_ok_payload(())),
+                        Err(err) => Err(encode_call_error_payload(err)),
+                    }}
+                    "#
+                },
+            ),
+        }
+        write_indented(
+            out,
+            4,
+            indoc! {
+                r#"
+                        })
+                    });
+                }
+                "#
+            },
+        );
+    }
+
+    fn write_subscription(&self, out: &mut String, host_expr: &str) {
+        let module = &self.module;
+        let method = &self.name;
+        let ids = const_name(&self.wire_name);
+        let item = self
+            .item_wrapper
+            .as_deref()
+            .expect("subscription methods must have an item wrapper");
+
+        let is_result_sub = matches!(self.kind, MethodKind::ResultSubscription);
+
+        write_indented(
+            out,
+            4,
+            &formatdoc! {
+                r#"
+                {{
+                    let host = {host_expr};
+                    dispatcher.on_subscription(wire_table::{ids}, move |request_id: String, bytes: Vec<u8>| {{
+                        let host = host.clone();
+                        Box::pin(async move {{
+                "#
+            },
+        );
+        let call_args = if let Some(request) = &self.request_wrapper {
+            write_indented(
+                out,
+                16,
+                &formatdoc! {
+                    r#"
+                    let request: versioned::{module}::{request} =
+                        Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                    "#
+                },
+            );
+            "&cx, request"
+        } else {
+            writeln!(out, "                let _ = bytes;").unwrap();
+            "&cx"
+        };
+        writeln!(
+            out,
+            "                let cx = CallContext::with_request_id(request_id.clone());"
+        )
+        .unwrap();
+        if is_result_sub {
+            write_indented(
+                out,
+                16,
+                &formatdoc! {
+                    r#"
+                    let stream = match host.{method}({call_args}).await {{
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    }};
+                    "#
+                },
+            );
+        } else {
+            writeln!(
+                out,
+                "                let stream = host.{method}({call_args}).await;"
+            )
+            .unwrap();
+        }
+        writeln!(
+            out,
+            "                Ok(subscription_stream::<versioned::{module}::{item}, _>(stream))"
+        )
+        .unwrap();
+        write_indented(
+            out,
+            4,
+            indoc! {
+                r#"
+                        })
+                    });
+                }
+                "#
+            },
+        );
+    }
+}
+
+fn named_root(ty: &TypeRef) -> Option<String> {
+    if let TypeRef::Named { name, args } = ty
+        && args.is_empty()
+    {
+        return Some(name.clone());
+    }
+    None
+}
+
+/// Append `block` to `out`, prefixing every non-empty line with `indent` spaces.
+fn write_indented(out: &mut String, indent: usize, block: &str) {
+    let pad = " ".repeat(indent);
+    for line in block.lines() {
+        if line.is_empty() {
+            out.push('\n');
+        } else {
+            writeln!(out, "{pad}{line}").unwrap();
+        }
+    }
+}
+
+fn write_header(out: &mut String) {
+    writedoc!(
+        out,
+        r#"
+        //! Wire dispatcher for the unified `TrUApi` trait.
+        //!
+        //! Auto-generated by truapi-codegen. Do not edit.
+
+        "#
+    )
+    .unwrap();
+}
+
+fn write_imports(out: &mut String, traits: &[&TraitDef]) {
+    writedoc!(
+        out,
+        r#"
+        use std::sync::Arc;
+
+        use parity_scale_codec::Decode;
+
+        use truapi::CallContext;
+        use truapi::api::{{
+        "#
+    )
+    .unwrap();
+    for trait_def in traits {
+        writeln!(out, "    {},", trait_def.name).unwrap();
+    }
+    writedoc!(
+        out,
+        r#"
+        }};
+        use truapi::versioned;
+
+        use crate::dispatcher::Dispatcher;
+        use crate::frame::{{encode_call_error_payload, encode_decode_error, encode_ok_payload}};
+        use crate::generated::wire_table;
+        use crate::subscription::subscription_stream;
+        "#
+    )
+    .unwrap();
+}
+
+fn write_top_register(out: &mut String, traits: &[&TraitDef]) {
+    let trait_names: Vec<&str> = traits.iter().map(|t| t.name.as_str()).collect();
+    let bounds = trait_names.join(" + ");
+    writedoc!(
+        out,
+        r#"
+        /// Register every TrUAPI method with the dispatcher.
+        pub fn register<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+        where
+            P: {bounds} + Send + Sync + 'static,
+        {{
+        "#
+    )
+    .unwrap();
+    let last = traits.len().saturating_sub(1);
+    for (idx, trait_def) in traits.iter().enumerate() {
+        let host_expr = if idx == last { "host" } else { "host.clone()" };
+        let module = module_for_trait(&trait_def.name);
+        writeln!(out, "    register_{module}(dispatcher, {host_expr});").unwrap();
+    }
+    writeln!(out, "}}").unwrap();
+}
diff --git a/rust/crates/truapi-codegen/src/rust/wire_table.rs b/rust/crates/truapi-codegen/src/rust/wire_table.rs
new file mode 100644
index 00000000..8696b575
--- /dev/null
+++ b/rust/crates/truapi-codegen/src/rust/wire_table.rs
@@ -0,0 +1,296 @@
+//! Emits `wire_table.rs`: the (id, tag) lookup table the server uses to
+//! pair incoming wire frames with their request, response, or
+//! subscription role.
+//!
+//! Per-method `#[wire(...)]` annotations decide id assignment:
+//! - request methods reserve `(request_id, response_id)`.
+//! - subscription methods reserve `(start_id, stop_id, interrupt_id, receive_id)`.
+//!
+//! Missing annotations and collisions both hard-fail codegen.
+
+use std::collections::BTreeMap;
+use std::fmt::Write;
+
+use anyhow::{Result, bail};
+use indoc::{formatdoc, writedoc};
+
+use crate::rustdoc::*;
+
+use super::{const_name, wire_method_name};
+
+#[derive(Debug, Clone, Copy)]
+struct WireEntry {
+    request_id: u8,
+    response_id: u8,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct SubEntry {
+    start_id: u8,
+    stop_id: u8,
+    interrupt_id: u8,
+    receive_id: u8,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum MethodEntry {
+    Request(WireEntry),
+    Subscription(SubEntry),
+}
+
+/// Emit the contents of `wire_table.rs`.
+pub fn generate_wire_table(api: &ApiDefinition) -> Result<String> {
+    let mut method_entries: Vec<(String, MethodEntry)> = Vec::new();
+    let mut seen: BTreeMap<u8, String> = BTreeMap::new();
+    let mut seen_methods: BTreeMap<String, String> = BTreeMap::new();
+
+    for trait_def in &api.traits {
+        for method in &trait_def.methods {
+            let entry = method_entry(trait_def, method)?;
+            let wire_method = wire_method_name(&trait_def.name, &method.name);
+            if let Some(existing) = seen_methods.insert(
+                wire_method.clone(),
+                format!("{}::{}", trait_def.name, method.name),
+            ) {
+                bail!(
+                    "wire method name `{wire_method}` reused: `{existing}` and `{}::{}` collide",
+                    trait_def.name,
+                    method.name
+                );
+            }
+            insert_entry(&mut seen, &wire_method, entry)?;
+            method_entries.push((wire_method, entry));
+        }
+    }
+
+    method_entries.sort_by_key(|(_, entry)| match entry {
+        MethodEntry::Request(WireEntry { request_id, .. }) => *request_id,
+        MethodEntry::Subscription(SubEntry { start_id, .. }) => *start_id,
+    });
+
+    render(&method_entries)
+}
+
+fn method_entry(trait_def: &TraitDef, method: &MethodDef) -> Result<MethodEntry> {
+    let wire = &method.wire;
+    match method.kind {
+        MethodKind::Request => {
+            if wire.start_id.is_some()
+                || wire.stop_id.is_some()
+                || wire.interrupt_id.is_some()
+                || wire.receive_id.is_some()
+            {
+                bail!(
+                    "method `{}::{}` is a request and must not use subscription wire ids",
+                    trait_def.name,
+                    method.name
+                );
+            }
+            let request_id = wire.request_id.ok_or_else(|| {
+                anyhow::anyhow!(
+                    "method `{}::{}` is missing #[wire(request_id = N)] annotation",
+                    trait_def.name,
+                    method.name
+                )
+            })?;
+            let response_id = infer_id(wire.response_id, request_id, 1, &method.name)?;
+            Ok(MethodEntry::Request(WireEntry {
+                request_id,
+                response_id,
+            }))
+        }
+        MethodKind::Subscription | MethodKind::ResultSubscription => {
+            if wire.request_id.is_some() || wire.response_id.is_some() {
+                bail!(
+                    "method `{}::{}` is a subscription and must not use request wire ids",
+                    trait_def.name,
+                    method.name
+                );
+            }
+            let start_id = wire.start_id.ok_or_else(|| {
+                anyhow::anyhow!(
+                    "method `{}::{}` is missing #[wire(start_id = N)] annotation",
+                    trait_def.name,
+                    method.name
+                )
+            })?;
+            let stop_id = infer_id(wire.stop_id, start_id, 1, &method.name)?;
+            let interrupt_id = infer_id(wire.interrupt_id, start_id, 2, &method.name)?;
+            let receive_id = infer_id(wire.receive_id, start_id, 3, &method.name)?;
+            Ok(MethodEntry::Subscription(SubEntry {
+                start_id,
+                stop_id,
+                interrupt_id,
+                receive_id,
+            }))
+        }
+    }
+}
+
+fn infer_id(explicit: Option<u8>, anchor: u8, offset: u8, method_name: &str) -> Result<u8> {
+    if let Some(id) = explicit {
+        return Ok(id);
+    }
+    anchor
+        .checked_add(offset)
+        .ok_or_else(|| anyhow::anyhow!("wire id overflow on `{method_name}` (base {anchor})"))
+}
+
+fn insert_entry(
+    seen: &mut BTreeMap<u8, String>,
+    method_name: &str,
+    entry: MethodEntry,
+) -> Result<()> {
+    let pairs: Vec<(u8, String)> = match entry {
+        MethodEntry::Request(WireEntry {
+            request_id,
+            response_id,
+        }) => vec![
+            (request_id, format!("{method_name}_request")),
+            (response_id, format!("{method_name}_response")),
+        ],
+        MethodEntry::Subscription(SubEntry {
+            start_id,
+            stop_id,
+            interrupt_id,
+            receive_id,
+        }) => vec![
+            (start_id, format!("{method_name}_start")),
+            (stop_id, format!("{method_name}_stop")),
+            (interrupt_id, format!("{method_name}_interrupt")),
+            (receive_id, format!("{method_name}_receive")),
+        ],
+    };
+    for (id, tag) in pairs {
+        if let Some(existing) = seen.insert(id, tag.clone()) {
+            bail!("wire id {id} reused: `{existing}` and `{tag}` collide");
+        }
+    }
+    Ok(())
+}
+
+fn render(methods: &[(String, MethodEntry)]) -> Result<String> {
+    let mut out = String::new();
+    writedoc!(
+        out,
+        r#"
+        //! Wire-protocol discriminant table.
+        //!
+        //! Auto-generated by truapi-codegen. Do not edit.
+        //!
+        //! Each method reserves either two ids (request/response) or four
+        //! (start/stop/interrupt/receive). The ids for each method are exposed
+        //! as a named const (`PREIMAGE_SUBMIT`, ...); [`WIRE_TABLE`] and the
+        //! generated dispatcher both reference those consts so the numbers live
+        //! in exactly one place. The table is sorted by request/start id.
+
+        /// Request method wire discriminants.
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub struct RequestFrameIds {{
+            /// Discriminant for the request frame.
+            pub request_id: u8,
+            /// Discriminant for the response frame.
+            pub response_id: u8,
+        }}
+
+        /// Subscription method wire discriminants.
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub struct SubscriptionFrameIds {{
+            /// Discriminant for the start frame.
+            pub start_id: u8,
+            /// Discriminant for the stop frame.
+            pub stop_id: u8,
+            /// Discriminant for the interrupt frame (server-initiated termination).
+            pub interrupt_id: u8,
+            /// Discriminant for each receive frame (a streamed item).
+            pub receive_id: u8,
+        }}
+
+        /// A single wire-table row.
+        pub struct WireEntry {{
+            /// Method name from the Rust trait.
+            pub method: &'static str,
+            /// What kind of slot this entry describes.
+            pub kind: WireKind,
+        }}
+
+        /// Wire-slot shape: request/response pair or subscription quartet.
+        pub enum WireKind {{
+            /// Request/response method.
+            Request(RequestFrameIds),
+            /// Subscription method.
+            Subscription(SubscriptionFrameIds),
+        }}
+        "#
+    )
+    .unwrap();
+
+    // Per-method consts: the single source of truth for each method's ids.
+    for (name, entry) in methods {
+        let konst = const_name(name);
+        let block = match entry {
+            MethodEntry::Request(WireEntry {
+                request_id,
+                response_id,
+            }) => formatdoc! {
+                r#"
+                /// Wire discriminants for `{name}`.
+                pub const {konst}: RequestFrameIds = RequestFrameIds {{
+                    request_id: {request_id},
+                    response_id: {response_id},
+                }};
+                "#
+            },
+            MethodEntry::Subscription(SubEntry {
+                start_id,
+                stop_id,
+                interrupt_id,
+                receive_id,
+            }) => formatdoc! {
+                r#"
+                /// Wire discriminants for `{name}`.
+                pub const {konst}: SubscriptionFrameIds = SubscriptionFrameIds {{
+                    start_id: {start_id},
+                    stop_id: {stop_id},
+                    interrupt_id: {interrupt_id},
+                    receive_id: {receive_id},
+                }};
+                "#
+            },
+        };
+        out.push('\n');
+        out.push_str(&block);
+    }
+
+    out.push('\n');
+    writedoc!(
+        out,
+        r#"
+        /// The full wire table. Ordering is part of the wire protocol;
+        /// only ever append. Removed methods leave their slot empty.
+        pub const WIRE_TABLE: &[WireEntry] = &[
+        "#
+    )
+    .unwrap();
+    for (name, entry) in methods {
+        let konst = const_name(name);
+        let variant = match entry {
+            MethodEntry::Request(_) => "Request",
+            MethodEntry::Subscription(_) => "Subscription",
+        };
+        let block = formatdoc! {
+            r#"
+            WireEntry {{
+                method: "{name}",
+                kind: WireKind::{variant}({konst}),
+            }},
+            "#
+        };
+        for line in block.lines() {
+            writeln!(out, "    {line}").unwrap();
+        }
+    }
+    writeln!(out, "];").unwrap();
+
+    Ok(out)
+}
diff --git a/rust/crates/truapi-codegen/src/rustdoc.rs b/rust/crates/truapi-codegen/src/rustdoc.rs
index 2e8aa459..d15d3f50 100644
--- a/rust/crates/truapi-codegen/src/rustdoc.rs
+++ b/rust/crates/truapi-codegen/src/rustdoc.rs
@@ -6,9 +6,17 @@ use std::collections::{BTreeMap, HashMap};
 use anyhow::{Context, Result, bail};
 use serde::Deserialize;
 
+/// Minimum rustdoc JSON `format_version` the extractors are tested against.
+/// Emitted by nightly 2026-02-23 (rustc 1.95.0-nightly); older formats may
+/// encode item shapes differently and are rejected outright.
+const MIN_FORMAT_VERSION: u32 = 57;
+
 /// Parsed rustdoc crate. IDs are integers but serialized as string keys in JSON maps.
 #[derive(Debug, Deserialize)]
 pub struct Crate {
+    /// rustdoc JSON format version stamped into the document.
+    #[serde(default)]
+    pub format_version: Option<u32>,
     pub index: HashMap<String, Item>,
     #[serde(default)]
     pub paths: HashMap<String, ItemPath>,
@@ -220,7 +228,7 @@ struct ItemCandidate {
 }
 
 #[derive(Debug, Default)]
-struct NameContext {
+pub(crate) struct NameContext {
     by_item_id: HashMap<String, String>,
     by_path: HashMap<String, String>,
 }
@@ -242,9 +250,23 @@ impl NameContext {
 }
 
 /// Parses rustdoc JSON output into the minimal crate model used by the code
-/// generator.
+/// generator. Rejects documents older than [`MIN_FORMAT_VERSION`] because the
+/// untyped walkers in this crate assume the format of recent nightlies.
 pub fn parse(json: &str) -> Result<Crate> {
-    serde_json::from_str(json).context("Failed to parse rustdoc JSON")
+    let krate: Crate = serde_json::from_str(json).context("Failed to parse rustdoc JSON")?;
+    let Some(version) = krate.format_version else {
+        bail!(
+            "rustdoc JSON is missing `format_version`; regenerate it with \
+             `cargo +nightly rustdoc --output-format json` (nightly 2026-02-23 or later)"
+        );
+    };
+    if version < MIN_FORMAT_VERSION {
+        bail!(
+            "rustdoc JSON format_version {version} is older than the tested minimum \
+             {MIN_FORMAT_VERSION}; regenerate with nightly 2026-02-23 or later"
+        );
+    }
+    Ok(krate)
 }
 
 /// Extracts the public traits and types that make up the generated API surface
@@ -844,7 +866,7 @@ fn extract_generic_arg(
     resolve_type(&generic, names)
 }
 
-fn resolve_type(ty: &serde_json::Value, names: &NameContext) -> Result<TypeRef> {
+pub(crate) fn resolve_type(ty: &serde_json::Value, names: &NameContext) -> Result<TypeRef> {
     if let Some(name) = ty.get("generic").and_then(|value| value.as_str()) {
         return Ok(TypeRef::Generic(name.to_string()));
     }
@@ -985,7 +1007,7 @@ fn expect_single_arg(type_name: &str, mut args: Vec<TypeRef>) -> Result<TypeRef>
     Ok(args.remove(0))
 }
 
-fn extract_struct(
+pub(crate) fn extract_struct(
     item_id: &str,
     item: &Item,
     krate: &Crate,
@@ -1086,7 +1108,7 @@ fn extract_struct(
     })
 }
 
-fn extract_enum(
+pub(crate) fn extract_enum(
     item_id: &str,
     item: &Item,
     krate: &Crate,
@@ -1288,7 +1310,7 @@ fn value_id(value: &serde_json::Value) -> Result<String> {
     bail!("Expected rustdoc item id, got {}", summarize_json(value))
 }
 
-fn summarize_json(value: &serde_json::Value) -> String {
+pub(crate) fn summarize_json(value: &serde_json::Value) -> String {
     const LIMIT: usize = 200;
 
     let mut text =
@@ -1310,4 +1332,35 @@ mod tests {
 
         assert_eq!(clean_docs(Some(docs)).as_deref(), Some("Trait summary."));
     }
+
+    #[test]
+    fn parse_accepts_tested_format_version() {
+        let json = format!(r#"{{ "format_version": {MIN_FORMAT_VERSION}, "index": {{}} }}"#);
+
+        assert!(parse(&json).is_ok());
+    }
+
+    #[test]
+    fn parse_rejects_missing_format_version() {
+        let err = parse(r#"{ "index": {} }"#).expect_err("missing format_version must error");
+
+        assert!(
+            format!("{err}").contains("missing `format_version`"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn parse_rejects_old_format_version() {
+        let json = format!(
+            r#"{{ "format_version": {}, "index": {{}} }}"#,
+            MIN_FORMAT_VERSION - 1
+        );
+        let err = parse(&json).expect_err("old format_version must error");
+
+        assert!(
+            format!("{err}").contains("older than the tested minimum"),
+            "unexpected error: {err}"
+        );
+    }
 }
diff --git a/rust/crates/truapi-codegen/src/ts.rs b/rust/crates/truapi-codegen/src/ts.rs
index 2b56d31e..cc131c17 100644
--- a/rust/crates/truapi-codegen/src/ts.rs
+++ b/rust/crates/truapi-codegen/src/ts.rs
@@ -9,14 +9,17 @@ use anyhow::{Result, bail};
 use convert_case::{Case, Casing};
 use indoc::{formatdoc, writedoc};
 
+use crate::rust::wire_const_name;
 use crate::rustdoc::*;
 
 mod examples;
 mod explorer;
+mod host_callbacks;
 mod playground;
 
 pub use examples::generate_client_examples;
 pub use explorer::generate_explorer;
+pub use host_callbacks::generate as generate_host_callbacks;
 pub use playground::generate_playground_services;
 
 #[derive(Default)]
@@ -458,10 +461,6 @@ fn ts_string_literal(value: &str) -> String {
     serde_json::to_string(value).expect("string serialization is infallible")
 }
 
-fn wire_const_name(trait_name: &str, method_name: &str) -> String {
-    format!("{trait_name}_{method_name}").to_case(Case::UpperSnake)
-}
-
 /// Sort key for stable, wire-id-ordered method emission shared by the
 /// playground and examples submodules.
 fn method_wire_sort_id(method: &MethodDef) -> u8 {
@@ -1144,14 +1143,15 @@ fn emit_payload(
 }
 
 /// Response shape after the versioned wrapper is stripped. TS callers see the
-/// inner type; request responses decode `Versioned<Result<Ok, Err>>`, while
-/// subscription items still decode the full versioned item wrapper.
+/// inner type; request responses decode `Result<VersionedOk,
+/// CallError<VersionedErr>>`, while subscription items still decode the full
+/// versioned item wrapper.
 #[derive(Clone)]
 struct ResponseEmission {
     inner_type_ts: String,
     wire_type_ts: String,
     wire_codec_expr: String,
-    inner_codec_expr: String,
+    unwrap_wire_value: bool,
 }
 
 fn versioned_value_cast(wire_type: &str, inner_type: &str, version: u32) -> String {
@@ -1189,13 +1189,13 @@ fn emit_response(
                 inner_type_ts: "undefined".to_string(),
                 wire_type_ts: format!("T.{}", versioned_wrapper_ts_name(wrapper_name)),
                 wire_codec_expr: format!("T.{}", versioned_wrapper_ts_name(wrapper_name)),
-                inner_codec_expr: "S._void".to_string(),
+                unwrap_wire_value: true,
             }),
             VersionedKind::Tuple(inner) => Ok(ResponseEmission {
                 inner_type_ts: ts_type_qualified(inner)?,
                 wire_type_ts: format!("T.{}", versioned_wrapper_ts_name(wrapper_name)),
                 wire_codec_expr: format!("T.{}", versioned_wrapper_ts_name(wrapper_name)),
-                inner_codec_expr: codec_expr(inner, true, ctx)?,
+                unwrap_wire_value: true,
             }),
         };
     }
@@ -1204,7 +1204,7 @@ fn emit_response(
         inner_type_ts: ts_type_qualified(ty)?,
         wire_type_ts: ts_type_qualified(ty)?,
         wire_codec_expr: codec_expr(ty, true, ctx)?,
-        inner_codec_expr: codec_expr(ty, true, ctx)?,
+        unwrap_wire_value: false,
     })
 }
 
@@ -1261,8 +1261,45 @@ fn indexed_versioned_codec_expr(
     ))
 }
 
-fn versioned_result_codec_expr(version: u32, ok_codec: &str, err_codec: &str) -> Result<String> {
-    indexed_versioned_codec_expr([(version, format!("S.Result({ok_codec}, {err_codec})"))])
+fn call_error_codec_expr(err: &TypeRef, err_codec: String) -> String {
+    if call_error_inner(err).is_some() {
+        format!("S.CallError({err_codec})")
+    } else {
+        err_codec
+    }
+}
+
+fn request_response_codec_expr(ok_codec: String, err: &TypeRef, err_codec: String) -> String {
+    let err_codec = call_error_codec_expr(err, err_codec);
+    format!("S.Result({ok_codec}, {err_codec})")
+}
+
+fn client_decode_response_expr(
+    response_codec: &str,
+    unwrap_ok_value: bool,
+    unwrap_err_value: bool,
+) -> String {
+    if !unwrap_ok_value && !unwrap_err_value {
+        return format!("(payload) => {response_codec}.dec(payload)");
+    }
+    let ok_value = if unwrap_ok_value {
+        "result.value.value"
+    } else {
+        "result.value"
+    };
+    let err_value = if unwrap_err_value {
+        "result.value.value"
+    } else {
+        "result.value"
+    };
+    format!(
+        r#"(payload) => {{
+        const result = {response_codec}.dec(payload);
+        return result.success
+          ? {{ success: true as const, value: {ok_value} }}
+          : {{ success: false as const, value: {err_value} }};
+      }}"#
+    )
 }
 
 fn emit_method(
@@ -1284,17 +1321,11 @@ fn emit_method(
             let is_handshake = trait_def.name == "System" && method.name == "handshake";
             let response = emit_response(ok, wrappers, ctx, wire_version)?;
             let error = emit_error_response(err, wrappers, ctx, wire_version)?;
-            let response_codec = match wire_version {
-                Some(version) => versioned_result_codec_expr(
-                    version,
-                    &response.inner_codec_expr,
-                    &error.inner_codec_expr,
-                )?,
-                None => format!(
-                    "S.Result({}, {})",
-                    response.wire_codec_expr, error.wire_codec_expr
-                ),
-            };
+            let response_codec = request_response_codec_expr(
+                response.wire_codec_expr.clone(),
+                err,
+                error.wire_codec_expr.clone(),
+            );
 
             let arg_decl = if is_handshake || payload.param_list.is_empty() {
                 String::new()
@@ -1325,12 +1356,12 @@ fn emit_method(
                 payload.wire_version,
                 request_expr,
             );
-            let value_suffix = if wire_version.is_some() { ".value" } else { "" };
-            writeln!(
-                out,
-                "      decodeResponse: (payload) => {response_codec}.dec(payload){value_suffix},"
-            )
-            .unwrap();
+            let decode_response = client_decode_response_expr(
+                &response_codec,
+                response.unwrap_wire_value,
+                error.unwrap_wire_value,
+            );
+            writeln!(out, "      decodeResponse: {decode_response},").unwrap();
             writedoc!(
                 out,
                 "
@@ -2522,28 +2553,22 @@ fn generate_host_server(api: &ApiDefinition) -> Result<String> {
         services_with_methods.push((trait_def, methods));
     }
 
-    // Only import the response-payload helpers actually referenced by this
-    // generation. `MethodKind::Request` methods need `toResponsePayload`
-    // (versioned) or `toFlatResponsePayload` (unversioned).
-    let mut needs_versioned_helper = false;
+    // Only import the response-payload helper when request handlers exist.
+    // All request responses use the flat wire shape
+    // `Result<Ok, CallError<Err>>`; versioned methods carry their version tag
+    // inside the Ok/Err value rather than around the Result.
     let mut needs_flat_helper = false;
     for (_, methods) in &services_with_methods {
         for method in methods {
             if !matches!(method.kind, MethodKind::Request) {
                 continue;
             }
-            if method_wire_versions(method, &wrappers)?.is_empty() {
-                needs_flat_helper = true;
-            } else {
-                needs_versioned_helper = true;
-            }
+            needs_flat_helper = true;
         }
     }
-    let helper_imports = match (needs_versioned_helper, needs_flat_helper) {
-        (true, true) => "  toFlatResponsePayload,\n  toResponsePayload,\n",
-        (true, false) => "  toResponsePayload,\n",
-        (false, true) => "  toFlatResponsePayload,\n",
-        (false, false) => "",
+    let helper_imports = match needs_flat_helper {
+        true => "  toFlatResponsePayload,\n",
+        false => "",
     };
 
     let mut out = String::new();
@@ -2745,10 +2770,9 @@ fn host_request_codec(
     }
 }
 
-/// Codec for encoding the response of a request method. Per-position: if
-/// both Ok and Err are versioned, build `indexedTaggedUnion({V<n>: [n-1,
-/// S.Result(ok_n, err_n)], ...})`. If neither is versioned, fall back to
-/// `S.Result(ok, err)`.
+/// Codec for encoding the response of a request method. Versioned positions
+/// encode the selected version inside the Ok/Err arm:
+/// `Result<VersionedOk, CallError<VersionedErr>>`.
 fn host_response_codec(
     ok: &TypeRef,
     err: &TypeRef,
@@ -2757,28 +2781,9 @@ fn host_response_codec(
     versions: &BTreeSet<u32>,
 ) -> Result<String> {
     let err_inner = call_error_inner(err).unwrap_or(err);
-    let ok_shapes = host_response_shapes_for_versions(ok, wrappers, ctx, versions)?;
-    let err_shapes = host_response_shapes_for_versions(err_inner, wrappers, ctx, versions)?;
-    match (ok_shapes, err_shapes) {
-        (None, None) => {
-            let ok_codec = codec_expr_raw(ok, true, ctx)?;
-            let err_codec = codec_expr_raw(err_inner, true, ctx)?;
-            Ok(format!("S.Result({ok_codec}, {err_codec})"))
-        }
-        (Some(o), Some(e)) => {
-            indexed_versioned_codec_expr(o.iter().zip(e.iter()).map(|(oo, ee)| {
-                (
-                    oo.version,
-                    format!(
-                        "S.Result({ok}, {err})",
-                        ok = oo.inner_codec_expr,
-                        err = ee.inner_codec_expr,
-                    ),
-                )
-            }))
-        }
-        _ => bail!("internal: mismatched per-version shapes for `{ok:?}` and `{err_inner:?}`"),
-    }
+    let ok_codec = host_value_codec(ok, wrappers, ctx, versions)?;
+    let err_codec = host_value_codec(err_inner, wrappers, ctx, versions)?;
+    Ok(request_response_codec_expr(ok_codec, err, err_codec))
 }
 
 /// Codec for encoding a subscription item or interrupt reason. Versioned
@@ -3141,7 +3146,7 @@ fn emit_host_entry(
                       ids: W.{wire_const},
                       async handle(ctx, bytes) {{
                         const request = {request_codec}.dec(bytes);
-                        const response = toResponsePayload(
+                        const response = toFlatResponsePayload(
                           await handlers.{ts_method_name}(ctx, request),
                         );
                         return {response_codec}.enc(response);
diff --git a/rust/crates/truapi-codegen/src/ts/host_callbacks.rs b/rust/crates/truapi-codegen/src/ts/host_callbacks.rs
new file mode 100644
index 00000000..af457ab8
--- /dev/null
+++ b/rust/crates/truapi-codegen/src/ts/host_callbacks.rs
@@ -0,0 +1,435 @@
+//! Emit the typed `HostCallbacks` TypeScript surface from a parsed
+//! `truapi-platform` rustdoc tree.
+//!
+//! One TS interface per Rust capability trait, plus a composite
+//! `HostCallbacks` super-interface that mirrors the `Platform: A + B + ...`
+//! super-trait so consumers can implement capabilities piecemeal. Named
+//! types in trait signatures (e.g. `HostDevicePermissionRequest`) resolve
+//! against `@parity/truapi`, the canonical typed client surface.
+
+use std::collections::BTreeSet;
+use std::fmt::Write;
+use std::fs;
+use std::path::Path;
+
+use anyhow::{Result, bail};
+use indoc::{formatdoc, writedoc};
+
+use crate::platform::{
+    PlatformDefinition, PlatformInner, PlatformMethod, PlatformReturn, PlatformTrait,
+};
+use crate::rustdoc::{FieldDef, TypeDef, TypeDefKind, TypeRef, VariantDef, VariantFields};
+
+/// Write the typed host-callbacks TS file into `output_dir`.
+pub fn generate(definition: &PlatformDefinition, output_dir: &str) -> Result<()> {
+    fs::create_dir_all(output_dir)?;
+    let body = emit_host_callbacks(definition)?;
+    fs::write(Path::new(output_dir).join("host-callbacks.ts"), body)?;
+    Ok(())
+}
+
+fn emit_host_callbacks(definition: &PlatformDefinition) -> Result<String> {
+    let mut out = String::new();
+    writedoc!(
+        out,
+        r#"
+        // Auto-generated by truapi-codegen. Do not edit.
+        //
+        // Typed host-callbacks surface derived from the `truapi-platform`
+        // capability traits. One interface per Rust trait + a composite
+        // `HostCallbacks` interface that mirrors the `Platform` super-trait.
+
+        "#,
+    )
+    .unwrap();
+
+    let imports = collect_named_types(definition);
+    if !imports.is_empty() {
+        let entries = imports
+            .iter()
+            .map(|name| format!("  {name},"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        writedoc!(
+            out,
+            r#"
+            import type {{
+            {entries}
+            }} from "@parity/truapi";
+
+            "#,
+        )
+        .unwrap();
+    }
+
+    for type_def in &definition.types {
+        let rendered = match &type_def.kind {
+            TypeDefKind::Enum(_) => emit_enum_type(type_def)?,
+            _ => emit_struct_interface(type_def)?,
+        };
+        out.push_str(&rendered);
+        out.push('\n');
+    }
+
+    for trait_def in &definition.traits {
+        out.push_str(&emit_trait_interface(trait_def)?);
+        out.push('\n');
+    }
+
+    // The Rust super-trait `Platform` becomes `HostCallbacks` on the TS
+    // surface: that is the name every host implementer reaches for, and
+    // it stays stable even if the Rust trait is renamed.
+    let (composes, docs): (Vec<String>, Option<&str>) = match &definition.super_trait {
+        Some(s) => (s.composes.clone(), s.docs.as_deref()),
+        None => (
+            definition.traits.iter().map(|t| t.name.clone()).collect(),
+            None,
+        ),
+    };
+    out.push_str(&emit_super_interface("HostCallbacks", &composes, docs));
+
+    Ok(out)
+}
+
+fn emit_trait_interface(trait_def: &PlatformTrait) -> Result<String> {
+    let jsdoc = render_jsdoc("", trait_def.docs.as_deref());
+    let body = trait_def
+        .methods
+        .iter()
+        .map(emit_method)
+        .collect::<Result<Vec<_>>>()?
+        .join("\n\n");
+    Ok(formatdoc! {
+        r#"
+        {jsdoc}export interface {name} {{
+        {body}
+        }}
+        "#,
+        name = ts_local_name(&trait_def.name),
+    })
+}
+
+fn emit_method(method: &PlatformMethod) -> Result<String> {
+    let jsdoc = render_jsdoc("  ", method.docs.as_deref());
+    let params = method
+        .params
+        .iter()
+        .map(|p| {
+            let ts = ts_type(&p.type_ref)?;
+            Ok(format!("{}: {ts}", to_camel_case(&p.name)))
+        })
+        .collect::<Result<Vec<_>>>()?
+        .join(", ");
+    let ret = format_return(&method.return_shape)?;
+    let name = to_camel_case(&method.name);
+    // A Rust default body makes the method optional for host implementations.
+    let optional = if method.has_default { "?" } else { "" };
+    Ok(format!("{jsdoc}  {name}{optional}({params}): {ret};"))
+}
+
+/// Emit a TS interface for a local platform struct. `Option<T>` fields become
+/// optional members so hosts receive plain objects with absent-when-`None`
+/// properties.
+fn emit_struct_interface(struct_def: &TypeDef) -> Result<String> {
+    let TypeDefKind::Struct(fields) = &struct_def.kind else {
+        bail!(
+            "Platform struct `{}` must have named fields",
+            struct_def.name
+        );
+    };
+    if !struct_def.generic_params.is_empty() {
+        bail!("Platform struct `{}` must not be generic", struct_def.name);
+    }
+    let jsdoc = render_jsdoc("", struct_def.docs.as_deref());
+    let body = fields
+        .iter()
+        .map(|field| {
+            let jsdoc = render_jsdoc("  ", field.docs.as_deref());
+            let name = to_camel_case(&field.name);
+            match &field.type_ref {
+                TypeRef::Option(inner) => Ok(format!("{jsdoc}  {name}?: {};", ts_type(inner)?)),
+                other => Ok(format!("{jsdoc}  {name}: {};", ts_type(other)?)),
+            }
+        })
+        .collect::<Result<Vec<_>>>()?
+        .join("\n\n");
+    Ok(formatdoc! {
+        r#"
+        {jsdoc}export interface {name} {{
+        {body}
+        }}
+        "#,
+        name = struct_def.name,
+    })
+}
+
+/// Emit a TS type for a local platform enum. Unit-only enums become string
+/// literal unions; payload enums become `{ tag, value }` tagged unions
+/// matching the `@parity/truapi` client convention.
+fn emit_enum_type(enum_def: &TypeDef) -> Result<String> {
+    let TypeDefKind::Enum(variants) = &enum_def.kind else {
+        bail!("Platform enum `{}` must have variants", enum_def.name);
+    };
+    if !enum_def.generic_params.is_empty() {
+        bail!("Platform enum `{}` must not be generic", enum_def.name);
+    }
+    let jsdoc = render_jsdoc("", enum_def.docs.as_deref());
+    if variants
+        .iter()
+        .all(|variant| matches!(variant.fields, VariantFields::Unit))
+    {
+        let union = variants
+            .iter()
+            .map(|variant| format!("\"{}\"", variant.name))
+            .collect::<Vec<_>>()
+            .join(" | ");
+        return Ok(format!(
+            "{jsdoc}export type {name} = {union};\n",
+            name = enum_def.name,
+        ));
+    }
+    let mut body = String::new();
+    for variant in variants {
+        body.push_str(&render_jsdoc("  ", variant.docs.as_deref()));
+        writeln!(body, "  | {}", enum_variant_type(variant)?).unwrap();
+    }
+    Ok(formatdoc! {
+        r#"
+        {jsdoc}export type {name} =
+        {body};
+        "#,
+        name = enum_def.name,
+        body = body.trim_end(),
+    })
+}
+
+/// Render one enum variant as a `{ tag, value }` member. Unit variants mark
+/// `value` optional so consumers can write `{ tag: "X" }`.
+fn enum_variant_type(variant: &VariantDef) -> Result<String> {
+    Ok(match &variant.fields {
+        VariantFields::Unit => format!("{{ tag: \"{}\"; value?: undefined }}", variant.name),
+        VariantFields::Unnamed(types) => format!(
+            "{{ tag: \"{}\"; value: {} }}",
+            variant.name,
+            unnamed_variant_value_type(types)?
+        ),
+        VariantFields::Named(fields) => format!(
+            "{{ tag: \"{}\"; value: {} }}",
+            variant.name,
+            inline_object_type(fields)?
+        ),
+    })
+}
+
+fn unnamed_variant_value_type(types: &[TypeRef]) -> Result<String> {
+    match types {
+        [single] => ts_type(single),
+        many => {
+            let rendered = many
+                .iter()
+                .map(ts_type)
+                .collect::<Result<Vec<_>>>()?
+                .join(", ");
+            Ok(format!("[{rendered}]"))
+        }
+    }
+}
+
+fn inline_object_type(fields: &[FieldDef]) -> Result<String> {
+    let body = fields
+        .iter()
+        .map(|field| {
+            let name = to_camel_case(&field.name);
+            match &field.type_ref {
+                TypeRef::Option(inner) => Ok(format!("{name}?: {}", ts_type(inner)?)),
+                other => Ok(format!("{name}: {}", ts_type(other)?)),
+            }
+        })
+        .collect::<Result<Vec<_>>>()?
+        .join("; ");
+    Ok(format!("{{ {body} }}"))
+}
+
+fn emit_super_interface(name: &str, composes: &[String], docs: Option<&str>) -> String {
+    let jsdoc = render_jsdoc("", docs);
+    if composes.is_empty() {
+        return format!("{jsdoc}export interface {name} {{}}\n");
+    }
+    let extends = composes
+        .iter()
+        .map(|name| ts_local_name(name))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("{jsdoc}export interface {name} extends {extends} {{}}\n")
+}
+
+fn collect_named_types(definition: &PlatformDefinition) -> BTreeSet<String> {
+    let mut out: BTreeSet<String> = BTreeSet::new();
+    for trait_def in &definition.traits {
+        for method in &trait_def.methods {
+            for param in &method.params {
+                collect_from_type(&param.type_ref, &mut out);
+            }
+            match &method.return_shape.inner {
+                // Err type is not part of the TS signature (errors throw),
+                // so don't import its name.
+                PlatformInner::Result { ok, .. } => collect_from_type(ok, &mut out),
+                PlatformInner::Stream(inner) => collect_from_type(inner, &mut out),
+                PlatformInner::Plain(inner) => collect_from_type(inner, &mut out),
+                // A trait object returns its bare trait name in the TS
+                // signature; collect it so a non-local trait gets imported
+                // rather than emitted as an undeclared name. Local traits are
+                // filtered out below since their interfaces live in this file.
+                PlatformInner::TraitObject(name) => {
+                    out.insert(name.clone());
+                }
+                PlatformInner::Unit => {}
+            }
+        }
+    }
+    // Filter out names defined locally (the capability trait interfaces and
+    // the platform struct/enum types emitted into this file).
+    let local: BTreeSet<String> = definition
+        .traits
+        .iter()
+        .map(|t| t.name.clone())
+        .chain(definition.types.iter().map(|s| s.name.clone()))
+        .collect();
+    out.into_iter().filter(|n| !local.contains(n)).collect()
+}
+
+fn collect_from_type(ty: &TypeRef, out: &mut BTreeSet<String>) {
+    match ty {
+        TypeRef::Named { name, args } => {
+            out.insert(name.clone());
+            for arg in args {
+                collect_from_type(arg, out);
+            }
+        }
+        TypeRef::Vec(inner) | TypeRef::Option(inner) | TypeRef::Array(inner, _) => {
+            collect_from_type(inner, out)
+        }
+        TypeRef::Tuple(items) => {
+            for item in items {
+                collect_from_type(item, out);
+            }
+        }
+        TypeRef::Primitive(_) | TypeRef::Generic(_) | TypeRef::Unit => {}
+    }
+}
+
+fn format_return(ret: &PlatformReturn) -> Result<String> {
+    let inner = match &ret.inner {
+        PlatformInner::Unit => "void".to_string(),
+        PlatformInner::Result { ok, .. } => ts_type(ok)?,
+        PlatformInner::Stream(item) => format!("AsyncIterable<{}>", ts_type(item)?),
+        PlatformInner::TraitObject(name) => name.clone(),
+        PlatformInner::Plain(ty) => ts_type(ty)?,
+    };
+    if ret.is_async {
+        Ok(format!("Promise<{inner}>"))
+    } else {
+        Ok(inner)
+    }
+}
+
+fn ts_type(ty: &TypeRef) -> Result<String> {
+    match ty {
+        TypeRef::Primitive(name) => match name.as_str() {
+            "bool" => Ok("boolean".to_string()),
+            "u8" | "u16" | "u32" | "i8" | "i16" | "i32" | "f32" | "f64" => Ok("number".to_string()),
+            "u64" | "u128" | "i64" | "i128" => Ok("bigint".to_string()),
+            "str" => Ok("string".to_string()),
+            _ => bail!("Unsupported primitive type `{name}` in host callbacks generation"),
+        },
+        TypeRef::Named { name, args } => {
+            if args.is_empty() {
+                Ok(name.clone())
+            } else {
+                let rendered = args
+                    .iter()
+                    .map(ts_type)
+                    .collect::<Result<Vec<_>>>()?
+                    .join(", ");
+                Ok(format!("{name}<{rendered}>"))
+            }
+        }
+        TypeRef::Vec(inner) => match inner.as_ref() {
+            TypeRef::Primitive(name) if name == "u8" => Ok("Uint8Array".to_string()),
+            _ => Ok(format!("Array<{}>", ts_type(inner)?)),
+        },
+        TypeRef::Option(inner) => Ok(format!("{} | undefined", ts_type(inner)?)),
+        TypeRef::Tuple(items) => {
+            if items.is_empty() {
+                Ok("void".to_string())
+            } else {
+                let rendered = items
+                    .iter()
+                    .map(ts_type)
+                    .collect::<Result<Vec<_>>>()?
+                    .join(", ");
+                Ok(format!("[{rendered}]"))
+            }
+        }
+        TypeRef::Array(inner, _len) => match inner.as_ref() {
+            TypeRef::Primitive(name) if name == "u8" => Ok("Uint8Array".to_string()),
+            _ => Ok(format!("Array<{}>", ts_type(inner)?)),
+        },
+        TypeRef::Generic(name) => Ok(name.clone()),
+        TypeRef::Unit => Ok("void".to_string()),
+    }
+}
+
+fn ts_local_name(name: &str) -> String {
+    match name {
+        "Storage" => "HostStorage".to_string(),
+        _ => name.to_string(),
+    }
+}
+
+fn render_jsdoc(indent: &str, docs: Option<&str>) -> String {
+    let Some(docs) = docs else {
+        return String::new();
+    };
+    let docs = docs.trim();
+    if docs.is_empty() {
+        return String::new();
+    }
+    let body = docs
+        .lines()
+        .map(|line| {
+            if line.is_empty() {
+                format!("{indent} *")
+            } else {
+                format!("{indent} * {}", render_ts_doc_line(line))
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!("{indent}/**\n{body}\n{indent} */\n")
+}
+
+fn render_ts_doc_line(line: &str) -> String {
+    line.replace("[`", "`")
+        .replace("`]", "`")
+        .replace("Ok(())", "success")
+        .replace("None", "`undefined`")
+}
+
+fn to_camel_case(name: &str) -> String {
+    let mut out = String::with_capacity(name.len());
+    let mut upper_next = false;
+    for (idx, ch) in name.chars().enumerate() {
+        if ch == '_' {
+            upper_next = idx != 0;
+            continue;
+        }
+        if upper_next {
+            out.extend(ch.to_uppercase());
+            upper_next = false;
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}
diff --git a/rust/crates/truapi-codegen/tests/golden/dispatcher.rs b/rust/crates/truapi-codegen/tests/golden/dispatcher.rs
new file mode 100644
index 00000000..3797ec46
--- /dev/null
+++ b/rust/crates/truapi-codegen/tests/golden/dispatcher.rs
@@ -0,0 +1,1142 @@
+//! Wire dispatcher for the unified `TrUApi` trait.
+//!
+//! Auto-generated by truapi-codegen. Do not edit.
+
+use std::sync::Arc;
+
+use parity_scale_codec::Decode;
+
+use truapi::CallContext;
+use truapi::api::{
+    Account,
+    Chain,
+    Chat,
+    CoinPayment,
+    Entropy,
+    LocalStorage,
+    Notifications,
+    Payment,
+    Permissions,
+    Preimage,
+    ResourceAllocation,
+    Signing,
+    StatementStore,
+    System,
+    Theme,
+};
+use truapi::versioned;
+
+use crate::dispatcher::Dispatcher;
+use crate::frame::{encode_call_error_payload, encode_decode_error, encode_ok_payload};
+use crate::generated::wire_table;
+use crate::subscription::subscription_stream;
+
+/// Register every TrUAPI method with the dispatcher.
+pub fn register<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Account + Chain + Chat + CoinPayment + Entropy + LocalStorage + Notifications + Payment + Permissions + Preimage + ResourceAllocation + Signing + StatementStore + System + Theme + Send + Sync + 'static,
+{
+    register_account(dispatcher, host.clone());
+    register_chain(dispatcher, host.clone());
+    register_chat(dispatcher, host.clone());
+    register_coin_payment(dispatcher, host.clone());
+    register_entropy(dispatcher, host.clone());
+    register_local_storage(dispatcher, host.clone());
+    register_notifications(dispatcher, host.clone());
+    register_payment(dispatcher, host.clone());
+    register_permissions(dispatcher, host.clone());
+    register_preimage(dispatcher, host.clone());
+    register_resource_allocation(dispatcher, host.clone());
+    register_signing(dispatcher, host.clone());
+    register_statement_store(dispatcher, host.clone());
+    register_system(dispatcher, host.clone());
+    register_theme(dispatcher, host);
+}
+
+fn register_account<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Account + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::ACCOUNT_CONNECTION_STATUS_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let _ = bytes;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.connection_status_subscribe(&cx).await;
+                Ok(subscription_stream::<versioned::account::HostAccountConnectionStatusSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::ACCOUNT_GET_ACCOUNT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostAccountGetRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostAccountGetResponse = match host.get_account(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::ACCOUNT_GET_ACCOUNT_ALIAS, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostAccountGetAliasRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostAccountGetAliasResponse = match host.get_account_alias(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::ACCOUNT_CREATE_ACCOUNT_PROOF, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostAccountCreateProofRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostAccountCreateProofResponse = match host.create_account_proof(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::ACCOUNT_GET_LEGACY_ACCOUNTS, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostGetLegacyAccountsRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostGetLegacyAccountsResponse = match host.get_legacy_accounts(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::ACCOUNT_GET_USER_ID, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostGetUserIdRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostGetUserIdResponse = match host.get_user_id(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::ACCOUNT_REQUEST_LOGIN, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::account::HostRequestLoginRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::account::HostRequestLoginResponse = match host.request_login(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_chain<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Chain + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::CHAIN_FOLLOW_HEAD_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadFollowRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.follow_head_subscribe(&cx, request).await;
+                Ok(subscription_stream::<versioned::chain::RemoteChainHeadFollowItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_HEAD_HEADER, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadHeaderRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadHeaderResponse = match host.get_head_header(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_HEAD_BODY, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadBodyRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadBodyResponse = match host.get_head_body(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_HEAD_STORAGE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadStorageRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadStorageResponse = match host.get_head_storage(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_CALL_HEAD, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadCallRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadCallResponse = match host.call_head(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_UNPIN_HEAD, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadUnpinRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadUnpinResponse = match host.unpin_head(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_CONTINUE_HEAD, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadContinueRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadContinueResponse = match host.continue_head(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_STOP_HEAD_OPERATION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainHeadStopOperationRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainHeadStopOperationResponse = match host.stop_head_operation(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_SPEC_GENESIS_HASH, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainSpecGenesisHashRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainSpecGenesisHashResponse = match host.get_spec_genesis_hash(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_SPEC_CHAIN_NAME, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainSpecChainNameRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainSpecChainNameResponse = match host.get_spec_chain_name(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_GET_SPEC_PROPERTIES, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainSpecPropertiesRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainSpecPropertiesResponse = match host.get_spec_properties(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAIN_BROADCAST_TRANSACTION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainTransactionBroadcastRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainTransactionBroadcastResponse = match host.broadcast_transaction(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::CHAIN_STOP_TRANSACTION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chain::RemoteChainTransactionStopRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chain::RemoteChainTransactionStopResponse = match host.stop_transaction(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_chat<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Chat + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAT_CREATE_ROOM, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chat::HostChatCreateRoomRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chat::HostChatCreateRoomResponse = match host.create_room(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAT_REGISTER_BOT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chat::HostChatRegisterBotRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chat::HostChatRegisterBotResponse = match host.register_bot(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::CHAT_LIST_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let _ = bytes;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.list_subscribe(&cx).await;
+                Ok(subscription_stream::<versioned::chat::HostChatListSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::CHAT_POST_MESSAGE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chat::HostChatPostMessageRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::chat::HostChatPostMessageResponse = match host.post_message(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::CHAT_ACTION_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let _ = bytes;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.action_subscribe(&cx).await;
+                Ok(subscription_stream::<versioned::chat::HostChatActionSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_subscription(wire_table::CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::chat::ProductChatCustomMessageRenderSubscribeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.custom_message_render_subscribe(&cx, request).await;
+                Ok(subscription_stream::<versioned::chat::ProductChatCustomMessageRenderSubscribeItem, _>(stream))
+            })
+        });
+    }
+}
+
+fn register_coin_payment<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: CoinPayment + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::COIN_PAYMENT_CREATE_PURSE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentCreatePurseRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::coin_payment::HostCoinPaymentCreatePurseResponse = match host.create_purse(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::COIN_PAYMENT_QUERY_PURSE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentQueryPurseRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::coin_payment::HostCoinPaymentQueryPurseResponse = match host.query_purse(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::COIN_PAYMENT_REBALANCE_PURSE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentRebalancePurseRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.rebalance_purse(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::coin_payment::HostCoinPaymentRebalancePurseItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::COIN_PAYMENT_DELETE_PURSE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentDeletePurseRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.delete_purse(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::coin_payment::HostCoinPaymentDeletePurseItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::COIN_PAYMENT_CREATE_RECEIVABLE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentCreateReceivableRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::coin_payment::HostCoinPaymentCreateReceivableResponse = match host.create_receivable(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::COIN_PAYMENT_CREATE_CHEQUE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentCreateChequeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::coin_payment::HostCoinPaymentCreateChequeResponse = match host.create_cheque(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::COIN_PAYMENT_DEPOSIT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentDepositRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.deposit(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::coin_payment::HostCoinPaymentDepositItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::COIN_PAYMENT_REFUND, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentRefundRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.refund(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::coin_payment::HostCoinPaymentRefundItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_subscription(wire_table::COIN_PAYMENT_LISTEN_FOR_PAYMENT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::coin_payment::HostCoinPaymentListenForRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.listen_for_payment(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::coin_payment::HostCoinPaymentListenForItem, _>(stream))
+            })
+        });
+    }
+}
+
+fn register_entropy<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Entropy + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::ENTROPY_DERIVE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::entropy::HostDeriveEntropyRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::entropy::HostDeriveEntropyResponse = match host.derive(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_local_storage<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: LocalStorage + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::LOCAL_STORAGE_READ, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::local_storage::HostLocalStorageReadRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::local_storage::HostLocalStorageReadResponse = match host.read(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::LOCAL_STORAGE_WRITE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::local_storage::HostLocalStorageWriteRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::local_storage::HostLocalStorageWriteResponse = match host.write(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::LOCAL_STORAGE_CLEAR, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::local_storage::HostLocalStorageClearRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::local_storage::HostLocalStorageClearResponse = match host.clear(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_notifications<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Notifications + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::NOTIFICATIONS_SEND_PUSH_NOTIFICATION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::notifications::HostPushNotificationRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::notifications::HostPushNotificationResponse = match host.send_push_notification(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::notifications::HostPushNotificationCancelRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::notifications::HostPushNotificationCancelResponse = match host.cancel_push_notification(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_payment<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Payment + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::PAYMENT_BALANCE_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::payment::HostPaymentBalanceSubscribeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.balance_subscribe(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::payment::HostPaymentBalanceSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::PAYMENT_REQUEST, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::payment::HostPaymentRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::payment::HostPaymentResponse = match host.request(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::PAYMENT_STATUS_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::payment::HostPaymentStatusSubscribeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.status_subscribe(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::payment::HostPaymentStatusSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::PAYMENT_TOP_UP, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::payment::HostPaymentTopUpRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::payment::HostPaymentTopUpResponse = match host.top_up(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_permissions<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Permissions + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::PERMISSIONS_REQUEST_DEVICE_PERMISSION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::permissions::HostDevicePermissionRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::permissions::HostDevicePermissionResponse = match host.request_device_permission(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::PERMISSIONS_REQUEST_REMOTE_PERMISSION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::permissions::RemotePermissionRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::permissions::RemotePermissionResponse = match host.request_remote_permission(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_preimage<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Preimage + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::PREIMAGE_LOOKUP_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::preimage::RemotePreimageLookupSubscribeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.lookup_subscribe(&cx, request).await;
+                Ok(subscription_stream::<versioned::preimage::RemotePreimageLookupSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::PREIMAGE_SUBMIT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::preimage::RemotePreimageSubmitRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::preimage::RemotePreimageSubmitResponse = match host.submit(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_resource_allocation<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: ResourceAllocation + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::RESOURCE_ALLOCATION_REQUEST, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::resource_allocation::HostRequestResourceAllocationRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::resource_allocation::HostRequestResourceAllocationResponse = match host.request(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_signing<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Signing + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_CREATE_TRANSACTION, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostCreateTransactionRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostCreateTransactionResponse = match host.create_transaction(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostCreateTransactionWithLegacyAccountRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostCreateTransactionWithLegacyAccountResponse = match host.create_transaction_with_legacy_account(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostSignRawWithLegacyAccountRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostSignRawWithLegacyAccountResponse = match host.sign_raw_with_legacy_account(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostSignPayloadWithLegacyAccountRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostSignPayloadWithLegacyAccountResponse = match host.sign_payload_with_legacy_account(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_SIGN_RAW, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostSignRawRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostSignRawResponse = match host.sign_raw(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::SIGNING_SIGN_PAYLOAD, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostSignPayloadRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostSignPayloadResponse = match host.sign_payload(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_statement_store<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: StatementStore + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(wire_table::STATEMENT_STORE_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreSubscribeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = match host.subscribe(&cx, request).await {
+                    Ok(sub) => sub,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(subscription_stream::<versioned::statement_store::RemoteStatementStoreSubscribeItem, _>(stream))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::STATEMENT_STORE_CREATE_PROOF, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreCreateProofRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::statement_store::RemoteStatementStoreCreateProofResponse = match host.create_proof(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::STATEMENT_STORE_CREATE_PROOF_AUTHORIZED, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreCreateProofAuthorizedRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::statement_store::RemoteStatementStoreCreateProofAuthorizedResponse = match host.create_proof_authorized(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::STATEMENT_STORE_SUBMIT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreSubmitRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                match host.submit(&cx, request).await {
+                    Ok(()) => Ok(encode_ok_payload(())),
+                    Err(err) => Err(encode_call_error_payload(err)),
+                }
+            })
+        });
+    }
+}
+
+fn register_system<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: System + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SYSTEM_HANDSHAKE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::system::HostHandshakeRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::system::HostHandshakeResponse = match host.handshake(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SYSTEM_FEATURE_SUPPORTED, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::system::HostFeatureSupportedRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::system::HostFeatureSupportedResponse = match host.feature_supported(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::SYSTEM_NAVIGATE_TO, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::system::HostNavigateToRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::system::HostNavigateToResponse = match host.navigate_to(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_theme<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Theme + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_subscription(wire_table::THEME_SUBSCRIBE, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let _ = bytes;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let stream = host.subscribe(&cx).await;
+                Ok(subscription_stream::<versioned::theme::HostThemeSubscribeItem, _>(stream))
+            })
+        });
+    }
+}
diff --git a/rust/crates/truapi-codegen/tests/golden/host-callbacks.ts b/rust/crates/truapi-codegen/tests/golden/host-callbacks.ts
new file mode 100644
index 00000000..5933cb8f
--- /dev/null
+++ b/rust/crates/truapi-codegen/tests/golden/host-callbacks.ts
@@ -0,0 +1,288 @@
+// Auto-generated by truapi-codegen. Do not edit.
+//
+// Typed host-callbacks surface derived from the `truapi-platform`
+// capability traits. One interface per Rust trait + a composite
+// `HostCallbacks` interface that mirrors the `Platform` super-trait.
+
+import type {
+  GenericError,
+  HostDevicePermissionRequest,
+  HostDevicePermissionResponse,
+  HostFeatureSupportedRequest,
+  HostFeatureSupportedResponse,
+  HostPushNotificationRequest,
+  HostPushNotificationResponse,
+  NotificationId,
+  RemotePermissionRequest,
+  RemotePermissionResponse,
+  Result,
+  ThemeVariant,
+} from "@parity/truapi";
+
+/**
+ * Auth/session lifecycle state the core projects for host UI. The core owns
+ * every transition and emits states in order; hosts render the current state
+ * and never derive auth UI from any other signal.
+ */
+export type AuthState =
+  /**
+   * No active session and no login in progress.
+   */
+  | { tag: "Disconnected"; value?: undefined }
+  /**
+   * A login is in progress: present the pairing deeplink/QR. Leave this
+   * state only on a subsequent emission (connected, failed, or
+   * disconnected after cancellation).
+   */
+  | { tag: "Pairing"; value: { deeplink: string } }
+  /**
+   * A session is active.
+   */
+  | { tag: "Connected"; value: SessionUiInfo }
+  /**
+   * The last login attempt failed; show the reason and offer a retry.
+   */
+  | { tag: "LoginFailed"; value: { reason: string } };
+
+/**
+ * Decoded session fields a host shell needs to render account UI without
+ * parsing the opaque session blob the core persists through `SessionStore`.
+ */
+export interface SessionUiInfo {
+  /**
+   * Whether a session is currently active. When `false` every other
+   * field is ``undefined``.
+   */
+  connected: boolean;
+
+  /**
+   * 32-byte sr25519 root public key of the active session.
+   */
+  publicKey?: Uint8Array;
+
+  /**
+   * Wallet identity account id used for People-chain username lookup.
+   */
+  identityAccountId?: Uint8Array;
+
+  /**
+   * Short username from the People-chain identity record.
+   */
+  liteUsername?: string;
+
+  /**
+   * Fully qualified username from the People-chain identity record.
+   */
+  fullUsername?: string;
+}
+
+/**
+ * Host auth UI driven by core-owned `AuthState` transitions.
+ */
+export interface AuthPresenter {
+  /**
+   * Observe an auth state change. Emitted only when the state actually
+   * changes, in transition order. Default is a no-op for hosts that
+   * render no auth UI.
+   */
+  authStateChanged?(state: AuthState): void;
+}
+
+/**
+ * JSON-RPC provider factory for chain access.
+ *
+ * The platform provides a way to get a JSON-RPC connection for a given chain.
+ * The server runtime manages the chainHead v1 state machine on top of this.
+ */
+export interface ChainProvider {
+  /**
+   * Open a JSON-RPC connection for the chain identified by `genesis_hash`.
+   * Drop the returned connection to disconnect.
+   */
+  connect(genesisHash: Uint8Array): Promise<JsonRpcConnection>;
+}
+
+/**
+ * Feature-support probing. The host answers whether it can service a given
+ * capability (currently scoped to per-chain support).
+ */
+export interface Features {
+  /**
+   * Report whether the requested feature is supported.
+   */
+  featureSupported(request: HostFeatureSupportedRequest): Promise<HostFeatureSupportedResponse>;
+}
+
+/**
+ * A live JSON-RPC connection to a chain.
+ */
+export interface JsonRpcConnection {
+  /**
+   * Send a JSON-RPC request string.
+   */
+  send(request: string): void;
+
+  /**
+   * Stream of JSON-RPC response strings.
+   */
+  responses(): AsyncIterable<string>;
+}
+
+/**
+ * Open URLs in the system browser. Input is already trimmed, categorized,
+ * and (where needed) normalized by the core; the host implementation only
+ * needs to hand the URL to the OS URL handler.
+ */
+export interface Navigation {
+  /**
+   * Open the given URL in the system browser.
+   */
+  navigateTo(url: string): Promise<void>;
+}
+
+/**
+ * Deliver push notifications.
+ */
+export interface Notifications {
+  /**
+   * Schedule or immediately display the given notification and return the
+   * host-assigned id.
+   */
+  pushNotification(notification: HostPushNotificationRequest): Promise<HostPushNotificationResponse>;
+
+  /**
+   * Cancel a notification by id. Idempotent: cancelling an already-fired or
+   * unknown id still returns `success`.
+   */
+  cancelNotification(id: NotificationId): Promise<void>;
+}
+
+/**
+ * Permission prompts. v0.1 keeps device permissions (camera, mic, NFC, ...)
+ * separate from remote permissions (domain access, chain submit, ...), so the
+ * platform surface mirrors that split.
+ */
+export interface Permissions {
+  /**
+   * Prompt the user for a device-level permission.
+   */
+  devicePermission(request: HostDevicePermissionRequest): Promise<HostDevicePermissionResponse>;
+
+  /**
+   * Prompt the user for a remote (product-scoped) permission bundle.
+   */
+  remotePermission(request: RemotePermissionRequest): Promise<RemotePermissionResponse>;
+}
+
+/**
+ * Host preimage backend. The core owns wire mapping and subscription
+ * lifecycle; the host owns the selected backend.
+ */
+export interface PreimageHost {
+  /**
+   * Prompt before submitting a preimage.
+   */
+  confirmPreimageSubmit(size: bigint): Promise<void>;
+
+  /**
+   * Submit the preimage and return its key.
+   */
+  submitPreimage(value: Uint8Array): Promise<Uint8Array>;
+
+  /**
+   * Emits current value/miss immediately, then future updates.
+   */
+  lookupPreimage(key: Uint8Array): AsyncIterable<Result<Uint8Array | undefined, GenericError>>;
+}
+
+/**
+ * Host-global opaque session persistence for core-owned SSO state.
+ */
+export interface SessionStore {
+  /**
+   * Read the currently persisted core session blob.
+   */
+  readSession(): Promise<Uint8Array | undefined>;
+
+  /**
+   * Persist the core session blob.
+   */
+  writeSession(value: Uint8Array): Promise<void>;
+
+  /**
+   * Clear the persisted core session blob.
+   */
+  clearSession(): Promise<void>;
+
+  /**
+   * Emit once immediately, then on future local/cross-runtime changes.
+   */
+  subscribeSessionStore(): AsyncIterable<Result<void, GenericError>>;
+}
+
+/**
+ * Scoped key-value storage. The platform namespaces keys so different products
+ * cannot read each other's data.
+ */
+export interface HostStorage {
+  /**
+   * Read a value by key.
+   */
+  read(key: string): Promise<Uint8Array | undefined>;
+
+  /**
+   * Write a value to a key.
+   */
+  write(key: string, value: Uint8Array): Promise<void>;
+
+  /**
+   * Clear a value at a key.
+   */
+  clear(key: string): Promise<void>;
+}
+
+/**
+ * Host theme source.
+ */
+export interface ThemeHost {
+  /**
+   * Emits current theme immediately, then future changes.
+   */
+  subscribeTheme(): AsyncIterable<Result<ThemeVariant, GenericError>>;
+}
+
+/**
+ * Local user confirmation UI for session-channel operations.
+ */
+export interface UserConfirmation {
+  /**
+   * Confirm a sign-payload request before the core asks the SSO peer.
+   */
+  confirmSignPayload(review: Uint8Array): Promise<boolean>;
+
+  /**
+   * Confirm a sign-raw request before the core asks the SSO peer.
+   */
+  confirmSignRaw(review: Uint8Array): Promise<boolean>;
+
+  /**
+   * Confirm a create-transaction request before the core asks the SSO peer.
+   */
+  confirmCreateTransaction(review: Uint8Array): Promise<boolean>;
+
+  /**
+   * Confirm a cross-domain account-alias request before the core asks the
+   * SSO peer.
+   */
+  confirmAccountAlias(review: Uint8Array): Promise<boolean>;
+
+  /**
+   * Confirm resource allocation before the core asks the SSO peer.
+   */
+  confirmResourceAllocation(review: Uint8Array): Promise<boolean>;
+}
+
+/**
+ * Combined platform interface. A host must provide all capability traits.
+ */
+export interface HostCallbacks extends Navigation, Notifications, Permissions, Features, HostStorage, ChainProvider, AuthPresenter, SessionStore, UserConfirmation, ThemeHost, PreimageHost {}
diff --git a/rust/crates/truapi-codegen/tests/golden/wire_table.rs b/rust/crates/truapi-codegen/tests/golden/wire_table.rs
new file mode 100644
index 00000000..12a72a94
--- /dev/null
+++ b/rust/crates/truapi-codegen/tests/golden/wire_table.rs
@@ -0,0 +1,722 @@
+//! Wire-protocol discriminant table.
+//!
+//! Auto-generated by truapi-codegen. Do not edit.
+//!
+//! Each method reserves either two ids (request/response) or four
+//! (start/stop/interrupt/receive). The ids for each method are exposed
+//! as a named const (`PREIMAGE_SUBMIT`, ...); [`WIRE_TABLE`] and the
+//! generated dispatcher both reference those consts so the numbers live
+//! in exactly one place. The table is sorted by request/start id.
+
+/// Request method wire discriminants.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RequestFrameIds {
+    /// Discriminant for the request frame.
+    pub request_id: u8,
+    /// Discriminant for the response frame.
+    pub response_id: u8,
+}
+
+/// Subscription method wire discriminants.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SubscriptionFrameIds {
+    /// Discriminant for the start frame.
+    pub start_id: u8,
+    /// Discriminant for the stop frame.
+    pub stop_id: u8,
+    /// Discriminant for the interrupt frame (server-initiated termination).
+    pub interrupt_id: u8,
+    /// Discriminant for each receive frame (a streamed item).
+    pub receive_id: u8,
+}
+
+/// A single wire-table row.
+pub struct WireEntry {
+    /// Method name from the Rust trait.
+    pub method: &'static str,
+    /// What kind of slot this entry describes.
+    pub kind: WireKind,
+}
+
+/// Wire-slot shape: request/response pair or subscription quartet.
+pub enum WireKind {
+    /// Request/response method.
+    Request(RequestFrameIds),
+    /// Subscription method.
+    Subscription(SubscriptionFrameIds),
+}
+
+/// Wire discriminants for `system_handshake`.
+pub const SYSTEM_HANDSHAKE: RequestFrameIds = RequestFrameIds {
+    request_id: 0,
+    response_id: 1,
+};
+
+/// Wire discriminants for `system_feature_supported`.
+pub const SYSTEM_FEATURE_SUPPORTED: RequestFrameIds = RequestFrameIds {
+    request_id: 2,
+    response_id: 3,
+};
+
+/// Wire discriminants for `notifications_send_push_notification`.
+pub const NOTIFICATIONS_SEND_PUSH_NOTIFICATION: RequestFrameIds = RequestFrameIds {
+    request_id: 4,
+    response_id: 5,
+};
+
+/// Wire discriminants for `system_navigate_to`.
+pub const SYSTEM_NAVIGATE_TO: RequestFrameIds = RequestFrameIds {
+    request_id: 6,
+    response_id: 7,
+};
+
+/// Wire discriminants for `permissions_request_device_permission`.
+pub const PERMISSIONS_REQUEST_DEVICE_PERMISSION: RequestFrameIds = RequestFrameIds {
+    request_id: 8,
+    response_id: 9,
+};
+
+/// Wire discriminants for `permissions_request_remote_permission`.
+pub const PERMISSIONS_REQUEST_REMOTE_PERMISSION: RequestFrameIds = RequestFrameIds {
+    request_id: 10,
+    response_id: 11,
+};
+
+/// Wire discriminants for `local_storage_read`.
+pub const LOCAL_STORAGE_READ: RequestFrameIds = RequestFrameIds {
+    request_id: 12,
+    response_id: 13,
+};
+
+/// Wire discriminants for `local_storage_write`.
+pub const LOCAL_STORAGE_WRITE: RequestFrameIds = RequestFrameIds {
+    request_id: 14,
+    response_id: 15,
+};
+
+/// Wire discriminants for `local_storage_clear`.
+pub const LOCAL_STORAGE_CLEAR: RequestFrameIds = RequestFrameIds {
+    request_id: 16,
+    response_id: 17,
+};
+
+/// Wire discriminants for `account_connection_status_subscribe`.
+pub const ACCOUNT_CONNECTION_STATUS_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 18,
+    stop_id: 19,
+    interrupt_id: 20,
+    receive_id: 21,
+};
+
+/// Wire discriminants for `account_get_account`.
+pub const ACCOUNT_GET_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 22,
+    response_id: 23,
+};
+
+/// Wire discriminants for `account_get_account_alias`.
+pub const ACCOUNT_GET_ACCOUNT_ALIAS: RequestFrameIds = RequestFrameIds {
+    request_id: 24,
+    response_id: 25,
+};
+
+/// Wire discriminants for `account_create_account_proof`.
+pub const ACCOUNT_CREATE_ACCOUNT_PROOF: RequestFrameIds = RequestFrameIds {
+    request_id: 26,
+    response_id: 27,
+};
+
+/// Wire discriminants for `account_get_legacy_accounts`.
+pub const ACCOUNT_GET_LEGACY_ACCOUNTS: RequestFrameIds = RequestFrameIds {
+    request_id: 28,
+    response_id: 29,
+};
+
+/// Wire discriminants for `signing_create_transaction`.
+pub const SIGNING_CREATE_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 30,
+    response_id: 31,
+};
+
+/// Wire discriminants for `signing_create_transaction_with_legacy_account`.
+pub const SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 32,
+    response_id: 33,
+};
+
+/// Wire discriminants for `signing_sign_raw_with_legacy_account`.
+pub const SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 34,
+    response_id: 35,
+};
+
+/// Wire discriminants for `signing_sign_payload_with_legacy_account`.
+pub const SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 36,
+    response_id: 37,
+};
+
+/// Wire discriminants for `chat_create_room`.
+pub const CHAT_CREATE_ROOM: RequestFrameIds = RequestFrameIds {
+    request_id: 38,
+    response_id: 39,
+};
+
+/// Wire discriminants for `chat_register_bot`.
+pub const CHAT_REGISTER_BOT: RequestFrameIds = RequestFrameIds {
+    request_id: 40,
+    response_id: 41,
+};
+
+/// Wire discriminants for `chat_list_subscribe`.
+pub const CHAT_LIST_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 42,
+    stop_id: 43,
+    interrupt_id: 44,
+    receive_id: 45,
+};
+
+/// Wire discriminants for `chat_post_message`.
+pub const CHAT_POST_MESSAGE: RequestFrameIds = RequestFrameIds {
+    request_id: 46,
+    response_id: 47,
+};
+
+/// Wire discriminants for `chat_action_subscribe`.
+pub const CHAT_ACTION_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 48,
+    stop_id: 49,
+    interrupt_id: 50,
+    receive_id: 51,
+};
+
+/// Wire discriminants for `chat_custom_message_render_subscribe`.
+pub const CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 52,
+    stop_id: 53,
+    interrupt_id: 54,
+    receive_id: 55,
+};
+
+/// Wire discriminants for `statement_store_subscribe`.
+pub const STATEMENT_STORE_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 56,
+    stop_id: 57,
+    interrupt_id: 58,
+    receive_id: 59,
+};
+
+/// Wire discriminants for `statement_store_create_proof`.
+pub const STATEMENT_STORE_CREATE_PROOF: RequestFrameIds = RequestFrameIds {
+    request_id: 60,
+    response_id: 61,
+};
+
+/// Wire discriminants for `statement_store_submit`.
+pub const STATEMENT_STORE_SUBMIT: RequestFrameIds = RequestFrameIds {
+    request_id: 62,
+    response_id: 63,
+};
+
+/// Wire discriminants for `preimage_lookup_subscribe`.
+pub const PREIMAGE_LOOKUP_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 64,
+    stop_id: 65,
+    interrupt_id: 66,
+    receive_id: 67,
+};
+
+/// Wire discriminants for `preimage_submit`.
+pub const PREIMAGE_SUBMIT: RequestFrameIds = RequestFrameIds {
+    request_id: 68,
+    response_id: 69,
+};
+
+/// Wire discriminants for `chain_follow_head_subscribe`.
+pub const CHAIN_FOLLOW_HEAD_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 76,
+    stop_id: 77,
+    interrupt_id: 78,
+    receive_id: 79,
+};
+
+/// Wire discriminants for `chain_get_head_header`.
+pub const CHAIN_GET_HEAD_HEADER: RequestFrameIds = RequestFrameIds {
+    request_id: 80,
+    response_id: 81,
+};
+
+/// Wire discriminants for `chain_get_head_body`.
+pub const CHAIN_GET_HEAD_BODY: RequestFrameIds = RequestFrameIds {
+    request_id: 82,
+    response_id: 83,
+};
+
+/// Wire discriminants for `chain_get_head_storage`.
+pub const CHAIN_GET_HEAD_STORAGE: RequestFrameIds = RequestFrameIds {
+    request_id: 84,
+    response_id: 85,
+};
+
+/// Wire discriminants for `chain_call_head`.
+pub const CHAIN_CALL_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 86,
+    response_id: 87,
+};
+
+/// Wire discriminants for `chain_unpin_head`.
+pub const CHAIN_UNPIN_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 88,
+    response_id: 89,
+};
+
+/// Wire discriminants for `chain_continue_head`.
+pub const CHAIN_CONTINUE_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 90,
+    response_id: 91,
+};
+
+/// Wire discriminants for `chain_stop_head_operation`.
+pub const CHAIN_STOP_HEAD_OPERATION: RequestFrameIds = RequestFrameIds {
+    request_id: 92,
+    response_id: 93,
+};
+
+/// Wire discriminants for `chain_get_spec_genesis_hash`.
+pub const CHAIN_GET_SPEC_GENESIS_HASH: RequestFrameIds = RequestFrameIds {
+    request_id: 94,
+    response_id: 95,
+};
+
+/// Wire discriminants for `chain_get_spec_chain_name`.
+pub const CHAIN_GET_SPEC_CHAIN_NAME: RequestFrameIds = RequestFrameIds {
+    request_id: 96,
+    response_id: 97,
+};
+
+/// Wire discriminants for `chain_get_spec_properties`.
+pub const CHAIN_GET_SPEC_PROPERTIES: RequestFrameIds = RequestFrameIds {
+    request_id: 98,
+    response_id: 99,
+};
+
+/// Wire discriminants for `chain_broadcast_transaction`.
+pub const CHAIN_BROADCAST_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 100,
+    response_id: 101,
+};
+
+/// Wire discriminants for `chain_stop_transaction`.
+pub const CHAIN_STOP_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 102,
+    response_id: 103,
+};
+
+/// Wire discriminants for `theme_subscribe`.
+pub const THEME_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 104,
+    stop_id: 105,
+    interrupt_id: 106,
+    receive_id: 107,
+};
+
+/// Wire discriminants for `entropy_derive`.
+pub const ENTROPY_DERIVE: RequestFrameIds = RequestFrameIds {
+    request_id: 108,
+    response_id: 109,
+};
+
+/// Wire discriminants for `account_get_user_id`.
+pub const ACCOUNT_GET_USER_ID: RequestFrameIds = RequestFrameIds {
+    request_id: 110,
+    response_id: 111,
+};
+
+/// Wire discriminants for `account_request_login`.
+pub const ACCOUNT_REQUEST_LOGIN: RequestFrameIds = RequestFrameIds {
+    request_id: 112,
+    response_id: 113,
+};
+
+/// Wire discriminants for `signing_sign_raw`.
+pub const SIGNING_SIGN_RAW: RequestFrameIds = RequestFrameIds {
+    request_id: 114,
+    response_id: 115,
+};
+
+/// Wire discriminants for `signing_sign_payload`.
+pub const SIGNING_SIGN_PAYLOAD: RequestFrameIds = RequestFrameIds {
+    request_id: 116,
+    response_id: 117,
+};
+
+/// Wire discriminants for `payment_balance_subscribe`.
+pub const PAYMENT_BALANCE_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 118,
+    stop_id: 119,
+    interrupt_id: 120,
+    receive_id: 121,
+};
+
+/// Wire discriminants for `payment_top_up`.
+pub const PAYMENT_TOP_UP: RequestFrameIds = RequestFrameIds {
+    request_id: 122,
+    response_id: 123,
+};
+
+/// Wire discriminants for `payment_request`.
+pub const PAYMENT_REQUEST: RequestFrameIds = RequestFrameIds {
+    request_id: 124,
+    response_id: 125,
+};
+
+/// Wire discriminants for `payment_status_subscribe`.
+pub const PAYMENT_STATUS_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 126,
+    stop_id: 127,
+    interrupt_id: 128,
+    receive_id: 129,
+};
+
+/// Wire discriminants for `resource_allocation_request`.
+pub const RESOURCE_ALLOCATION_REQUEST: RequestFrameIds = RequestFrameIds {
+    request_id: 130,
+    response_id: 131,
+};
+
+/// Wire discriminants for `statement_store_create_proof_authorized`.
+pub const STATEMENT_STORE_CREATE_PROOF_AUTHORIZED: RequestFrameIds = RequestFrameIds {
+    request_id: 132,
+    response_id: 133,
+};
+
+/// Wire discriminants for `notifications_cancel_push_notification`.
+pub const NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION: RequestFrameIds = RequestFrameIds {
+    request_id: 134,
+    response_id: 135,
+};
+
+/// Wire discriminants for `coin_payment_create_purse`.
+pub const COIN_PAYMENT_CREATE_PURSE: RequestFrameIds = RequestFrameIds {
+    request_id: 136,
+    response_id: 137,
+};
+
+/// Wire discriminants for `coin_payment_query_purse`.
+pub const COIN_PAYMENT_QUERY_PURSE: RequestFrameIds = RequestFrameIds {
+    request_id: 138,
+    response_id: 139,
+};
+
+/// Wire discriminants for `coin_payment_rebalance_purse`.
+pub const COIN_PAYMENT_REBALANCE_PURSE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 140,
+    stop_id: 141,
+    interrupt_id: 142,
+    receive_id: 143,
+};
+
+/// Wire discriminants for `coin_payment_delete_purse`.
+pub const COIN_PAYMENT_DELETE_PURSE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 144,
+    stop_id: 145,
+    interrupt_id: 146,
+    receive_id: 147,
+};
+
+/// Wire discriminants for `coin_payment_create_receivable`.
+pub const COIN_PAYMENT_CREATE_RECEIVABLE: RequestFrameIds = RequestFrameIds {
+    request_id: 148,
+    response_id: 149,
+};
+
+/// Wire discriminants for `coin_payment_create_cheque`.
+pub const COIN_PAYMENT_CREATE_CHEQUE: RequestFrameIds = RequestFrameIds {
+    request_id: 150,
+    response_id: 151,
+};
+
+/// Wire discriminants for `coin_payment_deposit`.
+pub const COIN_PAYMENT_DEPOSIT: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 152,
+    stop_id: 153,
+    interrupt_id: 154,
+    receive_id: 155,
+};
+
+/// Wire discriminants for `coin_payment_refund`.
+pub const COIN_PAYMENT_REFUND: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 156,
+    stop_id: 157,
+    interrupt_id: 158,
+    receive_id: 159,
+};
+
+/// Wire discriminants for `coin_payment_listen_for_payment`.
+pub const COIN_PAYMENT_LISTEN_FOR_PAYMENT: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 160,
+    stop_id: 161,
+    interrupt_id: 162,
+    receive_id: 163,
+};
+
+/// The full wire table. Ordering is part of the wire protocol;
+/// only ever append. Removed methods leave their slot empty.
+pub const WIRE_TABLE: &[WireEntry] = &[
+    WireEntry {
+        method: "system_handshake",
+        kind: WireKind::Request(SYSTEM_HANDSHAKE),
+    },
+    WireEntry {
+        method: "system_feature_supported",
+        kind: WireKind::Request(SYSTEM_FEATURE_SUPPORTED),
+    },
+    WireEntry {
+        method: "notifications_send_push_notification",
+        kind: WireKind::Request(NOTIFICATIONS_SEND_PUSH_NOTIFICATION),
+    },
+    WireEntry {
+        method: "system_navigate_to",
+        kind: WireKind::Request(SYSTEM_NAVIGATE_TO),
+    },
+    WireEntry {
+        method: "permissions_request_device_permission",
+        kind: WireKind::Request(PERMISSIONS_REQUEST_DEVICE_PERMISSION),
+    },
+    WireEntry {
+        method: "permissions_request_remote_permission",
+        kind: WireKind::Request(PERMISSIONS_REQUEST_REMOTE_PERMISSION),
+    },
+    WireEntry {
+        method: "local_storage_read",
+        kind: WireKind::Request(LOCAL_STORAGE_READ),
+    },
+    WireEntry {
+        method: "local_storage_write",
+        kind: WireKind::Request(LOCAL_STORAGE_WRITE),
+    },
+    WireEntry {
+        method: "local_storage_clear",
+        kind: WireKind::Request(LOCAL_STORAGE_CLEAR),
+    },
+    WireEntry {
+        method: "account_connection_status_subscribe",
+        kind: WireKind::Subscription(ACCOUNT_CONNECTION_STATUS_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "account_get_account",
+        kind: WireKind::Request(ACCOUNT_GET_ACCOUNT),
+    },
+    WireEntry {
+        method: "account_get_account_alias",
+        kind: WireKind::Request(ACCOUNT_GET_ACCOUNT_ALIAS),
+    },
+    WireEntry {
+        method: "account_create_account_proof",
+        kind: WireKind::Request(ACCOUNT_CREATE_ACCOUNT_PROOF),
+    },
+    WireEntry {
+        method: "account_get_legacy_accounts",
+        kind: WireKind::Request(ACCOUNT_GET_LEGACY_ACCOUNTS),
+    },
+    WireEntry {
+        method: "signing_create_transaction",
+        kind: WireKind::Request(SIGNING_CREATE_TRANSACTION),
+    },
+    WireEntry {
+        method: "signing_create_transaction_with_legacy_account",
+        kind: WireKind::Request(SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "signing_sign_raw_with_legacy_account",
+        kind: WireKind::Request(SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "signing_sign_payload_with_legacy_account",
+        kind: WireKind::Request(SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "chat_create_room",
+        kind: WireKind::Request(CHAT_CREATE_ROOM),
+    },
+    WireEntry {
+        method: "chat_register_bot",
+        kind: WireKind::Request(CHAT_REGISTER_BOT),
+    },
+    WireEntry {
+        method: "chat_list_subscribe",
+        kind: WireKind::Subscription(CHAT_LIST_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chat_post_message",
+        kind: WireKind::Request(CHAT_POST_MESSAGE),
+    },
+    WireEntry {
+        method: "chat_action_subscribe",
+        kind: WireKind::Subscription(CHAT_ACTION_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chat_custom_message_render_subscribe",
+        kind: WireKind::Subscription(CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "statement_store_subscribe",
+        kind: WireKind::Subscription(STATEMENT_STORE_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "statement_store_create_proof",
+        kind: WireKind::Request(STATEMENT_STORE_CREATE_PROOF),
+    },
+    WireEntry {
+        method: "statement_store_submit",
+        kind: WireKind::Request(STATEMENT_STORE_SUBMIT),
+    },
+    WireEntry {
+        method: "preimage_lookup_subscribe",
+        kind: WireKind::Subscription(PREIMAGE_LOOKUP_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "preimage_submit",
+        kind: WireKind::Request(PREIMAGE_SUBMIT),
+    },
+    WireEntry {
+        method: "chain_follow_head_subscribe",
+        kind: WireKind::Subscription(CHAIN_FOLLOW_HEAD_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chain_get_head_header",
+        kind: WireKind::Request(CHAIN_GET_HEAD_HEADER),
+    },
+    WireEntry {
+        method: "chain_get_head_body",
+        kind: WireKind::Request(CHAIN_GET_HEAD_BODY),
+    },
+    WireEntry {
+        method: "chain_get_head_storage",
+        kind: WireKind::Request(CHAIN_GET_HEAD_STORAGE),
+    },
+    WireEntry {
+        method: "chain_call_head",
+        kind: WireKind::Request(CHAIN_CALL_HEAD),
+    },
+    WireEntry {
+        method: "chain_unpin_head",
+        kind: WireKind::Request(CHAIN_UNPIN_HEAD),
+    },
+    WireEntry {
+        method: "chain_continue_head",
+        kind: WireKind::Request(CHAIN_CONTINUE_HEAD),
+    },
+    WireEntry {
+        method: "chain_stop_head_operation",
+        kind: WireKind::Request(CHAIN_STOP_HEAD_OPERATION),
+    },
+    WireEntry {
+        method: "chain_get_spec_genesis_hash",
+        kind: WireKind::Request(CHAIN_GET_SPEC_GENESIS_HASH),
+    },
+    WireEntry {
+        method: "chain_get_spec_chain_name",
+        kind: WireKind::Request(CHAIN_GET_SPEC_CHAIN_NAME),
+    },
+    WireEntry {
+        method: "chain_get_spec_properties",
+        kind: WireKind::Request(CHAIN_GET_SPEC_PROPERTIES),
+    },
+    WireEntry {
+        method: "chain_broadcast_transaction",
+        kind: WireKind::Request(CHAIN_BROADCAST_TRANSACTION),
+    },
+    WireEntry {
+        method: "chain_stop_transaction",
+        kind: WireKind::Request(CHAIN_STOP_TRANSACTION),
+    },
+    WireEntry {
+        method: "theme_subscribe",
+        kind: WireKind::Subscription(THEME_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "entropy_derive",
+        kind: WireKind::Request(ENTROPY_DERIVE),
+    },
+    WireEntry {
+        method: "account_get_user_id",
+        kind: WireKind::Request(ACCOUNT_GET_USER_ID),
+    },
+    WireEntry {
+        method: "account_request_login",
+        kind: WireKind::Request(ACCOUNT_REQUEST_LOGIN),
+    },
+    WireEntry {
+        method: "signing_sign_raw",
+        kind: WireKind::Request(SIGNING_SIGN_RAW),
+    },
+    WireEntry {
+        method: "signing_sign_payload",
+        kind: WireKind::Request(SIGNING_SIGN_PAYLOAD),
+    },
+    WireEntry {
+        method: "payment_balance_subscribe",
+        kind: WireKind::Subscription(PAYMENT_BALANCE_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "payment_top_up",
+        kind: WireKind::Request(PAYMENT_TOP_UP),
+    },
+    WireEntry {
+        method: "payment_request",
+        kind: WireKind::Request(PAYMENT_REQUEST),
+    },
+    WireEntry {
+        method: "payment_status_subscribe",
+        kind: WireKind::Subscription(PAYMENT_STATUS_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "resource_allocation_request",
+        kind: WireKind::Request(RESOURCE_ALLOCATION_REQUEST),
+    },
+    WireEntry {
+        method: "statement_store_create_proof_authorized",
+        kind: WireKind::Request(STATEMENT_STORE_CREATE_PROOF_AUTHORIZED),
+    },
+    WireEntry {
+        method: "notifications_cancel_push_notification",
+        kind: WireKind::Request(NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION),
+    },
+    WireEntry {
+        method: "coin_payment_create_purse",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_query_purse",
+        kind: WireKind::Request(COIN_PAYMENT_QUERY_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_rebalance_purse",
+        kind: WireKind::Subscription(COIN_PAYMENT_REBALANCE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_delete_purse",
+        kind: WireKind::Subscription(COIN_PAYMENT_DELETE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_create_receivable",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_RECEIVABLE),
+    },
+    WireEntry {
+        method: "coin_payment_create_cheque",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_CHEQUE),
+    },
+    WireEntry {
+        method: "coin_payment_deposit",
+        kind: WireKind::Subscription(COIN_PAYMENT_DEPOSIT),
+    },
+    WireEntry {
+        method: "coin_payment_refund",
+        kind: WireKind::Subscription(COIN_PAYMENT_REFUND),
+    },
+    WireEntry {
+        method: "coin_payment_listen_for_payment",
+        kind: WireKind::Subscription(COIN_PAYMENT_LISTEN_FOR_PAYMENT),
+    },
+];
diff --git a/rust/crates/truapi-codegen/tests/golden_rust_emit.rs b/rust/crates/truapi-codegen/tests/golden_rust_emit.rs
new file mode 100644
index 00000000..a9bd9240
--- /dev/null
+++ b/rust/crates/truapi-codegen/tests/golden_rust_emit.rs
@@ -0,0 +1,196 @@
+//! Golden snapshot test for the Rust dispatcher emitter.
+//!
+//! Each test runs `cargo +nightly rustdoc -p truapi` into its own
+//! `--target-dir` under a per-test tempdir so concurrent test execution
+//! cannot race on the shared `target/doc/truapi.json` path. Nightly Rust
+//! is required; if it is not available the test panics rather than
+//! silently passing (set up rustup with `rustup toolchain install nightly`).
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Run `cargo +nightly rustdoc -p truapi --output-format json` into the
+/// given `target_dir` and return the path to the produced JSON file.
+/// Panics with a clear message if nightly is unavailable so CI cannot
+/// pass vacuously.
+fn produce_rustdoc_json(workspace_root: &Path, target_dir: &Path) -> PathBuf {
+    produce_rustdoc_json_for_package(workspace_root, target_dir, "truapi")
+}
+
+fn produce_rustdoc_json_for_package(
+    workspace_root: &Path,
+    target_dir: &Path,
+    package: &str,
+) -> PathBuf {
+    let output = Command::new("cargo")
+        .args(["+nightly", "rustdoc", "-p", package, "--target-dir"])
+        .arg(target_dir)
+        .args(["--", "-Z", "unstable-options", "--output-format", "json"])
+        .current_dir(workspace_root)
+        .output()
+        .expect(
+            "failed to spawn `cargo +nightly rustdoc`; install nightly via \
+             `rustup toolchain install nightly`",
+        );
+    assert!(
+        output.status.success(),
+        "`cargo +nightly rustdoc -p {package}` failed (status {}); nightly toolchain is required.\nstdout:\n{}\nstderr:\n{}",
+        output.status,
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let json_name = package.replace('-', "_");
+    let json = target_dir.join(format!("doc/{json_name}.json"));
+    assert!(
+        json.exists(),
+        "rustdoc JSON not found at {} after successful rustdoc invocation",
+        json.display(),
+    );
+    json
+}
+
+fn workspace_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(3)
+        .expect("workspace root above rust/crates/truapi-codegen")
+        .to_path_buf()
+}
+
+#[test]
+fn golden_dispatcher_and_wire_table() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let workspace = workspace_root();
+
+    let tempdir = tempfile::tempdir().expect("tempdir");
+    let rustdoc_json = produce_rustdoc_json(&workspace, &tempdir.path().join("rustdoc-target"));
+
+    let out = Command::new(env!("CARGO_BIN_EXE_truapi-codegen"))
+        .args([
+            "--input",
+            rustdoc_json.to_str().unwrap(),
+            "--output",
+            tempdir.path().join("ts").to_str().unwrap(),
+            "--rust-output",
+            tempdir.path().join("rust").to_str().unwrap(),
+        ])
+        .output()
+        .expect("run truapi-codegen");
+    assert!(
+        out.status.success(),
+        "codegen failed: stdout=\n{}\nstderr=\n{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+
+    // Compare both emitted files against the goldens. We assert on
+    // wire_table.rs first because it's small and the diff is easy to
+    // read when the wire ids drift.
+    let golden_dir = manifest_dir.join("tests/golden");
+    let cases = [
+        ("wire_table.rs", "wire_table.rs"),
+        ("dispatcher.rs", "dispatcher.rs"),
+    ];
+    for (golden_name, output_name) in cases {
+        let golden = fs::read_to_string(golden_dir.join(golden_name))
+            .unwrap_or_else(|e| panic!("read {golden_name}: {e}"));
+        let actual = fs::read_to_string(tempdir.path().join("rust").join(output_name))
+            .unwrap_or_else(|e| panic!("read generated {output_name}: {e}"));
+        if golden != actual {
+            // Dump actual to a sibling file for easy inspection
+            // when running locally.
+            let dump = manifest_dir.join(format!("tests/golden/{output_name}.actual"));
+            let _ = fs::write(&dump, &actual);
+            panic!(
+                "golden mismatch for {output_name}; wrote actual to {}",
+                dump.display()
+            );
+        }
+    }
+}
+
+/// Idempotence guard at the integration level: running the binary twice
+/// against the same input must produce identical output. This catches
+/// non-determinism (HashMap iteration order, timestamps, etc.) that the
+/// inline unit tests might miss because they exercise smaller APIs.
+#[test]
+fn binary_emission_is_idempotent() {
+    let workspace = workspace_root();
+    let tempdir = tempfile::tempdir().expect("tempdir");
+    let rustdoc_json = produce_rustdoc_json(&workspace, &tempdir.path().join("rustdoc-target"));
+
+    let run_once = || -> (String, String) {
+        let tmp = tempfile::tempdir().unwrap();
+        let status = Command::new(env!("CARGO_BIN_EXE_truapi-codegen"))
+            .args([
+                "--input",
+                rustdoc_json.to_str().unwrap(),
+                "--output",
+                tmp.path().join("ts").to_str().unwrap(),
+                "--rust-output",
+                tmp.path().join("rust").to_str().unwrap(),
+            ])
+            .status()
+            .expect("run truapi-codegen");
+        assert!(status.success(), "codegen run failed");
+        let dispatcher =
+            fs::read_to_string(tmp.path().join("rust/dispatcher.rs")).expect("read dispatcher");
+        let wire_table =
+            fs::read_to_string(tmp.path().join("rust/wire_table.rs")).expect("read wire_table");
+        (dispatcher, wire_table)
+    };
+
+    let (a_disp, a_wire) = run_once();
+    let (b_disp, b_wire) = run_once();
+    assert_eq!(a_disp, b_disp, "dispatcher.rs differs between runs");
+    assert_eq!(a_wire, b_wire, "wire_table.rs differs between runs");
+}
+
+#[test]
+fn golden_host_callbacks_ts() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let workspace = workspace_root();
+
+    let tempdir = tempfile::tempdir().expect("tempdir");
+    let truapi_json = produce_rustdoc_json(&workspace, &tempdir.path().join("rustdoc-target"));
+    let platform_json = produce_rustdoc_json_for_package(
+        &workspace,
+        &tempdir.path().join("rustdoc-platform-target"),
+        "truapi-platform",
+    );
+
+    let out = Command::new(env!("CARGO_BIN_EXE_truapi-codegen"))
+        .args([
+            "--input",
+            truapi_json.to_str().unwrap(),
+            "--output",
+            tempdir.path().join("ts").to_str().unwrap(),
+            "--platform-input",
+            platform_json.to_str().unwrap(),
+            "--platform-ts-output",
+            tempdir.path().join("platform").to_str().unwrap(),
+        ])
+        .output()
+        .expect("run truapi-codegen");
+    assert!(
+        out.status.success(),
+        "codegen failed: stdout=\n{}\nstderr=\n{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+
+    let golden_path = manifest_dir.join("tests/golden/host-callbacks.ts");
+    let golden =
+        fs::read_to_string(&golden_path).unwrap_or_else(|e| panic!("read host-callbacks.ts: {e}"));
+    let actual = fs::read_to_string(tempdir.path().join("platform/host-callbacks.ts"))
+        .expect("read generated host-callbacks.ts");
+    if golden != actual {
+        let dump = manifest_dir.join("tests/golden/host-callbacks.ts.actual");
+        let _ = fs::write(&dump, &actual);
+        panic!(
+            "golden mismatch for host-callbacks.ts; wrote actual to {}",
+            dump.display()
+        );
+    }
+}
diff --git a/rust/crates/truapi-platform/Cargo.toml b/rust/crates/truapi-platform/Cargo.toml
new file mode 100644
index 00000000..26e4342d
--- /dev/null
+++ b/rust/crates/truapi-platform/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "truapi-platform"
+version = "0.1.0"
+edition.workspace = true
+description = "Platform capability traits for TrUAPI host implementations"
+license = "MIT"
+
+[dependencies]
+truapi = { path = "../truapi" }
+futures = "0.3"
+url = "2"
diff --git a/rust/crates/truapi-platform/README.md b/rust/crates/truapi-platform/README.md
new file mode 100644
index 00000000..a892ecc2
--- /dev/null
+++ b/rust/crates/truapi-platform/README.md
@@ -0,0 +1,27 @@
+# truapi-platform
+
+Platform capability traits for TrUAPI host implementations.
+
+Each platform (web/WASM, iOS/UniFFI, Android/UniFFI) implements these traits to
+provide native capabilities. The TrUAPI dispatcher (in `truapi-server`) calls
+into these when handling API requests from the product side.
+
+## Traits
+
+- `Storage`, scoped key-value storage (`read`, `write`, `clear`).
+- `Navigation`, open URLs in the system browser.
+- `Notifications`, deliver push notifications.
+- `Permissions`, prompt for device and remote permissions (v0.1 split callbacks).
+- `Features`, probe per-chain (or other) feature support.
+- `ChainProvider` / `JsonRpcConnection`, open JSON-RPC connections to chains.
+
+`Platform` is a blanket-implemented supertrait that combines the six
+host-facing capabilities: `Navigation`, `Notifications`, `Permissions`,
+`Features`, `Storage`, and `ChainProvider`. Account, signing, statement-store
+and preimage flows live in the Rust core itself, not in this trait set.
+
+## Versioning
+
+Types come from `truapi::versioned::*` (V1 enum wrappers) where possible, and
+fall back to `truapi::v01::*` for inner error and value types. The crate
+re-exports both modules for downstream convenience.
diff --git a/rust/crates/truapi-platform/src/lib.rs b/rust/crates/truapi-platform/src/lib.rs
new file mode 100644
index 00000000..f1169fab
--- /dev/null
+++ b/rust/crates/truapi-platform/src/lib.rs
@@ -0,0 +1,394 @@
+//! Capability traits a TrUAPI host must implement.
+//!
+//! Each trait covers a single OS-primitive surface the Rust core cannot reach
+//! from its own process (key-value persistence, URL launching, push
+//! notifications, permission UI, chain RPC, host-selected preimage backends).
+//! Account management, signing, and statement-store protocol flows live in the
+//! Rust core itself and are not part of this trait set.
+//!
+//! Host implementations may use `async fn` in trait bodies directly. The
+//! consumers (`truapi-server::runtime::PlatformRuntimeHost<P>`) are generic
+//! over `P: Platform`, so `dyn Trait` object safety is not required.
+
+#![forbid(unsafe_code)]
+
+use futures::stream::BoxStream;
+
+use truapi::v01::{
+    GenericError, HostDevicePermissionRequest, HostDevicePermissionResponse,
+    HostLocalStorageReadError, HostNavigateToError, HostPushNotificationRequest,
+    HostPushNotificationResponse, NotificationId, PreimageSubmitError, RemotePermissionRequest,
+    RemotePermissionResponse, ThemeVariant,
+};
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use url::Url;
+
+/// Re-export of `truapi::v01` for host implementations.
+pub use truapi::v01;
+/// Re-export of `truapi::versioned` for host implementations.
+pub use truapi::versioned;
+
+/// Static runtime configuration supplied by the embedding host before the
+/// core handles product-scoped calls.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RuntimeConfig {
+    /// Human-readable dotli label, e.g. `my-app`.
+    pub product_label: String,
+    /// Canonical product identifier used for account derivation.
+    pub product_id: String,
+    /// Host deployment/site identifier, e.g. `dot.li`.
+    pub site_id: String,
+    /// Host name shown by the wallet during SSO pairing.
+    pub host_name: String,
+    /// Optional host icon URL/CID shown by the wallet during SSO pairing.
+    pub host_icon: Option<String>,
+    /// Optional host version shown by the wallet during SSO pairing.
+    pub host_version: Option<String>,
+    /// Optional platform/browser name shown by the wallet during SSO pairing.
+    pub platform_type: Option<String>,
+    /// Optional platform/browser version shown by the wallet during SSO pairing.
+    pub platform_version: Option<String>,
+    /// People-chain genesis hash used for statement-store SSO.
+    pub people_chain_genesis_hash: [u8; 32],
+    /// Deeplink scheme used in pairing QR payloads.
+    pub pairing_deeplink_scheme: PairingDeeplinkScheme,
+}
+
+impl RuntimeConfig {
+    /// Validate fields whose representation cannot be made invalid by Rust
+    /// types alone.
+    pub fn validate(&self) -> Result<(), RuntimeConfigValidationError> {
+        require_non_empty("product_label", &self.product_label)?;
+        require_non_empty("product_id", &self.product_id)?;
+        require_non_empty("site_id", &self.site_id)?;
+        require_non_empty("host_name", &self.host_name)?;
+        if let Some(icon) = &self.host_icon {
+            let parsed =
+                Url::parse(icon).map_err(|err| RuntimeConfigValidationError::InvalidHostIcon {
+                    reason: err.to_string(),
+                })?;
+            if parsed.scheme() != "https" {
+                return Err(RuntimeConfigValidationError::InsecureHostIcon {
+                    scheme: parsed.scheme().to_string(),
+                });
+            }
+        }
+        Ok(())
+    }
+}
+
+fn require_non_empty(field: &'static str, value: &str) -> Result<(), RuntimeConfigValidationError> {
+    if value.trim().is_empty() {
+        return Err(RuntimeConfigValidationError::EmptyField { field });
+    }
+    Ok(())
+}
+
+/// Runtime config validation error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RuntimeConfigValidationError {
+    /// Required string field was empty or whitespace-only.
+    EmptyField {
+        /// Field name.
+        field: &'static str,
+    },
+    /// Host icon URL could not be parsed as an absolute URL.
+    InvalidHostIcon {
+        /// Parse failure reason.
+        reason: String,
+    },
+    /// Host icon URL used a non-HTTPS scheme.
+    InsecureHostIcon {
+        /// Actual URL scheme.
+        scheme: String,
+    },
+}
+
+impl std::fmt::Display for RuntimeConfigValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RuntimeConfigValidationError::EmptyField { field } => {
+                write!(f, "{field} must not be empty")
+            }
+            RuntimeConfigValidationError::InvalidHostIcon { reason } => {
+                write!(f, "host_icon must be an absolute HTTPS URL: {reason}")
+            }
+            RuntimeConfigValidationError::InsecureHostIcon { scheme } => {
+                write!(f, "host_icon must use https scheme, got {scheme:?}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for RuntimeConfigValidationError {}
+
+/// SSO wallet deeplink scheme.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PairingDeeplinkScheme {
+    /// Production Polkadot app.
+    PolkadotApp,
+    /// Development Polkadot app.
+    PolkadotAppDev,
+}
+
+/// Scoped key-value storage. The platform namespaces keys so different products
+/// cannot read each other's data.
+pub trait Storage: Send + Sync {
+    /// Read a value by key.
+    fn read(
+        &self,
+        key: String,
+    ) -> impl Future<Output = Result<Option<Vec<u8>>, HostLocalStorageReadError>> + Send;
+
+    /// Write a value to a key.
+    fn write(
+        &self,
+        key: String,
+        value: Vec<u8>,
+    ) -> impl Future<Output = Result<(), HostLocalStorageReadError>> + Send;
+
+    /// Clear a value at a key.
+    fn clear(
+        &self,
+        key: String,
+    ) -> impl Future<Output = Result<(), HostLocalStorageReadError>> + Send;
+}
+
+/// Open URLs in the system browser. Input is already trimmed, categorized,
+/// and (where needed) normalized by the core; the host implementation only
+/// needs to hand the URL to the OS URL handler.
+pub trait Navigation: Send + Sync {
+    /// Open the given URL in the system browser.
+    fn navigate_to(
+        &self,
+        url: String,
+    ) -> impl Future<Output = Result<(), HostNavigateToError>> + Send;
+}
+
+/// Deliver push notifications.
+pub trait Notifications: Send + Sync {
+    /// Schedule or immediately display the given notification and return the
+    /// host-assigned id.
+    fn push_notification(
+        &self,
+        notification: HostPushNotificationRequest,
+    ) -> impl Future<Output = Result<HostPushNotificationResponse, GenericError>> + Send;
+
+    /// Cancel a notification by id. Idempotent: cancelling an already-fired or
+    /// unknown id still returns `Ok(())`.
+    fn cancel_notification(
+        &self,
+        id: NotificationId,
+    ) -> impl Future<Output = Result<(), GenericError>> + Send;
+}
+
+/// Permission prompts. v0.1 keeps device permissions (camera, mic, NFC, ...)
+/// separate from remote permissions (domain access, chain submit, ...), so the
+/// platform surface mirrors that split.
+pub trait Permissions: Send + Sync {
+    /// Prompt the user for a device-level permission.
+    fn device_permission(
+        &self,
+        request: HostDevicePermissionRequest,
+    ) -> impl Future<Output = Result<HostDevicePermissionResponse, GenericError>> + Send;
+
+    /// Prompt the user for a remote (product-scoped) permission bundle.
+    fn remote_permission(
+        &self,
+        request: RemotePermissionRequest,
+    ) -> impl Future<Output = Result<RemotePermissionResponse, GenericError>> + Send;
+}
+
+/// Feature-support probing. The host answers whether it can service a given
+/// capability (currently scoped to per-chain support).
+pub trait Features: Send + Sync {
+    /// Report whether the requested feature is supported.
+    fn feature_supported(
+        &self,
+        request: HostFeatureSupportedRequest,
+    ) -> impl Future<Output = Result<HostFeatureSupportedResponse, GenericError>> + Send;
+}
+
+/// JSON-RPC provider factory for chain access.
+///
+/// The platform provides a way to get a JSON-RPC connection for a given chain.
+/// The server runtime manages the chainHead v1 state machine on top of this.
+pub trait ChainProvider: Send + Sync {
+    /// Open a JSON-RPC connection for the chain identified by `genesis_hash`.
+    /// Drop the returned connection to disconnect.
+    fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> impl Future<Output = Result<Box<dyn JsonRpcConnection>, GenericError>> + Send;
+}
+
+/// A live JSON-RPC connection to a chain.
+pub trait JsonRpcConnection: Send + Sync {
+    /// Send a JSON-RPC request string.
+    fn send(&self, request: String);
+
+    /// Stream of JSON-RPC response strings.
+    fn responses(&self) -> BoxStream<'static, String>;
+}
+
+/// Decoded session fields a host shell needs to render account UI without
+/// parsing the opaque session blob the core persists through [`SessionStore`].
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct SessionUiInfo {
+    /// Whether a session is currently active. When `false` every other
+    /// field is `None`.
+    pub connected: bool,
+    /// 32-byte sr25519 root public key of the active session.
+    pub public_key: Option<[u8; 32]>,
+    /// Wallet identity account id used for People-chain username lookup.
+    pub identity_account_id: Option<[u8; 32]>,
+    /// Short username from the People-chain identity record.
+    pub lite_username: Option<String>,
+    /// Fully qualified username from the People-chain identity record.
+    pub full_username: Option<String>,
+}
+
+/// Auth/session lifecycle state the core projects for host UI. The core owns
+/// every transition and emits states in order; hosts render the current state
+/// and never derive auth UI from any other signal.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub enum AuthState {
+    /// No active session and no login in progress.
+    #[default]
+    Disconnected,
+    /// A login is in progress: present the pairing deeplink/QR. Leave this
+    /// state only on a subsequent emission (connected, failed, or
+    /// disconnected after cancellation).
+    Pairing {
+        /// Wallet pairing deeplink to render as a QR code or open directly.
+        deeplink: String,
+    },
+    /// A session is active.
+    Connected(SessionUiInfo),
+    /// The last login attempt failed; show the reason and offer a retry.
+    LoginFailed {
+        /// Human-readable failure reason.
+        reason: String,
+    },
+}
+
+/// Host auth UI driven by core-owned [`AuthState`] transitions.
+pub trait AuthPresenter: Send + Sync {
+    /// Observe an auth state change. Emitted only when the state actually
+    /// changes, in transition order. Default is a no-op for hosts that
+    /// render no auth UI.
+    fn auth_state_changed(&self, state: AuthState) {
+        let _ = state;
+    }
+}
+
+/// Host-global opaque session persistence for core-owned SSO state.
+pub trait SessionStore: Send + Sync {
+    /// Read the currently persisted core session blob.
+    fn read_session(&self) -> impl Future<Output = Result<Option<Vec<u8>>, GenericError>> + Send;
+
+    /// Persist the core session blob.
+    fn write_session(
+        &self,
+        value: Vec<u8>,
+    ) -> impl Future<Output = Result<(), GenericError>> + Send;
+
+    /// Clear the persisted core session blob.
+    fn clear_session(&self) -> impl Future<Output = Result<(), GenericError>> + Send;
+
+    /// Emit once immediately, then on future local/cross-runtime changes.
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), GenericError>>;
+}
+
+/// Local user confirmation UI for session-channel operations.
+pub trait UserConfirmation: Send + Sync {
+    /// Confirm a sign-payload request before the core asks the SSO peer.
+    fn confirm_sign_payload(
+        &self,
+        review: Vec<u8>,
+    ) -> impl Future<Output = Result<bool, GenericError>> + Send;
+
+    /// Confirm a sign-raw request before the core asks the SSO peer.
+    fn confirm_sign_raw(
+        &self,
+        review: Vec<u8>,
+    ) -> impl Future<Output = Result<bool, GenericError>> + Send;
+
+    /// Confirm a create-transaction request before the core asks the SSO peer.
+    fn confirm_create_transaction(
+        &self,
+        review: Vec<u8>,
+    ) -> impl Future<Output = Result<bool, GenericError>> + Send;
+
+    /// Confirm a cross-domain account-alias request before the core asks the
+    /// SSO peer.
+    fn confirm_account_alias(
+        &self,
+        review: Vec<u8>,
+    ) -> impl Future<Output = Result<bool, GenericError>> + Send;
+
+    /// Confirm resource allocation before the core asks the SSO peer.
+    fn confirm_resource_allocation(
+        &self,
+        review: Vec<u8>,
+    ) -> impl Future<Output = Result<bool, GenericError>> + Send;
+}
+
+/// Host theme source.
+pub trait ThemeHost: Send + Sync {
+    /// Emits current theme immediately, then future changes.
+    fn subscribe_theme(&self) -> BoxStream<'static, Result<ThemeVariant, GenericError>>;
+}
+
+/// Host preimage backend. The core owns wire mapping and subscription
+/// lifecycle; the host owns the selected backend.
+pub trait PreimageHost: Send + Sync {
+    /// Prompt before submitting a preimage.
+    fn confirm_preimage_submit(
+        &self,
+        size: u64,
+    ) -> impl Future<Output = Result<(), PreimageSubmitError>> + Send;
+
+    /// Submit the preimage and return its key.
+    fn submit_preimage(
+        &self,
+        value: Vec<u8>,
+    ) -> impl Future<Output = Result<Vec<u8>, PreimageSubmitError>> + Send;
+
+    /// Emits current value/miss immediately, then future updates.
+    fn lookup_preimage(
+        &self,
+        key: Vec<u8>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, GenericError>>;
+}
+
+/// Combined platform interface. A host must provide all capability traits.
+pub trait Platform:
+    Navigation
+    + Notifications
+    + Permissions
+    + Features
+    + Storage
+    + ChainProvider
+    + AuthPresenter
+    + SessionStore
+    + UserConfirmation
+    + ThemeHost
+    + PreimageHost
+{
+}
+
+impl<T> Platform for T where
+    T: Navigation
+        + Notifications
+        + Permissions
+        + Features
+        + Storage
+        + ChainProvider
+        + AuthPresenter
+        + SessionStore
+        + UserConfirmation
+        + ThemeHost
+        + PreimageHost
+{
+}
diff --git a/rust/crates/truapi-platform/tests/bounds.rs b/rust/crates/truapi-platform/tests/bounds.rs
new file mode 100644
index 00000000..664a5113
--- /dev/null
+++ b/rust/crates/truapi-platform/tests/bounds.rs
@@ -0,0 +1,85 @@
+//! Compile-time check that the `Platform` super-trait composes its capability
+//! traits with `Send + Sync + 'static` bounds. `Platform` itself is not
+//! object-safe (the capability traits use `async fn` returning
+//! `impl Future`); the runtime consumes implementors via generics, not
+//! `dyn Trait`.
+
+use truapi_platform::{
+    PairingDeeplinkScheme, Platform, RuntimeConfig, RuntimeConfigValidationError,
+};
+
+fn _assert_platform_bounds<T: Platform + Send + Sync + 'static>() {}
+
+fn valid_runtime_config() -> RuntimeConfig {
+    RuntimeConfig {
+        product_label: "dotli".to_string(),
+        product_id: "dotli.dot".to_string(),
+        site_id: "dot.li".to_string(),
+        host_name: "Polkadot Web".to_string(),
+        host_icon: Some("https://dot.li/dotli.png".to_string()),
+        host_version: None,
+        platform_type: None,
+        platform_version: None,
+        people_chain_genesis_hash: [0xa2; 32],
+        pairing_deeplink_scheme: PairingDeeplinkScheme::PolkadotApp,
+    }
+}
+
+#[test]
+fn runtime_config_accepts_https_host_icon() {
+    valid_runtime_config()
+        .validate()
+        .expect("host icon is valid https");
+}
+
+#[test]
+fn runtime_config_rejects_empty_required_fields() {
+    let mut config = valid_runtime_config();
+    config.product_label = " ".to_string();
+    assert_eq!(
+        config.validate(),
+        Err(RuntimeConfigValidationError::EmptyField {
+            field: "product_label"
+        })
+    );
+
+    let mut config = valid_runtime_config();
+    config.product_id = String::new();
+    assert_eq!(
+        config.validate(),
+        Err(RuntimeConfigValidationError::EmptyField {
+            field: "product_id"
+        })
+    );
+
+    let mut config = valid_runtime_config();
+    config.site_id = "\t".to_string();
+    assert_eq!(
+        config.validate(),
+        Err(RuntimeConfigValidationError::EmptyField { field: "site_id" })
+    );
+}
+
+#[test]
+fn runtime_config_rejects_relative_host_icon() {
+    let mut config = valid_runtime_config();
+    config.host_icon = Some("/dotli.png".to_string());
+
+    assert!(matches!(
+        config.validate(),
+        Err(RuntimeConfigValidationError::InvalidHostIcon { .. })
+    ));
+}
+
+#[test]
+fn runtime_config_rejects_non_https_host_icon() {
+    let mut config = valid_runtime_config();
+    config.host_icon = Some("http://localhost:3000/dotli.png".to_string());
+
+    assert_eq!(
+        config.validate(),
+        Err(RuntimeConfigValidationError::InsecureHostIcon {
+            scheme: "http".to_string(),
+        })
+    );
+}
diff --git a/rust/crates/truapi-server/Cargo.toml b/rust/crates/truapi-server/Cargo.toml
new file mode 100644
index 00000000..6f14a817
--- /dev/null
+++ b/rust/crates/truapi-server/Cargo.toml
@@ -0,0 +1,80 @@
+[package]
+name = "truapi-server"
+version = "0.1.0"
+edition.workspace = true
+description = "TrUAPI server runtime: dispatcher, frames, SCALE, streams"
+# MIT for this crate's own code; the smoldot light-client glue under
+# src/smoldot_provider/wasm_*.rs is vendored from subxt-lightclient under
+# Apache-2.0 (see THIRD_PARTY_NOTICES.md and the per-file SPDX headers).
+license = "MIT AND Apache-2.0"
+
+[lib]
+crate-type = ["rlib", "cdylib", "staticlib"]
+
+[features]
+default = []
+ws-bridge = ["dep:tokio", "dep:tokio-tungstenite", "dep:rand"]
+smoldot = ["dep:smoldot-light", "dep:smoldot"]
+
+[dependencies]
+truapi = { path = "../truapi" }
+truapi-platform = { path = "../truapi-platform" }
+async-trait = "0.1"
+derive_more = { version = "2", features = ["display"] }
+futures = "0.3"
+futures-timer = { version = "3", features = ["wasm-bindgen"] }
+parity-scale-codec = { version = "3", features = ["derive"] }
+serde_json = "1"
+thiserror = "1"
+unicode-normalization = "0.1"
+url = "2"
+uniffi = "0.29.4"
+hex = "0.4"
+blake2-rfc = { version = "0.2", default-features = false }
+sp-crypto-hashing = { version = "0.1", default-features = false }
+bs58 = { version = "0.5", default-features = false, features = ["alloc"] }
+schnorrkel = { version = "0.11.5", default-features = false, features = ["alloc", "getrandom"] }
+getrandom = { version = "0.2", features = ["js"] }
+p256 = { version = "0.13", default-features = false, features = ["ecdh"] }
+hkdf = "0.12"
+sha2 = "0.10"
+aes-gcm = { version = "0.10", default-features = false, features = ["aes", "alloc"] }
+tracing = "0.1"
+# `registry` + `std` only: pulls the Registry + per-layer filter/reload, but
+# not `env-filter` (which drags in `regex`, heavy on wasm).
+tracing-subscriber = { version = "0.3", default-features = false, features = ["registry", "std"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+smoldot-light = { version = "1.1.0", optional = true }
+smoldot = { version = "1.1.0", optional = true }
+tokio = { version = "1", features = ["rt-multi-thread", "net", "sync", "macros", "io-util"], optional = true }
+tokio-tungstenite = { version = "0.21", default-features = false, features = ["handshake"], optional = true }
+rand = { version = "0.8", optional = true }
+futures = { version = "0.3", features = ["thread-pool"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+js-sys = "0.3"
+wasm-bindgen = "0.2.118"
+wasm-bindgen-futures = "0.4"
+console_error_panic_hook = "0.1"
+smoldot-light = { version = "1.1.0", optional = true, default-features = false }
+smoldot = { version = "1.1.0", optional = true, default-features = false, features = ["std"] }
+futures-util = "0.3"
+pin-project = "1"
+send_wrapper = { version = "0.6", features = ["futures"] }
+web-time = "1"
+web-sys = { version = "0.3", features = [
+    "BinaryType",
+    "CloseEvent",
+    "console",
+    "Event",
+    "MessageEvent",
+    "WebSocket",
+] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+tokio = { version = "1", features = ["rt-multi-thread", "net", "sync", "macros", "io-util", "time"] }
+tokio-tungstenite = { version = "0.21", default-features = false, features = ["connect"] }
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wasm-bindgen-test = "0.3"
diff --git a/rust/crates/truapi-server/README.md b/rust/crates/truapi-server/README.md
new file mode 100644
index 00000000..181464f4
--- /dev/null
+++ b/rust/crates/truapi-server/README.md
@@ -0,0 +1,33 @@
+# truapi-server
+
+*Runtime core for TrUAPI: dispatcher, protocol frames, SCALE-coded wire envelope.*
+
+## What this crate is for
+
+`truapi-server` is the runtime that turns trait implementations of the
+`truapi` API into a working host. It owns:
+
+- the [`ProtocolMessage`] wire envelope and SCALE codec
+- the [`Dispatcher`] that routes incoming frames to per-method handlers
+- the subscription lifecycle (start/receive/stop/interrupt)
+- the [`Transport`] trait that platform-specific IPC backends implement
+- the auto-generated dispatcher/wire-table tables shipped under
+  [`crate::generated`]
+
+## Wire envelope
+
+Every frame on the wire is encoded as:
+
+```text
+[requestId: SCALE str][discriminant: u8][payload bytes...]
+```
+
+The discriminant identifies a method + frame kind via the auto-generated
+[`crate::generated::wire_table::WIRE_TABLE`]. Each method's ids are exposed
+as a named const (`PREIMAGE_SUBMIT`, ...); both `WIRE_TABLE` and the generated
+dispatcher reference those consts. Method ordering is part of the wire
+protocol; only ever append.
+
+The payload bytes are the SCALE-encoded inner value, inlined without a
+length prefix. The discriminant is carried directly as `Payload::id`, and the
+dispatcher routes on that numeric id via id-keyed tables.
diff --git a/rust/crates/truapi-server/THIRD_PARTY_NOTICES.md b/rust/crates/truapi-server/THIRD_PARTY_NOTICES.md
new file mode 100644
index 00000000..3b96ace0
--- /dev/null
+++ b/rust/crates/truapi-server/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,33 @@
+# Third-party notices
+
+`truapi-server` is MIT-licensed except for the vendored sources listed below,
+which are redistributed under their own terms.
+
+## subxt-lightclient
+
+Files:
+
+- `src/smoldot_provider/wasm_socket.rs`
+- `src/smoldot_provider/wasm_platform.rs`
+- `src/smoldot_provider/wasm_helpers.rs`
+
+Vendored from [`subxt-lightclient`](https://github.com/paritytech/subxt) v0.50.0,
+available under `Apache-2.0 OR GPL-3.0`. These files are redistributed under the
+**Apache License 2.0**, whose attribution requirements (§4) are satisfied by
+this notice and the per-file `SPDX-License-Identifier: Apache-2.0` headers.
+
+```
+Copyright Parity Technologies (UK) Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use these files 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/rust/crates/truapi-server/src/chain_runtime.rs b/rust/crates/truapi-server/src/chain_runtime.rs
new file mode 100644
index 00000000..fc4a8487
--- /dev/null
+++ b/rust/crates/truapi-server/src/chain_runtime.rs
@@ -0,0 +1,1771 @@
+//! ChainHead v1 state machine used by `PlatformRuntimeHost`.
+//!
+//! [`ChainRuntime`] keeps one [`ChainConnection`] per chain (keyed by genesis
+//! hash) on top of the platform-provided [`JsonRpcConnection`]. Each connection
+//! owns the per-product `chainHead_v1_follow` subscriptions, the in-flight
+//! request map, and the json-rpc response loop. The follow event stream is
+//! parsed into v01 [`RemoteChainHeadFollowItem`] values; one-shot calls
+//! (header / body / call / storage / spec / broadcast / stop) are submitted as
+//! json-rpc requests and the matching response is decoded back into a typed
+//! v01 result.
+//!
+//! The chain-side traits return [`RuntimeFailure`], a local classification
+//! that the [`crate::runtime`] layer maps to [`truapi::CallError`] variants
+//! (`Unsupported`, `HostFailure`, ...). This avoids leaking json-rpc plumbing
+//! into the public API.
+
+use std::collections::HashMap;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::task::{Context, Poll};
+
+use futures::FutureExt;
+use futures::channel::{mpsc, oneshot};
+use futures::future::{BoxFuture, Shared};
+use futures::stream::BoxStream;
+use futures::{Stream, StreamExt};
+use serde_json::{Map, Value, json};
+use tracing::instrument;
+use truapi::v01::{
+    OperationStartedResult, RemoteChainHeadBodyRequest, RemoteChainHeadBodyResponse,
+    RemoteChainHeadCallRequest, RemoteChainHeadCallResponse, RemoteChainHeadContinueRequest,
+    RemoteChainHeadFollowItem, RemoteChainHeadFollowRequest, RemoteChainHeadHeaderRequest,
+    RemoteChainHeadHeaderResponse, RemoteChainHeadStopOperationRequest,
+    RemoteChainHeadStorageRequest, RemoteChainHeadStorageResponse, RemoteChainHeadUnpinRequest,
+    RemoteChainSpecChainNameResponse, RemoteChainSpecGenesisHashResponse,
+    RemoteChainSpecPropertiesResponse, RemoteChainTransactionBroadcastRequest,
+    RemoteChainTransactionBroadcastResponse, RemoteChainTransactionStopRequest, RuntimeApi,
+    RuntimeSpec, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem,
+};
+use truapi_platform::JsonRpcConnection;
+
+use crate::subscription::Spawner;
+
+const FOLLOW_METHOD: &str = "remote_chain_head_follow";
+
+/// Cap on the number of distinct remote subscription ids buffered in
+/// `pending_follow_events`, and on the events held per id, so a misbehaving
+/// node (or late events for a retired remote id) cannot grow memory without
+/// bound while a follow id is being established.
+const MAX_PENDING_FOLLOW_EVENT_IDS: usize = 64;
+const MAX_PENDING_FOLLOW_EVENTS_PER_ID: usize = 256;
+
+/// Shared, single-flight `chainHead_v1_follow` setup keyed by local follow id.
+/// Concurrent callers for the same id await one in-flight request rather than
+/// each opening (and leaking) a separate remote subscription.
+type FollowSetup = Shared<BoxFuture<'static, Result<String, RuntimeFailure>>>;
+
+/// Shared, single-flight provider connect keyed by genesis hash. Concurrent
+/// first connections for the same chain await one in-flight `connect` rather
+/// than each opening a connection and orphaning all but the last insert.
+type ConnectionSetup = Shared<BoxFuture<'static, Result<Arc<ChainConnection>, RuntimeFailure>>>;
+
+/// Classification of framework-level chain failures separate from JSON-RPC
+/// domain errors. Maps cleanly to [`truapi::CallError`] variants at the
+/// `PlatformRuntimeHost` boundary.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RuntimeFailureKind {
+    /// Backend is not wired or refused the request for plumbing reasons.
+    Unavailable,
+    /// Backend responded but the payload was malformed or the call failed.
+    HostFailure,
+}
+
+/// Framework-level chain failure with a diagnostic reason.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RuntimeFailure {
+    kind: RuntimeFailureKind,
+    method: &'static str,
+    reason: Option<String>,
+}
+
+impl RuntimeFailure {
+    /// Backend refused the call for unavailability reasons (no provider, the
+    /// connection died, etc.).
+    pub fn unavailable(method: &'static str) -> Self {
+        Self {
+            kind: RuntimeFailureKind::Unavailable,
+            method,
+            reason: None,
+        }
+    }
+
+    /// Backend produced a structural error (malformed json-rpc, unexpected
+    /// shape, ...).
+    pub fn host_failure(method: &'static str, reason: impl Into<String>) -> Self {
+        Self {
+            kind: RuntimeFailureKind::HostFailure,
+            method,
+            reason: Some(reason.into()),
+        }
+    }
+
+    /// Failure classification.
+    pub fn kind(&self) -> RuntimeFailureKind {
+        self.kind
+    }
+
+    /// Method tag the failure originated from.
+    pub fn method(&self) -> &'static str {
+        self.method
+    }
+
+    /// Diagnostic reason. Always non-empty for `HostFailure`.
+    pub fn reason(&self) -> String {
+        match &self.reason {
+            Some(reason) => format!("{}: {}", self.method, reason),
+            None => self.method.to_string(),
+        }
+    }
+}
+
+/// Provider of `JsonRpcConnection` instances keyed by chain genesis hash.
+/// The default [`UnavailableChainProvider`] makes every call fail; real
+/// hosts plug in either the platform-side `ChainProvider` or the bundled
+/// smoldot provider (feature `smoldot`).
+#[async_trait::async_trait]
+pub trait RuntimeChainProvider: Send + Sync {
+    /// Open or reuse a JSON-RPC connection for the chain identified by
+    /// `genesis_hash`.
+    async fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure>;
+}
+
+/// Default provider: every `connect` call fails with `Unavailable`, so each
+/// chain RPC surfaces a typed "unavailable" error to the product.
+#[derive(Default)]
+pub struct UnavailableChainProvider;
+
+#[async_trait::async_trait]
+impl RuntimeChainProvider for UnavailableChainProvider {
+    async fn connect(
+        &self,
+        _genesis_hash: Vec<u8>,
+    ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure> {
+        Err(RuntimeFailure::unavailable("remote_chain_connect"))
+    }
+}
+
+/// chainHead-v1 state machine on top of a [`RuntimeChainProvider`].
+///
+/// Each method maps a typed v01 chain request to one or more json-rpc calls,
+/// shares one `chainHead_v1_follow` subscription per (genesis_hash, local
+/// follow id) pair, and parses follow events back into typed
+/// [`RemoteChainHeadFollowItem`] values.
+#[derive(Clone)]
+pub struct ChainRuntime {
+    provider: Arc<dyn RuntimeChainProvider>,
+    spawner: Spawner,
+    connections: Arc<Mutex<HashMap<String, Arc<ChainConnection>>>>,
+    connection_setups: Arc<Mutex<HashMap<String, ConnectionSetup>>>,
+}
+
+impl ChainRuntime {
+    /// Build a `ChainRuntime` driven by `provider`. Background tasks (response
+    /// pumps, follow setup) are spawned on `spawner`.
+    pub fn new(provider: Arc<dyn RuntimeChainProvider>, spawner: Spawner) -> Self {
+        Self {
+            provider,
+            spawner,
+            connections: Arc::new(Mutex::new(HashMap::new())),
+            connection_setups: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    /// Start (or attach to an existing) `chainHead_v1_follow` subscription.
+    /// Returns a stream of typed follow items that closes when the remote
+    /// sends `stop` or the connection drops.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.follow"))]
+    pub fn remote_chain_head_follow(
+        &self,
+        follow_subscription_id: String,
+        request: RemoteChainHeadFollowRequest,
+    ) -> BoxStream<'static, RemoteChainHeadFollowItem> {
+        let (tx, rx) = mpsc::unbounded();
+        let runtime = self.clone();
+        let cleanup_runtime = self.clone();
+        let cleanup_genesis_hash = request.genesis_hash.clone();
+        let cleanup_follow_id = follow_subscription_id.clone();
+
+        let fut = async move {
+            if runtime
+                .start_follow(follow_subscription_id, request, Some(tx.clone()))
+                .await
+                .is_err()
+            {
+                let _ = tx.unbounded_send(FollowSignal::Interrupt);
+            }
+        };
+        (self.spawner)(fut.boxed());
+
+        let stream = ManagedSubscription::new(
+            rx.boxed(),
+            Some(Box::new(move || {
+                cleanup_runtime.cleanup_follow(&cleanup_genesis_hash, &cleanup_follow_id);
+            })),
+        );
+        stream
+            .filter_map(|signal| async move {
+                match signal {
+                    FollowSignal::Item(item) => Some(item),
+                    FollowSignal::Interrupt => None,
+                }
+            })
+            .boxed()
+    }
+
+    /// Fetch a block header.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.header"))]
+    pub async fn remote_chain_head_header(
+        &self,
+        request: RemoteChainHeadHeaderRequest,
+    ) -> Result<RemoteChainHeadHeaderResponse, RuntimeFailure> {
+        let method = "remote_chain_head_header";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_header",
+                json!([remote_follow_id, encode_hex(&request.hash)]),
+            )
+            .await?;
+        let header = match value {
+            Value::Null => None,
+            Value::String(encoded) => Some(
+                decode_hex(&encoded)
+                    .map_err(|reason| RuntimeFailure::host_failure(method, reason))?,
+            ),
+            _ => {
+                return Err(RuntimeFailure::host_failure(
+                    method,
+                    "unexpected chainHead_v1_header result",
+                ));
+            }
+        };
+        Ok(RemoteChainHeadHeaderResponse { header })
+    }
+
+    /// Start a chainHead_v1_body operation.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.body"))]
+    pub async fn remote_chain_head_body(
+        &self,
+        request: RemoteChainHeadBodyRequest,
+    ) -> Result<RemoteChainHeadBodyResponse, RuntimeFailure> {
+        let method = "remote_chain_head_body";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_body",
+                json!([remote_follow_id, encode_hex(&request.hash)]),
+            )
+            .await?;
+        let operation = operation_started_result(method, value)?;
+        Ok(RemoteChainHeadBodyResponse { operation })
+    }
+
+    /// Start a chainHead_v1_storage operation.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.storage"))]
+    pub async fn remote_chain_head_storage(
+        &self,
+        request: RemoteChainHeadStorageRequest,
+    ) -> Result<RemoteChainHeadStorageResponse, RuntimeFailure> {
+        let method = "remote_chain_head_storage";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+
+        let items = request
+            .items
+            .iter()
+            .map(encode_storage_query_item)
+            .collect::<Vec<_>>();
+        let child_trie = request
+            .child_trie
+            .as_ref()
+            .map(|bytes| Value::String(encode_hex(bytes)))
+            .unwrap_or(Value::Null);
+
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_storage",
+                json!([
+                    remote_follow_id,
+                    encode_hex(&request.hash),
+                    Value::Array(items),
+                    child_trie,
+                ]),
+            )
+            .await?;
+        let operation = operation_started_result(method, value)?;
+        Ok(RemoteChainHeadStorageResponse { operation })
+    }
+
+    /// Start a chainHead_v1_call operation.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.call"))]
+    pub async fn remote_chain_head_call(
+        &self,
+        request: RemoteChainHeadCallRequest,
+    ) -> Result<RemoteChainHeadCallResponse, RuntimeFailure> {
+        let method = "remote_chain_head_call";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, true)
+            .await?;
+
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_call",
+                json!([
+                    remote_follow_id,
+                    encode_hex(&request.hash),
+                    request.function,
+                    encode_hex(&request.call_parameters),
+                ]),
+            )
+            .await?;
+        let operation = operation_started_result(method, value)?;
+        Ok(RemoteChainHeadCallResponse { operation })
+    }
+
+    /// Release pinned blocks.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.unpin"))]
+    pub async fn remote_chain_head_unpin(
+        &self,
+        request: RemoteChainHeadUnpinRequest,
+    ) -> Result<(), RuntimeFailure> {
+        let method = "remote_chain_head_unpin";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+        let hashes: Vec<Value> = request
+            .hashes
+            .iter()
+            .map(|hash| Value::String(encode_hex(hash)))
+            .collect();
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_unpin",
+                json!([remote_follow_id, Value::Array(hashes)]),
+            )
+            .await?;
+        match value {
+            Value::Null => Ok(()),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected chainHead_v1_unpin result",
+            )),
+        }
+    }
+
+    /// Continue a paused operation.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.continue"))]
+    pub async fn remote_chain_head_continue(
+        &self,
+        request: RemoteChainHeadContinueRequest,
+    ) -> Result<(), RuntimeFailure> {
+        let method = "remote_chain_head_continue";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_continue",
+                json!([remote_follow_id, request.operation_id]),
+            )
+            .await?;
+        match value {
+            Value::Null => Ok(()),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected chainHead_v1_continue result",
+            )),
+        }
+    }
+
+    /// Stop a chain-head operation.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.stop_operation"))]
+    pub async fn remote_chain_head_stop_operation(
+        &self,
+        request: RemoteChainHeadStopOperationRequest,
+    ) -> Result<(), RuntimeFailure> {
+        let method = "remote_chain_head_stop_operation";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let remote_follow_id = self
+            .ensure_follow_context(method, &connection, request.follow_subscription_id, false)
+            .await?;
+        let value = connection
+            .request_value(
+                method,
+                "chainHead_v1_stopOperation",
+                json!([remote_follow_id, request.operation_id]),
+            )
+            .await?;
+        match value {
+            Value::Null => Ok(()),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected chainHead_v1_stopOperation result",
+            )),
+        }
+    }
+
+    /// Echo back the chain genesis hash via chainSpec_v1_genesisHash.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.spec_genesis_hash"))]
+    pub async fn remote_chain_spec_genesis_hash(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<RemoteChainSpecGenesisHashResponse, RuntimeFailure> {
+        let method = "remote_chain_spec_genesis_hash";
+        let connection = self.connection_for(method, &genesis_hash).await?;
+        let value = connection
+            .request_value(method, "chainSpec_v1_genesisHash", json!([]))
+            .await?;
+        match value {
+            Value::String(encoded) => {
+                let bytes = decode_hex(&encoded)
+                    .map_err(|reason| RuntimeFailure::host_failure(method, reason))?;
+                Ok(RemoteChainSpecGenesisHashResponse {
+                    genesis_hash: bytes,
+                })
+            }
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected chainSpec_v1_genesisHash result",
+            )),
+        }
+    }
+
+    /// Fetch the chain display name via chainSpec_v1_chainName.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.spec_chain_name"))]
+    pub async fn remote_chain_spec_chain_name(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<RemoteChainSpecChainNameResponse, RuntimeFailure> {
+        let method = "remote_chain_spec_chain_name";
+        let connection = self.connection_for(method, &genesis_hash).await?;
+        let value = connection
+            .request_value(method, "chainSpec_v1_chainName", json!([]))
+            .await?;
+        match value {
+            Value::String(name) => Ok(RemoteChainSpecChainNameResponse { chain_name: name }),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected chainSpec_v1_chainName result",
+            )),
+        }
+    }
+
+    /// Fetch the chain JSON properties via chainSpec_v1_properties.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.spec_properties"))]
+    pub async fn remote_chain_spec_properties(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<RemoteChainSpecPropertiesResponse, RuntimeFailure> {
+        let method = "remote_chain_spec_properties";
+        let connection = self.connection_for(method, &genesis_hash).await?;
+        let value = connection
+            .request_value(method, "chainSpec_v1_properties", json!([]))
+            .await?;
+        let properties = serde_json::to_string(&value)
+            .map_err(|err| RuntimeFailure::host_failure(method, err.to_string()))?;
+        Ok(RemoteChainSpecPropertiesResponse { properties })
+    }
+
+    /// Broadcast a signed transaction via transaction_v1_broadcast.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.transaction_broadcast"))]
+    pub async fn remote_chain_transaction_broadcast(
+        &self,
+        request: RemoteChainTransactionBroadcastRequest,
+    ) -> Result<RemoteChainTransactionBroadcastResponse, RuntimeFailure> {
+        let method = "remote_chain_transaction_broadcast";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let value = connection
+            .request_value(
+                method,
+                "transaction_v1_broadcast",
+                json!([encode_hex(&request.transaction)]),
+            )
+            .await?;
+        match value {
+            Value::Null => Ok(RemoteChainTransactionBroadcastResponse { operation_id: None }),
+            Value::String(operation_id) => Ok(RemoteChainTransactionBroadcastResponse {
+                operation_id: Some(operation_id),
+            }),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected transaction_v1_broadcast result",
+            )),
+        }
+    }
+
+    /// Stop a transaction broadcast via transaction_v1_stop.
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.transaction_stop"))]
+    pub async fn remote_chain_transaction_stop(
+        &self,
+        request: RemoteChainTransactionStopRequest,
+    ) -> Result<(), RuntimeFailure> {
+        let method = "remote_chain_transaction_stop";
+        let connection = self.connection_for(method, &request.genesis_hash).await?;
+        let value = connection
+            .request_value(method, "transaction_v1_stop", json!([request.operation_id]))
+            .await?;
+        match value {
+            Value::Null => Ok(()),
+            _ => Err(RuntimeFailure::host_failure(
+                method,
+                "unexpected transaction_v1_stop result",
+            )),
+        }
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.connection_for", method = method))]
+    async fn connection_for(
+        &self,
+        method: &'static str,
+        genesis_hash: &[u8],
+    ) -> Result<Arc<ChainConnection>, RuntimeFailure> {
+        let key = encode_hex(genesis_hash);
+        let setup = {
+            let mut connections = self.connections.lock().unwrap();
+            match connections.get(&key) {
+                Some(connection) if !connection.is_closed() => return Ok(connection.clone()),
+                Some(_) => {
+                    connections.remove(&key);
+                }
+                None => {}
+            }
+            // Single-flight the provider connect (same shape as
+            // `follow_setups`): concurrent first connections for the same
+            // chain share one in-flight `connect` instead of racing the
+            // insert and orphaning the loser's connection.
+            let mut setups = self.connection_setups.lock().unwrap();
+            if let Some(existing) = setups.get(&key) {
+                existing.clone()
+            } else {
+                let provider = self.provider.clone();
+                let spawner = self.spawner.clone();
+                let connections = self.connections.clone();
+                let setups_map = self.connection_setups.clone();
+                let setup_key = key.clone();
+                let genesis_hash = genesis_hash.to_owned();
+                let setup: ConnectionSetup = async move {
+                    let result = provider.connect(genesis_hash).await.map(|rpc| {
+                        let connection = ChainConnection::new(rpc, spawner);
+                        connections
+                            .lock()
+                            .unwrap()
+                            .insert(setup_key.clone(), connection.clone());
+                        connection
+                    });
+                    setups_map.lock().unwrap().remove(&setup_key);
+                    result
+                }
+                .boxed()
+                .shared();
+                setups.insert(key, setup.clone());
+                setup
+            }
+        };
+
+        setup.await.map_err(|failure| match failure.kind() {
+            RuntimeFailureKind::Unavailable => RuntimeFailure::unavailable(method),
+            RuntimeFailureKind::HostFailure => {
+                RuntimeFailure::host_failure(method, failure.reason())
+            }
+        })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.start_follow"))]
+    async fn start_follow(
+        &self,
+        local_follow_id: String,
+        request: RemoteChainHeadFollowRequest,
+        sender: Option<mpsc::UnboundedSender<FollowSignal>>,
+    ) -> Result<(), RuntimeFailure> {
+        let connection = self
+            .connection_for(FOLLOW_METHOD, &request.genesis_hash)
+            .await?;
+        // Record this subscriber's sender before kicking off (or joining) the
+        // single-flight setup so events route to it regardless of which caller
+        // wins the setup.
+        connection.register_follow_intent(&local_follow_id, request.with_runtime, sender);
+        connection
+            .ensure_remote_follow(local_follow_id, request.with_runtime)
+            .await?;
+        Ok(())
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.ensure_follow_context", method = method))]
+    async fn ensure_follow_context(
+        &self,
+        method: &'static str,
+        connection: &Arc<ChainConnection>,
+        local_follow_id: String,
+        with_runtime: bool,
+    ) -> Result<String, RuntimeFailure> {
+        let remote_follow_id = connection
+            .ensure_remote_follow(local_follow_id.clone(), with_runtime)
+            .await?;
+        if with_runtime && !connection.follow_with_runtime(&local_follow_id) {
+            return Err(RuntimeFailure::host_failure(
+                method,
+                "follow subscription was created without runtime metadata",
+            ));
+        }
+        Ok(remote_follow_id)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain_runtime.cleanup_follow"))]
+    fn cleanup_follow(&self, genesis_hash: &[u8], local_follow_id: &str) {
+        let key = encode_hex(genesis_hash);
+        let Some(connection) = self.connections.lock().unwrap().get(&key).cloned() else {
+            return;
+        };
+        connection.unfollow(local_follow_id);
+    }
+}
+
+/// One delivery on the local follow stream. `Interrupt` signals an
+/// abnormal close (connection dropped, follow setup failed); it produces no
+/// item but ends the stream.
+enum FollowSignal {
+    Item(RemoteChainHeadFollowItem),
+    Interrupt,
+}
+
+struct ChainConnection {
+    rpc: Arc<dyn JsonRpcConnection>,
+    request_ids: AtomicU64,
+    closed: AtomicBool,
+    follows: Mutex<HashMap<String, FollowState>>,
+    follows_by_remote: Mutex<HashMap<String, String>>,
+    pending_follow_events: Mutex<HashMap<String, Vec<RemoteChainHeadFollowItem>>>,
+    follow_setups: Mutex<HashMap<String, FollowSetup>>,
+    requests: Mutex<HashMap<String, PendingRequest>>,
+}
+
+impl ChainConnection {
+    fn new(rpc: Arc<dyn JsonRpcConnection>, spawner: Spawner) -> Arc<Self> {
+        let connection = Arc::new(Self {
+            rpc,
+            request_ids: AtomicU64::new(1),
+            closed: AtomicBool::new(false),
+            follows: Mutex::new(HashMap::new()),
+            follows_by_remote: Mutex::new(HashMap::new()),
+            pending_follow_events: Mutex::new(HashMap::new()),
+            follow_setups: Mutex::new(HashMap::new()),
+            requests: Mutex::new(HashMap::new()),
+        });
+        connection.clone().spawn_response_loop(spawner);
+        connection
+    }
+
+    fn spawn_response_loop(self: Arc<Self>, spawner: Spawner) {
+        let rpc = self.rpc.clone();
+        let fut = async move {
+            let mut responses = rpc.responses();
+            while let Some(response) = responses.next().await {
+                if let Err(failure) = self.handle_response(&response) {
+                    self.close_with_failure(failure);
+                    return;
+                }
+            }
+            self.close_with_failure(RuntimeFailure::unavailable(FOLLOW_METHOD));
+        };
+        (spawner)(fut.boxed());
+    }
+
+    fn is_closed(&self) -> bool {
+        self.closed.load(Ordering::Relaxed)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain_connection.request_value", method = method, rpc_method = rpc_method))]
+    async fn request_value(
+        &self,
+        method: &'static str,
+        rpc_method: &'static str,
+        params: Value,
+    ) -> Result<Value, RuntimeFailure> {
+        let request_id = format!(
+            "truapi:{}",
+            self.request_ids.fetch_add(1, Ordering::Relaxed)
+        );
+        let (tx, rx) = oneshot::channel();
+        {
+            // Check `closed` and insert under the same lock `close_with_failure`
+            // takes, so the connection cannot drain the request map between the
+            // check and the insert and leave this request to hang forever.
+            let mut requests = self.requests.lock().unwrap();
+            if self.is_closed() {
+                return Err(RuntimeFailure::unavailable(method));
+            }
+            requests.insert(request_id.clone(), PendingRequest { method, tx });
+        }
+        self.rpc.send(
+            json!({
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "method": rpc_method,
+                "params": params,
+            })
+            .to_string(),
+        );
+
+        match rx.await {
+            Ok(result) => result,
+            Err(_) => Err(RuntimeFailure::unavailable(method)),
+        }
+    }
+
+    fn follow_with_runtime(&self, local_follow_id: &str) -> bool {
+        self.follows
+            .lock()
+            .unwrap()
+            .get(local_follow_id)
+            .map(|follow| follow.with_runtime)
+            .unwrap_or(false)
+    }
+
+    fn remote_follow_id(&self, local_follow_id: &str) -> Option<String> {
+        self.follows
+            .lock()
+            .unwrap()
+            .get(local_follow_id)
+            .and_then(|follow| follow.remote_follow_id.clone())
+    }
+
+    /// Record intent to follow `local_follow_id`, attaching `sender` for a
+    /// follow subscriber. Idempotent: an existing follow keeps its
+    /// `with_runtime` flag and remote id; only the sender is (re)attached.
+    fn register_follow_intent(
+        &self,
+        local_follow_id: &str,
+        with_runtime: bool,
+        sender: Option<mpsc::UnboundedSender<FollowSignal>>,
+    ) {
+        let mut follows = self.follows.lock().unwrap();
+        match follows.get_mut(local_follow_id) {
+            Some(follow) => {
+                if sender.is_some() {
+                    follow.sender = sender;
+                }
+            }
+            None => {
+                follows.insert(
+                    local_follow_id.to_string(),
+                    FollowState {
+                        with_runtime,
+                        remote_follow_id: None,
+                        sender,
+                    },
+                );
+            }
+        }
+    }
+
+    /// Issue `chainHead_v1_follow` exactly once per local follow id and return
+    /// the remote subscription id. Concurrent callers for the same id share
+    /// one in-flight setup instead of each opening a duplicate remote
+    /// subscription that would then leak.
+    #[instrument(skip_all, fields(runtime.method = "chain_connection.ensure_remote_follow"))]
+    async fn ensure_remote_follow(
+        self: &Arc<Self>,
+        local_follow_id: String,
+        with_runtime: bool,
+    ) -> Result<String, RuntimeFailure> {
+        if let Some(remote_follow_id) = self.remote_follow_id(&local_follow_id) {
+            return Ok(remote_follow_id);
+        }
+
+        let setup = {
+            let mut setups = self.follow_setups.lock().unwrap();
+            if let Some(existing) = setups.get(&local_follow_id) {
+                existing.clone()
+            } else {
+                let connection = self.clone();
+                let id = local_follow_id.clone();
+                let setup: FollowSetup =
+                    async move { connection.run_follow_setup(id, with_runtime).await }
+                        .boxed()
+                        .shared();
+                setups.insert(local_follow_id.clone(), setup.clone());
+                setup
+            }
+        };
+
+        let result = setup.await;
+        // On failure, drop the cached setup so a later re-subscribe can retry.
+        // On success the established follow short-circuits the fast path above,
+        // and `remove_follow` clears the entry at teardown.
+        if result.is_err() {
+            self.follow_setups.lock().unwrap().remove(&local_follow_id);
+        }
+        result
+    }
+
+    /// Body of the single-flight follow setup: ensure the `FollowState`
+    /// exists, issue `chainHead_v1_follow`, and record the remote id.
+    #[instrument(skip_all, fields(runtime.method = "chain_connection.run_follow_setup"))]
+    async fn run_follow_setup(
+        self: Arc<Self>,
+        local_follow_id: String,
+        with_runtime: bool,
+    ) -> Result<String, RuntimeFailure> {
+        self.follows
+            .lock()
+            .unwrap()
+            .entry(local_follow_id.clone())
+            .or_insert_with(|| FollowState {
+                with_runtime,
+                remote_follow_id: None,
+                sender: None,
+            });
+
+        let remote_follow_id = match self
+            .request_value(FOLLOW_METHOD, "chainHead_v1_follow", json!([with_runtime]))
+            .await
+        {
+            Ok(Value::String(value)) => value,
+            Ok(_) => {
+                self.remove_follow(&local_follow_id);
+                return Err(RuntimeFailure::host_failure(
+                    FOLLOW_METHOD,
+                    "unexpected chainHead_v1_follow result",
+                ));
+            }
+            Err(failure) => {
+                self.remove_follow(&local_follow_id);
+                return Err(failure);
+            }
+        };
+
+        self.set_remote_follow_id(&local_follow_id, remote_follow_id.clone());
+        Ok(remote_follow_id)
+    }
+
+    fn set_remote_follow_id(&self, local_follow_id: &str, remote_follow_id: String) {
+        let attached = {
+            let mut follows = self.follows.lock().unwrap();
+            if let Some(follow) = follows.get_mut(local_follow_id) {
+                follow.remote_follow_id = Some(remote_follow_id.clone());
+                self.follows_by_remote
+                    .lock()
+                    .unwrap()
+                    .insert(remote_follow_id.clone(), local_follow_id.to_string());
+                true
+            } else {
+                false
+            }
+        };
+        if !attached {
+            // The local follow was torn down (stream dropped, connection
+            // closed) while `chainHead_v1_follow` was in flight. Release the
+            // now-orphaned remote subscription rather than leaking it on the
+            // node, and drop any events buffered for it.
+            self.send_unfollow(&remote_follow_id);
+            self.pending_follow_events
+                .lock()
+                .unwrap()
+                .remove(&remote_follow_id);
+            return;
+        }
+        let buffered = self
+            .pending_follow_events
+            .lock()
+            .unwrap()
+            .remove(&remote_follow_id)
+            .unwrap_or_default();
+        for event in buffered {
+            self.deliver_follow_event(local_follow_id, event);
+        }
+    }
+
+    fn remove_follow(&self, local_follow_id: &str) {
+        self.follow_setups.lock().unwrap().remove(local_follow_id);
+        if let Some(follow) = self.follows.lock().unwrap().remove(local_follow_id)
+            && let Some(remote_follow_id) = follow.remote_follow_id
+        {
+            self.follows_by_remote
+                .lock()
+                .unwrap()
+                .remove(&remote_follow_id);
+        }
+    }
+
+    fn unfollow(&self, local_follow_id: &str) {
+        let remote_follow_id = self.remote_follow_id(local_follow_id);
+        self.remove_follow(local_follow_id);
+        let Some(remote_follow_id) = remote_follow_id else {
+            return;
+        };
+        self.send_unfollow(&remote_follow_id);
+    }
+
+    /// Send a `chainHead_v1_unfollow` for `remote_follow_id`. Best-effort: a
+    /// closed connection simply drops the request.
+    fn send_unfollow(&self, remote_follow_id: &str) {
+        self.rpc.send(
+            json!({
+                "jsonrpc": "2.0",
+                "id": format!("truapi:{}", self.request_ids.fetch_add(1, Ordering::Relaxed)),
+                "method": "chainHead_v1_unfollow",
+                "params": [remote_follow_id],
+            })
+            .to_string(),
+        );
+    }
+
+    fn handle_response(&self, response: &str) -> Result<(), RuntimeFailure> {
+        let value: Value = serde_json::from_str(response).map_err(|error| {
+            RuntimeFailure::host_failure(FOLLOW_METHOD, format!("invalid json-rpc frame: {error}"))
+        })?;
+
+        if value.get("method") == Some(&Value::String("chainHead_v1_followEvent".to_string())) {
+            return self.handle_follow_notification(&value);
+        }
+
+        let Some(request_id) = value.get("id").and_then(json_id) else {
+            return Ok(());
+        };
+        let Some(pending) = self.requests.lock().unwrap().remove(&request_id) else {
+            return Ok(());
+        };
+
+        if let Some(result) = value.get("result") {
+            let _ = pending.tx.send(Ok(result.clone()));
+            return Ok(());
+        }
+
+        if let Some(error) = value.get("error") {
+            let reason = error
+                .get("message")
+                .and_then(Value::as_str)
+                .unwrap_or("json-rpc error")
+                .to_string();
+            let _ = pending
+                .tx
+                .send(Err(RuntimeFailure::host_failure(pending.method, reason)));
+            return Ok(());
+        }
+
+        let _ = pending.tx.send(Err(RuntimeFailure::host_failure(
+            pending.method,
+            "json-rpc response missing result and error",
+        )));
+        Ok(())
+    }
+
+    fn handle_follow_notification(&self, value: &Value) -> Result<(), RuntimeFailure> {
+        let params = value
+            .get("params")
+            .and_then(Value::as_object)
+            .ok_or_else(|| {
+                RuntimeFailure::host_failure(
+                    FOLLOW_METHOD,
+                    "missing chainHead_v1_followEvent params",
+                )
+            })?;
+        let remote_follow_id = params
+            .get("subscription")
+            .and_then(Value::as_str)
+            .ok_or_else(|| {
+                RuntimeFailure::host_failure(
+                    FOLLOW_METHOD,
+                    "missing chainHead_v1_followEvent subscription",
+                )
+            })?;
+        let event = parse_follow_event(params.get("result").ok_or_else(|| {
+            RuntimeFailure::host_failure(FOLLOW_METHOD, "missing chainHead_v1_followEvent result")
+        })?)?;
+        let local_follow_id = self
+            .follows_by_remote
+            .lock()
+            .unwrap()
+            .get(remote_follow_id)
+            .cloned();
+        match local_follow_id {
+            Some(local_follow_id) => self.deliver_follow_event(&local_follow_id, event),
+            None => {
+                let mut pending = self.pending_follow_events.lock().unwrap();
+                // Bound the buffer in both dimensions so a misbehaving node, or
+                // late events for a retired remote id, cannot grow memory
+                // without limit while a follow id is being established.
+                let known = pending.contains_key(remote_follow_id);
+                if !known && pending.len() >= MAX_PENDING_FOLLOW_EVENT_IDS {
+                    return Ok(());
+                }
+                let buffer = pending.entry(remote_follow_id.to_string()).or_default();
+                if buffer.len() >= MAX_PENDING_FOLLOW_EVENTS_PER_ID {
+                    return Ok(());
+                }
+                buffer.push(event);
+            }
+        }
+        Ok(())
+    }
+
+    fn deliver_follow_event(&self, local_follow_id: &str, event: RemoteChainHeadFollowItem) {
+        let sender = self
+            .follows
+            .lock()
+            .unwrap()
+            .get(local_follow_id)
+            .and_then(|follow| follow.sender.clone());
+        let is_stop = matches!(event, RemoteChainHeadFollowItem::Stop);
+        if let Some(sender) = sender {
+            let _ = sender.unbounded_send(FollowSignal::Item(event));
+        }
+        if is_stop {
+            self.remove_follow(local_follow_id);
+        }
+    }
+
+    fn close_with_failure(&self, failure: RuntimeFailure) {
+        // Flip `closed` while holding the requests lock so it is mutually
+        // exclusive with `request_value`'s check-and-insert: a request is
+        // either seen here and failed, or sees `closed` and bails, but never
+        // slips through to hang.
+        let requests = {
+            let mut requests = self.requests.lock().unwrap();
+            self.closed.store(true, Ordering::Relaxed);
+            std::mem::take(&mut *requests)
+        };
+        for (_, request) in requests {
+            let mapped = match failure.kind() {
+                RuntimeFailureKind::Unavailable => RuntimeFailure::unavailable(request.method),
+                RuntimeFailureKind::HostFailure => {
+                    RuntimeFailure::host_failure(request.method, failure.reason())
+                }
+            };
+            let _ = request.tx.send(Err(mapped));
+        }
+
+        let follows = std::mem::take(&mut *self.follows.lock().unwrap());
+        self.follows_by_remote.lock().unwrap().clear();
+        self.pending_follow_events.lock().unwrap().clear();
+        self.follow_setups.lock().unwrap().clear();
+        for (_, follow) in follows {
+            if let Some(sender) = follow.sender {
+                let _ = sender.unbounded_send(FollowSignal::Interrupt);
+            }
+        }
+    }
+}
+
+struct PendingRequest {
+    method: &'static str,
+    tx: oneshot::Sender<Result<Value, RuntimeFailure>>,
+}
+
+struct FollowState {
+    with_runtime: bool,
+    remote_follow_id: Option<String>,
+    sender: Option<mpsc::UnboundedSender<FollowSignal>>,
+}
+
+/// Subscription wrapper that runs an `on_drop` cleanup when the stream is
+/// dropped. Used by `remote_chain_head_follow` to send `chainHead_v1_unfollow`
+/// when the local follow stream is dropped.
+struct ManagedSubscription<T> {
+    inner: BoxStream<'static, T>,
+    on_drop: Option<Box<dyn FnOnce() + Send + Sync>>,
+}
+
+impl<T> ManagedSubscription<T> {
+    fn new(inner: BoxStream<'static, T>, on_drop: Option<Box<dyn FnOnce() + Send + Sync>>) -> Self {
+        Self { inner, on_drop }
+    }
+}
+
+impl<T> Drop for ManagedSubscription<T> {
+    fn drop(&mut self) {
+        if let Some(on_drop) = self.on_drop.take() {
+            on_drop();
+        }
+    }
+}
+
+impl<T> Stream for ManagedSubscription<T> {
+    type Item = T;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+        this.inner.as_mut().poll_next(cx)
+    }
+}
+
+fn parse_follow_event(value: &Value) -> Result<RemoteChainHeadFollowItem, RuntimeFailure> {
+    let event = value
+        .get("event")
+        .and_then(Value::as_str)
+        .ok_or_else(|| RuntimeFailure::host_failure(FOLLOW_METHOD, "missing event name"))?;
+    match event {
+        "initialized" => Ok(RemoteChainHeadFollowItem::Initialized {
+            finalized_block_hashes: decode_hex_vec_field(value, "finalizedBlockHashes")?,
+            finalized_block_runtime: value
+                .get("finalizedBlockRuntime")
+                .map(parse_runtime_type)
+                .transpose()
+                .map_err(|reason| RuntimeFailure::host_failure(FOLLOW_METHOD, reason))?,
+        }),
+        "newBlock" => Ok(RemoteChainHeadFollowItem::NewBlock {
+            block_hash: decode_hex_field(value, "blockHash")?,
+            parent_block_hash: decode_hex_field(value, "parentBlockHash")?,
+            new_runtime: value
+                .get("newRuntime")
+                .map(parse_runtime_type)
+                .transpose()
+                .map_err(|reason| RuntimeFailure::host_failure(FOLLOW_METHOD, reason))?,
+        }),
+        "bestBlockChanged" => Ok(RemoteChainHeadFollowItem::BestBlockChanged {
+            best_block_hash: decode_hex_field(value, "bestBlockHash")?,
+        }),
+        "finalized" => Ok(RemoteChainHeadFollowItem::Finalized {
+            finalized_block_hashes: decode_hex_vec_field(value, "finalizedBlockHashes")?,
+            pruned_block_hashes: decode_hex_vec_field(value, "prunedBlockHashes")?,
+        }),
+        "operationBodyDone" => Ok(RemoteChainHeadFollowItem::OperationBodyDone {
+            operation_id: string_field(value, "operationId")?,
+            value: decode_hex_vec_field(value, "value")?,
+        }),
+        "operationCallDone" => Ok(RemoteChainHeadFollowItem::OperationCallDone {
+            operation_id: string_field(value, "operationId")?,
+            output: decode_hex_field(value, "output")?,
+        }),
+        "operationStorageItems" => Ok(RemoteChainHeadFollowItem::OperationStorageItems {
+            operation_id: string_field(value, "operationId")?,
+            items: parse_storage_result_items(value)?,
+        }),
+        "operationStorageDone" => Ok(RemoteChainHeadFollowItem::OperationStorageDone {
+            operation_id: string_field(value, "operationId")?,
+        }),
+        "operationWaitingForContinue" => {
+            Ok(RemoteChainHeadFollowItem::OperationWaitingForContinue {
+                operation_id: string_field(value, "operationId")?,
+            })
+        }
+        "operationInaccessible" => Ok(RemoteChainHeadFollowItem::OperationInaccessible {
+            operation_id: string_field(value, "operationId")?,
+        }),
+        "operationError" => Ok(RemoteChainHeadFollowItem::OperationError {
+            operation_id: string_field(value, "operationId")?,
+            error: string_field(value, "error")?,
+        }),
+        "stop" => Ok(RemoteChainHeadFollowItem::Stop),
+        other => Err(RuntimeFailure::host_failure(
+            FOLLOW_METHOD,
+            format!("unsupported follow event {other}"),
+        )),
+    }
+}
+
+fn parse_storage_result_items(value: &Value) -> Result<Vec<StorageResultItem>, RuntimeFailure> {
+    let Some(items) = value.get("items").and_then(Value::as_array) else {
+        return Ok(Vec::new());
+    };
+    items
+        .iter()
+        .map(|item| -> Result<StorageResultItem, RuntimeFailure> {
+            let key = decode_hex_field(item, "key")?;
+            let value = optional_hex_field(item, "value")?;
+            let hash = optional_hex_field(item, "hash")?;
+            let closest_descendant_merkle_value =
+                optional_hex_field(item, "closestDescendantMerkleValue")?;
+            Ok(StorageResultItem {
+                key,
+                value,
+                hash,
+                closest_descendant_merkle_value,
+            })
+        })
+        .collect()
+}
+
+fn operation_started_result(
+    method: &'static str,
+    value: Value,
+) -> Result<OperationStartedResult, RuntimeFailure> {
+    let result = value
+        .get("result")
+        .and_then(Value::as_str)
+        .ok_or_else(|| RuntimeFailure::host_failure(method, "missing operation result kind"))?;
+    match result {
+        "started" => Ok(OperationStartedResult::Started {
+            operation_id: value
+                .get("operationId")
+                .and_then(Value::as_str)
+                .ok_or_else(|| RuntimeFailure::host_failure(method, "missing operation id"))?
+                .to_string(),
+        }),
+        "limitReached" => Ok(OperationStartedResult::LimitReached),
+        other => Err(RuntimeFailure::host_failure(
+            method,
+            format!("unexpected operation result {other}"),
+        )),
+    }
+}
+
+fn parse_runtime_type(value: &Value) -> Result<RuntimeType, String> {
+    let Some(kind) = value.get("type").and_then(Value::as_str) else {
+        return Ok(RuntimeType::Invalid {
+            error: "missing runtime type".to_string(),
+        });
+    };
+    match kind {
+        "valid" => {
+            let spec = value
+                .get("spec")
+                .and_then(Value::as_object)
+                .ok_or_else(|| "missing valid runtime spec".to_string())?;
+            let apis = spec
+                .get("apis")
+                .and_then(Value::as_object)
+                .map(|apis| {
+                    let mut entries = apis
+                        .iter()
+                        .filter_map(|(name, version)| {
+                            version.as_u64().map(|version| RuntimeApi {
+                                name: name.clone(),
+                                version: version as u32,
+                            })
+                        })
+                        .collect::<Vec<_>>();
+                    entries.sort_by(|left, right| left.name.cmp(&right.name));
+                    entries
+                })
+                .unwrap_or_default();
+            Ok(RuntimeType::Valid(RuntimeSpec {
+                spec_name: string_object_field(spec, "specName")?,
+                impl_name: string_object_field(spec, "implName")?,
+                spec_version: u32_object_field(spec, "specVersion")?,
+                impl_version: u32_object_field(spec, "implVersion")?,
+                transaction_version: spec
+                    .get("transactionVersion")
+                    .and_then(Value::as_u64)
+                    .map(|value| value as u32),
+                apis,
+            }))
+        }
+        "invalid" => Ok(RuntimeType::Invalid {
+            error: value
+                .get("error")
+                .and_then(Value::as_str)
+                .unwrap_or("invalid runtime")
+                .to_string(),
+        }),
+        other => Err(format!("unsupported runtime type {other}")),
+    }
+}
+
+fn encode_storage_query_item(item: &StorageQueryItem) -> Value {
+    let query_type = match item.query_type {
+        StorageQueryType::Value => "value",
+        StorageQueryType::Hash => "hash",
+        StorageQueryType::ClosestDescendantMerkleValue => "closestDescendantMerkleValue",
+        StorageQueryType::DescendantsValues => "descendantsValues",
+        StorageQueryType::DescendantsHashes => "descendantsHashes",
+    };
+    let mut map = Map::new();
+    map.insert("key".to_string(), Value::String(encode_hex(&item.key)));
+    map.insert("type".to_string(), Value::String(query_type.to_string()));
+    Value::Object(map)
+}
+
+fn json_id(value: &Value) -> Option<String> {
+    match value {
+        Value::String(text) => Some(text.clone()),
+        Value::Number(number) => Some(number.to_string()),
+        _ => None,
+    }
+}
+
+fn decode_hex_field(value: &Value, field: &str) -> Result<Vec<u8>, RuntimeFailure> {
+    let string = string_field(value, field)?;
+    decode_hex(&string).map_err(|reason| RuntimeFailure::host_failure(FOLLOW_METHOD, reason))
+}
+
+fn optional_hex_field(value: &Value, field: &str) -> Result<Option<Vec<u8>>, RuntimeFailure> {
+    match value.get(field) {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(text)) => decode_hex(text)
+            .map(Some)
+            .map_err(|reason| RuntimeFailure::host_failure(FOLLOW_METHOD, reason)),
+        Some(_) => Err(RuntimeFailure::host_failure(
+            FOLLOW_METHOD,
+            format!("invalid {field}"),
+        )),
+    }
+}
+
+fn decode_hex_vec_field(value: &Value, field: &str) -> Result<Vec<Vec<u8>>, RuntimeFailure> {
+    let Some(values) = value.get(field).and_then(Value::as_array) else {
+        return Ok(Vec::new());
+    };
+    values
+        .iter()
+        .map(|value| {
+            value
+                .as_str()
+                .ok_or_else(|| {
+                    RuntimeFailure::host_failure(FOLLOW_METHOD, format!("invalid {field}"))
+                })
+                .and_then(|value| {
+                    decode_hex(value)
+                        .map_err(|reason| RuntimeFailure::host_failure(FOLLOW_METHOD, reason))
+                })
+        })
+        .collect()
+}
+
+fn string_field(value: &Value, field: &str) -> Result<String, RuntimeFailure> {
+    value
+        .get(field)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+        .ok_or_else(|| RuntimeFailure::host_failure(FOLLOW_METHOD, format!("missing {field}")))
+}
+
+fn string_object_field(value: &Map<String, Value>, field: &str) -> Result<String, String> {
+    value
+        .get(field)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+        .ok_or_else(|| format!("missing {field}"))
+}
+
+fn u32_object_field(value: &Map<String, Value>, field: &str) -> Result<u32, String> {
+    value
+        .get(field)
+        .and_then(Value::as_u64)
+        .map(|value| value as u32)
+        .ok_or_else(|| format!("missing {field}"))
+}
+
+/// Encode a byte slice as a `0x`-prefixed lowercase hex string.
+pub(crate) fn encode_hex(value: &[u8]) -> String {
+    format!("0x{}", hex::encode(value))
+}
+
+fn decode_hex(value: &str) -> Result<Vec<u8>, String> {
+    hex::decode(value.strip_prefix("0x").unwrap_or(value)).map_err(|_| "invalid hex".to_string())
+}
+
+// ---------------------------------------------------------------------------
+// Spawner adapter for the chain runtime.
+// ---------------------------------------------------------------------------
+//
+// `ChainRuntime` uses a small wrapper future type so callers can construct
+// the runtime with a generic `Spawner` without exposing the `BoxFuture`
+// requirement in the public signature.
+
+/// Convenience: build a [`Spawner`] that runs each spawned future on a fresh
+/// OS thread driven by [`futures::executor::block_on`]. Useful for tests and
+/// embedders that have not yet wired a real runtime. Not available on wasm32
+/// since the platform has no threads.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn thread_per_task_spawner() -> Spawner {
+    Arc::new(|fut: futures::future::BoxFuture<'static, ()>| {
+        std::thread::spawn(move || futures::executor::block_on(fut));
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_trait::async_trait;
+    use futures::channel::mpsc as fut_mpsc;
+    use futures::stream::BoxStream;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    fn spawner_for_tests() -> Spawner {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            thread_per_task_spawner()
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            Arc::new(futures::executor::block_on)
+        }
+    }
+
+    /// Provider that echoes a canned response for every request it sees,
+    /// driven by a `respond` closure. The closure receives each json-rpc
+    /// request string and returns the response string the test wants the
+    /// server to deliver. Keeps the response loop synchronized with the
+    /// request stream so there is no race between `send` and the response
+    /// loop draining frames before pending requests have registered.
+    type Responder = Arc<dyn Fn(&str) -> Option<String> + Send + Sync>;
+
+    struct ScriptedProvider {
+        respond: Responder,
+        sent: Arc<Mutex<Vec<String>>>,
+        sender: Arc<Mutex<Option<fut_mpsc::UnboundedSender<String>>>>,
+        receiver: Arc<Mutex<Option<fut_mpsc::UnboundedReceiver<String>>>>,
+        connect_calls: Arc<AtomicUsize>,
+    }
+
+    impl ScriptedProvider {
+        fn new<F>(respond: F) -> Self
+        where
+            F: Fn(&str) -> Option<String> + Send + Sync + 'static,
+        {
+            let (tx, rx) = fut_mpsc::unbounded();
+            Self {
+                respond: Arc::new(respond),
+                sent: Arc::new(Mutex::new(Vec::new())),
+                sender: Arc::new(Mutex::new(Some(tx))),
+                receiver: Arc::new(Mutex::new(Some(rx))),
+                connect_calls: Arc::new(AtomicUsize::new(0)),
+            }
+        }
+    }
+
+    struct ScriptedConnection {
+        respond: Responder,
+        sent: Arc<Mutex<Vec<String>>>,
+        sender: Arc<Mutex<Option<fut_mpsc::UnboundedSender<String>>>>,
+        receiver: Mutex<Option<fut_mpsc::UnboundedReceiver<String>>>,
+    }
+
+    impl JsonRpcConnection for ScriptedConnection {
+        fn send(&self, request: String) {
+            self.sent.lock().unwrap().push(request.clone());
+            if let Some(response) = (self.respond)(&request)
+                && let Some(sender) = self.sender.lock().unwrap().as_ref()
+            {
+                let _ = sender.unbounded_send(response);
+            }
+        }
+        fn responses(&self) -> BoxStream<'static, String> {
+            let rx = self
+                .receiver
+                .lock()
+                .unwrap()
+                .take()
+                .expect("ScriptedConnection::responses called twice");
+            rx.boxed()
+        }
+    }
+
+    #[async_trait]
+    impl RuntimeChainProvider for ScriptedProvider {
+        async fn connect(
+            &self,
+            _genesis_hash: Vec<u8>,
+        ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure> {
+            self.connect_calls.fetch_add(1, Ordering::SeqCst);
+            let receiver = self.receiver.lock().unwrap().take();
+            Ok(Arc::new(ScriptedConnection {
+                respond: self.respond.clone(),
+                sent: self.sent.clone(),
+                sender: self.sender.clone(),
+                receiver: Mutex::new(receiver),
+            }))
+        }
+    }
+
+    /// Clone of the scripted notification sender, used by tests to push
+    /// asynchronous frames (e.g. follow events) into the response stream.
+    fn notification_sender(provider: &ScriptedProvider) -> fut_mpsc::UnboundedSender<String> {
+        provider
+            .sender
+            .lock()
+            .unwrap()
+            .as_ref()
+            .expect("notification sender available")
+            .clone()
+    }
+
+    #[test]
+    fn unavailable_provider_surfaces_failure() {
+        let provider = Arc::new(UnavailableChainProvider);
+        let result = futures::executor::block_on(provider.connect(vec![0u8; 32]));
+        let err = match result {
+            Ok(_) => panic!("expected failure"),
+            Err(err) => err,
+        };
+        assert_eq!(err.kind(), RuntimeFailureKind::Unavailable);
+        assert_eq!(err.method(), "remote_chain_connect");
+    }
+
+    /// Find the json-rpc request id of the just-sent frame so the scripted
+    /// responder can mirror it back to the dispatcher.
+    fn extract_id(request: &str) -> Option<String> {
+        let value: Value = serde_json::from_str(request).ok()?;
+        value.get("id")?.as_str().map(ToString::to_string)
+    }
+
+    #[test]
+    fn header_request_routes_through_provider() {
+        let provider = Arc::new(ScriptedProvider::new(|request| {
+            let id = extract_id(request).unwrap();
+            if request.contains("chainHead_v1_follow") {
+                Some(format!(
+                    r#"{{"jsonrpc":"2.0","id":"{id}","result":"REMOTE-FOLLOW"}}"#
+                ))
+            } else if request.contains("chainHead_v1_header") {
+                Some(format!(
+                    r#"{{"jsonrpc":"2.0","id":"{id}","result":"0xdeadbeef"}}"#
+                ))
+            } else {
+                None
+            }
+        }));
+        let runtime = ChainRuntime::new(provider.clone(), spawner_for_tests());
+        let response = futures::executor::block_on(runtime.remote_chain_head_header(
+            RemoteChainHeadHeaderRequest {
+                genesis_hash: vec![0u8; 32],
+                follow_subscription_id: "local-follow".to_string(),
+                hash: vec![1u8; 32],
+            },
+        ))
+        .expect("ok response");
+        assert_eq!(response.header, Some(vec![0xde, 0xad, 0xbe, 0xef]));
+        assert_eq!(provider.connect_calls.load(Ordering::SeqCst), 1);
+        let sent = provider.sent.lock().unwrap().clone();
+        assert_eq!(sent.len(), 2);
+        assert!(sent[0].contains("chainHead_v1_follow"));
+        assert!(sent[1].contains("chainHead_v1_header"));
+    }
+
+    /// Two concurrent calls for the same chain must share one provider
+    /// `connect` instead of racing the first connection and orphaning the
+    /// loser.
+    #[test]
+    fn concurrent_connection_for_shares_one_connect() {
+        struct SlowConnectProvider {
+            inner: ScriptedProvider,
+        }
+
+        #[async_trait]
+        impl RuntimeChainProvider for SlowConnectProvider {
+            async fn connect(
+                &self,
+                genesis_hash: Vec<u8>,
+            ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure> {
+                futures_timer::Delay::new(std::time::Duration::from_millis(50)).await;
+                self.inner.connect(genesis_hash).await
+            }
+        }
+
+        let provider = Arc::new(SlowConnectProvider {
+            inner: ScriptedProvider::new(|request| {
+                let id = extract_id(request).unwrap();
+                if request.contains("chainSpec_v1_chainName") {
+                    Some(format!(
+                        r#"{{"jsonrpc":"2.0","id":"{id}","result":"Polkadot"}}"#
+                    ))
+                } else {
+                    None
+                }
+            }),
+        });
+        let runtime = ChainRuntime::new(provider.clone(), spawner_for_tests());
+
+        let (first, second) = futures::executor::block_on(futures::future::join(
+            runtime.remote_chain_spec_chain_name(vec![0u8; 32]),
+            runtime.remote_chain_spec_chain_name(vec![0u8; 32]),
+        ));
+
+        assert_eq!(first.unwrap().chain_name, "Polkadot");
+        assert_eq!(second.unwrap().chain_name, "Polkadot");
+        assert_eq!(provider.inner.connect_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn unknown_genesis_chain_spec_propagates_failure() {
+        let provider = Arc::new(UnavailableChainProvider);
+        let runtime = ChainRuntime::new(provider, spawner_for_tests());
+        let err = match futures::executor::block_on(
+            runtime.remote_chain_spec_chain_name(vec![0u8; 32]),
+        ) {
+            Ok(_) => panic!("expected failure"),
+            Err(err) => err,
+        };
+        assert_eq!(err.kind(), RuntimeFailureKind::Unavailable);
+        assert_eq!(err.method(), "remote_chain_spec_chain_name");
+    }
+
+    #[test]
+    fn json_rpc_error_becomes_host_failure() {
+        let provider = Arc::new(ScriptedProvider::new(|request| {
+            let id = extract_id(request).unwrap();
+            Some(format!(
+                r#"{{"jsonrpc":"2.0","id":"{id}","error":{{"code":-32601,"message":"method not found"}}}}"#
+            ))
+        }));
+        let runtime = ChainRuntime::new(provider, spawner_for_tests());
+        let err = match futures::executor::block_on(
+            runtime.remote_chain_spec_chain_name(vec![0u8; 32]),
+        ) {
+            Ok(_) => panic!("expected failure"),
+            Err(err) => err,
+        };
+        assert_eq!(err.kind(), RuntimeFailureKind::HostFailure);
+        assert!(
+            err.reason().contains("method not found"),
+            "unexpected reason: {}",
+            err.reason()
+        );
+    }
+
+    #[test]
+    fn follow_event_initialized_translates_to_v01_item() {
+        // Answer `chainHead_v1_follow` through the synchronized responder so
+        // the ack cannot reach the response loop before the pending request
+        // is registered.
+        let provider = Arc::new(ScriptedProvider::new(|request| {
+            let id = extract_id(request).unwrap();
+            if request.contains("chainHead_v1_follow") {
+                Some(format!(
+                    r#"{{"jsonrpc":"2.0","id":"{id}","result":"REMOTE-FOLLOW"}}"#
+                ))
+            } else {
+                None
+            }
+        }));
+        let runtime = ChainRuntime::new(provider.clone(), spawner_for_tests());
+
+        let mut stream = runtime.remote_chain_head_follow(
+            "local-follow".to_string(),
+            RemoteChainHeadFollowRequest {
+                genesis_hash: vec![0u8; 32],
+                with_runtime: false,
+            },
+        );
+
+        // Push follow events keyed by remote subscription id. Events that
+        // land before the follow ack are buffered by remote id and replayed
+        // once the follow is established.
+        let tx = notification_sender(&provider);
+        tx.unbounded_send(
+            r#"{"jsonrpc":"2.0","method":"chainHead_v1_followEvent","params":{"subscription":"REMOTE-FOLLOW","result":{"event":"initialized","finalizedBlockHashes":["0xaabbccdd"]}}}"#
+                .to_string(),
+        ).unwrap();
+        tx.unbounded_send(
+            r#"{"jsonrpc":"2.0","method":"chainHead_v1_followEvent","params":{"subscription":"REMOTE-FOLLOW","result":{"event":"stop"}}}"#
+                .to_string(),
+        ).unwrap();
+
+        let items: Vec<_> = futures::executor::block_on(async {
+            let mut out = Vec::new();
+            while let Some(item) = stream.next().await {
+                let is_stop = matches!(item, RemoteChainHeadFollowItem::Stop);
+                out.push(item);
+                if is_stop {
+                    break;
+                }
+            }
+            out
+        });
+
+        match &items[0] {
+            RemoteChainHeadFollowItem::Initialized {
+                finalized_block_hashes,
+                finalized_block_runtime,
+            } => {
+                assert_eq!(finalized_block_hashes, &vec![vec![0xaa, 0xbb, 0xcc, 0xdd]]);
+                assert!(finalized_block_runtime.is_none());
+            }
+            other => panic!("expected Initialized, got {other:?}"),
+        }
+        assert!(matches!(items[1], RemoteChainHeadFollowItem::Stop));
+    }
+
+    #[cfg_attr(target_arch = "wasm32", ignore)]
+    #[test]
+    fn drop_follow_stream_sends_unfollow() {
+        let provider = Arc::new(ScriptedProvider::new(|request| {
+            let id = extract_id(request).unwrap();
+            if request.contains("chainHead_v1_follow") {
+                Some(format!(
+                    r#"{{"jsonrpc":"2.0","id":"{id}","result":"REMOTE-FOLLOW"}}"#
+                ))
+            } else {
+                None
+            }
+        }));
+        let runtime = ChainRuntime::new(provider.clone(), spawner_for_tests());
+        let sent = provider.sent.clone();
+
+        let stream = runtime.remote_chain_head_follow(
+            "local-follow".to_string(),
+            RemoteChainHeadFollowRequest {
+                genesis_hash: vec![0u8; 32],
+                with_runtime: false,
+            },
+        );
+
+        // Wait until the follow setup roundtrips and lands in `sent`.
+        // Generous timeout so the test stays robust under loaded CI runners
+        // where the spawner can be slow to schedule the request task.
+        for _ in 0..500 {
+            if !sent.lock().unwrap().is_empty() {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+
+        drop(stream);
+
+        // Wait for the cleanup task to run and emit the unfollow request.
+        for _ in 0..500 {
+            if sent.lock().unwrap().len() >= 2 {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+
+        let messages = sent.lock().unwrap().clone();
+        assert!(
+            messages.iter().any(|m| m.contains("chainHead_v1_unfollow")),
+            "unfollow not sent; messages: {messages:?}",
+        );
+    }
+
+    #[test]
+    fn encode_hex_round_trip() {
+        let bytes = vec![0x00u8, 0x12, 0xab, 0xff];
+        let s = encode_hex(&bytes);
+        assert_eq!(s, "0x0012abff");
+        assert_eq!(decode_hex(&s).unwrap(), bytes);
+    }
+
+    #[test]
+    fn parse_runtime_type_valid_sorts_apis() {
+        let value: Value = serde_json::from_str(
+            r#"{"type":"valid","spec":{"specName":"polkadot","implName":"parity-polkadot","specVersion":1000,"implVersion":1,"transactionVersion":24,"apis":{"0xbeef":2,"0xbabe":4}}}"#,
+        )
+        .unwrap();
+        let runtime_type = parse_runtime_type(&value).unwrap();
+        match runtime_type {
+            RuntimeType::Valid(spec) => {
+                assert_eq!(spec.apis.len(), 2);
+                assert_eq!(spec.apis[0].name, "0xbabe");
+                assert_eq!(spec.apis[1].name, "0xbeef");
+                assert_eq!(spec.transaction_version, Some(24));
+            }
+            other => panic!("expected Valid, got {other:?}"),
+        }
+    }
+}
diff --git a/rust/crates/truapi-server/src/core.rs b/rust/crates/truapi-server/src/core.rs
new file mode 100644
index 00000000..6042a21c
--- /dev/null
+++ b/rust/crates/truapi-server/src/core.rs
@@ -0,0 +1,398 @@
+//! `TrUApiCore`: the entrypoint a host wraps around a `truapi::api::TrUApi`
+//! implementation (direct path) or a `truapi_platform::Platform`
+//! implementation (platform path).
+//!
+//! Direct path: `TrUApiCore::new(host)` accepts anything implementing
+//! the unified [`truapi::api::TrUApi`] super-trait. Useful for unit tests
+//! and bespoke hosts.
+//!
+//! Platform path: [`TrUApiCore::from_platform_with_config`] takes a
+//! [`truapi_platform::Platform`] and wires it through
+//! [`crate::runtime::PlatformRuntimeHost`] before registering with the
+//! generated dispatcher. This is the path real platform shims (UniFFI,
+//! wasm-bindgen, ws-bridge, ...) take.
+
+use std::sync::{Arc, Mutex};
+
+use futures::future::BoxFuture;
+use parity_scale_codec::{Decode, Encode};
+use tracing::instrument;
+use truapi::api::TrUApi;
+use truapi_platform::{Platform, RuntimeConfig};
+
+use crate::generated::dispatcher;
+use crate::host_logic::session::SessionState;
+use crate::runtime::PlatformRuntimeHost;
+use crate::subscription::Spawner;
+use crate::{Dispatcher, ProtocolMessage, Transport};
+
+type DisconnectFn = Arc<dyn Fn() -> BoxFuture<'static, ()> + Send + Sync>;
+type CancelLoginFn = Arc<dyn Fn() + Send + Sync>;
+
+/// Top-level core. Owns the dispatcher and, on the platform path, the shared
+/// session-state holder.
+pub struct TrUApiCore {
+    dispatcher: Dispatcher,
+    /// Always present; empty for [`Self::new`] (direct host path), connected
+    /// to a [`PlatformRuntimeHost`] for [`Self::from_platform_with_config`].
+    session_state: Arc<SessionState>,
+    disconnect: DisconnectFn,
+    cancel_login: CancelLoginFn,
+}
+
+impl TrUApiCore {
+    /// Build a core around a direct `TrUApi` implementation. The session
+    /// state holder is unused on this path (no platform pushes updates),
+    /// but is created anyway so the public API surface stays consistent.
+    /// Subscription work runs on `spawner`.
+    #[instrument(skip_all, fields(runtime.method = "core.new"))]
+    pub fn new<P>(host: Arc<P>, spawner: Spawner) -> Self
+    where
+        P: TrUApi + 'static,
+    {
+        let mut dispatcher = Dispatcher::new(spawner);
+        dispatcher::register(&mut dispatcher, host);
+        let session_state = SessionState::new();
+        let disconnect_state = session_state.clone();
+        Self {
+            dispatcher,
+            session_state,
+            disconnect: Arc::new(move || {
+                let state = disconnect_state.clone();
+                Box::pin(async move {
+                    state.clear_session();
+                })
+            }),
+            cancel_login: Arc::new(|| {}),
+        }
+    }
+
+    /// Build a core around a [`Platform`] implementation and explicit product
+    /// runtime configuration.
+    #[instrument(skip_all, fields(runtime.method = "core.from_platform_with_config"))]
+    pub fn from_platform_with_config<P>(
+        platform: Arc<P>,
+        runtime_config: RuntimeConfig,
+        spawner: Spawner,
+    ) -> Self
+    where
+        P: Platform + 'static,
+    {
+        let runtime = Arc::new(PlatformRuntimeHost::new(
+            platform,
+            runtime_config,
+            spawner.clone(),
+        ));
+        runtime.start_session_store_sync(spawner.clone());
+        let session_state = runtime.session_state();
+        let disconnect_runtime = runtime.clone();
+        let cancel_login_runtime = runtime.clone();
+        let mut dispatcher = Dispatcher::new(spawner);
+        dispatcher::register(&mut dispatcher, runtime);
+        Self {
+            dispatcher,
+            session_state,
+            disconnect: Arc::new(move || {
+                let runtime = disconnect_runtime.clone();
+                Box::pin(async move {
+                    runtime.disconnect().await;
+                })
+            }),
+            cancel_login: Arc::new(move || cancel_login_runtime.cancel_login()),
+        }
+    }
+
+    /// Handle to the shared session-state holder used by subscriptions and
+    /// tests. Real host lifecycle flows through `SessionStore` and
+    /// `disconnect`.
+    pub fn session_state(&self) -> Arc<SessionState> {
+        self.session_state.clone()
+    }
+
+    /// Core-owned logout/disconnect. Platform-backed cores best-effort notify
+    /// the SSO peer and clear the host-global session store; direct cores only
+    /// clear their in-memory session state.
+    #[instrument(skip_all, fields(runtime.method = "core.disconnect"))]
+    pub async fn disconnect_async(&self) {
+        (self.disconnect)().await;
+    }
+
+    /// Blocking wrapper for embedders that do not drive async directly.
+    #[instrument(skip_all, fields(runtime.method = "core.disconnect_blocking"))]
+    pub fn disconnect(&self) {
+        futures::executor::block_on(self.disconnect_async());
+    }
+
+    /// Cancel any in-flight `request_login` pairing. The host UI receives a
+    /// `Disconnected` auth state immediately and the pending login resolves
+    /// to `Rejected`. A no-op when no login is in progress (and always a
+    /// no-op on the direct host path).
+    #[instrument(skip_all, fields(runtime.method = "core.cancel_login"))]
+    pub fn cancel_login(&self) {
+        (self.cancel_login)();
+    }
+
+    /// Asynchronous form of [`Self::receive_from_product`]. Decodes the
+    /// incoming frame, runs it through the dispatcher, and returns the
+    /// SCALE-encoded response (if any).
+    #[instrument(skip_all, fields(runtime.method = "core.receive_from_product"))]
+    pub async fn receive_from_product_async(&self, frame: &[u8]) -> Option<Vec<u8>> {
+        let message = ProtocolMessage::decode(&mut &*frame).ok()?;
+        let transport = Arc::new(ResponseTransport::default());
+        self.dispatcher
+            .dispatch(message, transport.clone() as Arc<dyn Transport>)
+            .await;
+        transport.take().map(|response| response.encode())
+    }
+
+    /// Synchronous wrapper that blocks the current thread until the inner
+    /// future resolves. Convenient for embedding contexts (e.g. UniFFI) that
+    /// don't already drive an async runtime.
+    #[instrument(skip_all, fields(runtime.method = "core.receive_from_product_blocking"))]
+    pub fn receive_from_product(&self, frame: &[u8]) -> Option<Vec<u8>> {
+        futures::executor::block_on(self.receive_from_product_async(frame))
+    }
+
+    /// Dispatch an already-decoded protocol message through the underlying
+    /// dispatcher. Bridges that own a long-lived transport (e.g. WebSocket,
+    /// JS callback) call this directly so subscription items flow back
+    /// through the bridge transport instead of the single-slot capture used
+    /// by [`Self::receive_from_product`].
+    #[instrument(skip_all, fields(runtime.method = "core.dispatch"))]
+    pub async fn dispatch(&self, message: ProtocolMessage, transport: Arc<dyn Transport>) {
+        self.dispatcher.dispatch(message, transport).await;
+    }
+}
+
+/// Single-slot transport that captures the next response the dispatcher
+/// emits. Used by [`TrUApiCore::receive_from_product`] to bridge between the
+/// dispatcher's push model and the synchronous "decode in, encoded out"
+/// shape exposed to embedders.
+#[derive(Default)]
+struct ResponseTransport {
+    response: Mutex<Option<ProtocolMessage>>,
+}
+
+impl ResponseTransport {
+    fn take(&self) -> Option<ProtocolMessage> {
+        self.response.lock().unwrap().take()
+    }
+}
+
+impl Transport for ResponseTransport {
+    fn send(&self, message: ProtocolMessage) {
+        *self.response.lock().unwrap() = Some(message);
+    }
+
+    fn on_message(
+        &self,
+        _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+    ) -> Box<dyn FnOnce()> {
+        Box::new(|| {})
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use parity_scale_codec::Encode;
+    use truapi::v01;
+    use truapi::versioned::local_storage::{
+        HostLocalStorageClearRequest, HostLocalStorageReadRequest, HostLocalStorageWriteRequest,
+    };
+    use truapi::versioned::notifications::HostPushNotificationRequest;
+    use truapi::versioned::permissions::RemotePermissionRequest;
+    use truapi::versioned::system::HostFeatureSupportedRequest;
+
+    use crate::frame::{Payload, request_ids, subscription_ids};
+    use crate::test_support::{StubPlatform, runtime_config, test_spawner};
+
+    #[test]
+    fn from_platform_dispatches_feature_supported() {
+        let core = TrUApiCore::from_platform_with_config(
+            Arc::new(StubPlatform::default()),
+            runtime_config("dotli.dot"),
+            test_spawner(),
+        );
+        let request = HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+            genesis_hash: vec![0u8; 32],
+        });
+        let ids = request_ids("system_feature_supported").expect("known request method");
+        let frame = ProtocolMessage {
+            request_id: "p:1".into(),
+            payload: Payload {
+                id: ids.request_id,
+                value: request.encode(),
+            },
+        };
+        let encoded = frame.encode();
+        let response_bytes = core
+            .receive_from_product(&encoded)
+            .expect("dispatcher should emit a response");
+        let response = ProtocolMessage::decode(&mut &response_bytes[..]).expect("decode response");
+        assert_eq!(response.request_id, "p:1");
+        assert_eq!(response.payload.id, ids.response_id);
+        // Wire payload is `Result<Ok, Err>`-shaped:
+        // [Ok disc=0x00][V1 variant 0x00][supported=1]
+        assert_eq!(response.payload.value, vec![0x00, 0x00, 0x01]);
+    }
+
+    /// Drive a request frame through `TrUApiCore::receive_from_product`,
+    /// decode the response envelope, and return its payload bytes (without
+    /// the wrapping ProtocolMessage). Shared by the runtime-delegation
+    /// tests below.
+    fn run_request(core: &TrUApiCore, method: &str, request_bytes: Vec<u8>) -> Vec<u8> {
+        let ids = request_ids(method).expect("known request method");
+        let frame = ProtocolMessage {
+            request_id: "p:1".into(),
+            payload: Payload {
+                id: ids.request_id,
+                value: request_bytes,
+            },
+        };
+        let response_bytes = core
+            .receive_from_product(&frame.encode())
+            .expect("dispatcher should emit a response");
+        let response = ProtocolMessage::decode(&mut &response_bytes[..]).expect("decode response");
+        assert_eq!(response.request_id, "p:1");
+        assert_eq!(response.payload.id, ids.response_id);
+        response.payload.value
+    }
+
+    fn make_core() -> TrUApiCore {
+        TrUApiCore::from_platform_with_config(
+            Arc::new(StubPlatform::default()),
+            runtime_config("dotli.dot"),
+            test_spawner(),
+        )
+    }
+
+    #[test]
+    fn local_storage_read_round_trips_none() {
+        let core = make_core();
+        let request = HostLocalStorageReadRequest::V1(v01::HostLocalStorageReadRequest {
+            key: "missing".into(),
+        });
+        let payload = run_request(&core, "local_storage_read", request.encode());
+        // Ok disc 0x00, V1 variant 0x00, Option::None = 0x00.
+        assert_eq!(payload, vec![0x00, 0x00, 0x00]);
+    }
+
+    #[test]
+    fn local_storage_write_round_trips_unit_ok() {
+        let core = make_core();
+        let request = HostLocalStorageWriteRequest::V1(v01::HostLocalStorageWriteRequest {
+            key: "k".into(),
+            value: vec![1, 2, 3],
+        });
+        let payload = run_request(&core, "local_storage_write", request.encode());
+        // Ok disc 0x00, V1 variant 0x00.
+        assert_eq!(payload, vec![0x00, 0x00]);
+    }
+
+    #[test]
+    fn local_storage_clear_round_trips_unit_ok() {
+        let core = make_core();
+        let request =
+            HostLocalStorageClearRequest::V1(v01::HostLocalStorageClearRequest { key: "k".into() });
+        let payload = run_request(&core, "local_storage_clear", request.encode());
+        // Ok disc 0x00, V1 variant 0x00.
+        assert_eq!(payload, vec![0x00, 0x00]);
+    }
+
+    #[test]
+    fn send_push_notification_delegates_to_platform() {
+        let core = make_core();
+        let request = HostPushNotificationRequest::V1(v01::HostPushNotificationRequest {
+            text: "hi".into(),
+            deeplink: None,
+            scheduled_at: None,
+        });
+        let payload = run_request(
+            &core,
+            "notifications_send_push_notification",
+            request.encode(),
+        );
+        // Ok disc 0x00, V1 variant 0x00, notification id 0.
+        let mut expected = vec![0x00u8];
+        truapi::versioned::notifications::HostPushNotificationResponse::V1(
+            v01::HostPushNotificationResponse { id: 0 },
+        )
+        .encode_to(&mut expected);
+        assert_eq!(payload, expected);
+    }
+
+    #[test]
+    fn request_remote_permission_round_trips_granted() {
+        let core = make_core();
+        let request = RemotePermissionRequest::V1(v01::RemotePermissionRequest {
+            permission: v01::RemotePermission::ChainSubmit,
+        });
+        let payload = run_request(
+            &core,
+            "permissions_request_remote_permission",
+            request.encode(),
+        );
+        // Stub permissions grants every request. Wire is Ok disc 0x00, V1
+        // variant 0x00, granted=1.
+        assert_eq!(payload, vec![0x00, 0x00, 0x01]);
+    }
+
+    /// `connection_status_subscribe` produces a stream whose first item is
+    /// the current session state. Drive it through the dispatcher with a
+    /// recording transport and assert exactly one `_receive` frame appears.
+    #[test]
+    fn connection_status_subscribe_yields_initial_disconnected() {
+        use std::sync::Mutex;
+
+        #[derive(Default)]
+        struct RecordingTransport {
+            sent: Mutex<Vec<ProtocolMessage>>,
+        }
+        impl Transport for RecordingTransport {
+            fn send(&self, message: ProtocolMessage) {
+                self.sent.lock().unwrap().push(message);
+            }
+            fn on_message(
+                &self,
+                _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+            ) -> Box<dyn FnOnce()> {
+                Box::new(|| {})
+            }
+        }
+
+        let core = make_core();
+        let transport = Arc::new(RecordingTransport::default());
+        let dyn_transport: Arc<dyn Transport> = transport.clone();
+
+        let sub_ids =
+            subscription_ids("account_connection_status_subscribe").expect("known subscription");
+        let frame = ProtocolMessage {
+            request_id: "p:1".into(),
+            payload: Payload {
+                id: sub_ids.start_id,
+                value: Vec::new(),
+            },
+        };
+        futures::executor::block_on(core.dispatch(frame, dyn_transport));
+
+        // Wait briefly for the spawned thread to emit the initial item.
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
+        loop {
+            if !transport.sent.lock().unwrap().is_empty() {
+                break;
+            }
+            if std::time::Instant::now() > deadline {
+                panic!("subscription did not yield an item in time");
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+
+        let sent = transport.sent.lock().unwrap().clone();
+        assert!(!sent.is_empty(), "expected at least one _receive frame");
+        let first = &sent[0];
+        assert_eq!(first.payload.id, sub_ids.receive_id);
+        // V1(Disconnected): V1 variant 0x00, Disconnected discriminant 0x00.
+        assert_eq!(first.payload.value, vec![0x00, 0x00]);
+    }
+}
diff --git a/rust/crates/truapi-server/src/dispatcher.rs b/rust/crates/truapi-server/src/dispatcher.rs
new file mode 100644
index 00000000..20389abd
--- /dev/null
+++ b/rust/crates/truapi-server/src/dispatcher.rs
@@ -0,0 +1,310 @@
+//! Request dispatcher.
+//!
+//! Routes incoming frames to the appropriate trait method based on the
+//! numeric wire discriminant. The handler set is registered by the
+//! auto-generated [`crate::generated::dispatcher::register`] function; this
+//! module provides the framework that owns the registration tables and the
+//! routing logic.
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use futures::future::LocalBoxFuture;
+use tracing::instrument;
+
+use crate::frame::{Payload, ProtocolMessage};
+use crate::generated::wire_table::{RequestFrameIds, SubscriptionFrameIds};
+use crate::subscription::{Spawner, SubscriptionManager, SubscriptionStream};
+use crate::transport::Transport;
+
+/// A handler for a request-response method. The returned future is not
+/// required to be `Send` because the truapi trait uses `async fn`, whose
+/// auto-Send-ness is not guaranteed. The `request_id` is the per-frame
+/// identifier; handlers thread it into the `CallContext` so trait methods
+/// can correlate logs/cancellation with the originating request. On the
+/// error path handlers return the SCALE-encoded `CallError` payload bytes
+/// (typically via [`crate::frame::encode_decode_error`] or
+/// [`crate::frame::encode_call_error_payload`]); the dispatcher wraps them
+/// into the response envelope.
+pub type RequestHandler =
+    Arc<dyn Fn(String, Vec<u8>) -> LocalBoxFuture<'static, Result<Vec<u8>, Vec<u8>>> + Send + Sync>;
+
+/// A handler for a subscription method. On the error path the handler
+/// returns the SCALE-encoded `CallError` payload bytes; the dispatcher
+/// wraps them into an `_interrupt` envelope.
+pub type SubscriptionHandler = Arc<
+    dyn Fn(String, Vec<u8>) -> LocalBoxFuture<'static, Result<SubscriptionStream, Vec<u8>>>
+        + Send
+        + Sync,
+>;
+
+/// A registered request handler plus the discriminants it replies on.
+pub struct RequestEntry {
+    ids: RequestFrameIds,
+    handler: RequestHandler,
+}
+
+/// A registered subscription handler plus the discriminants its frames carry.
+pub struct SubscriptionEntry {
+    ids: SubscriptionFrameIds,
+    handler: SubscriptionHandler,
+}
+
+/// Routes incoming protocol messages to registered handlers, keyed on the
+/// numeric wire discriminant.
+pub struct Dispatcher {
+    by_request: HashMap<u8, RequestEntry>,
+    by_start: HashMap<u8, SubscriptionEntry>,
+    stop_ids: HashSet<u8>,
+    subscriptions: SubscriptionManager,
+}
+
+impl Dispatcher {
+    /// Construct a dispatcher whose subscriptions are driven on `spawner`.
+    pub fn new(spawner: Spawner) -> Self {
+        Self {
+            by_request: HashMap::new(),
+            by_start: HashMap::new(),
+            stop_ids: HashSet::new(),
+            subscriptions: SubscriptionManager::new(spawner),
+        }
+    }
+
+    /// Register a request-response handler, keyed on `ids.request_id`. Returns
+    /// the previously registered entry if any; callers (the generated
+    /// `dispatcher::register`) should treat `Some` as a programming error
+    /// since each request id must own exactly one handler.
+    pub fn on_request<F>(&mut self, ids: RequestFrameIds, handler: F) -> Option<RequestEntry>
+    where
+        F: Fn(String, Vec<u8>) -> LocalBoxFuture<'static, Result<Vec<u8>, Vec<u8>>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        self.by_request.insert(
+            ids.request_id,
+            RequestEntry {
+                ids,
+                handler: Arc::new(handler),
+            },
+        )
+    }
+
+    /// Register a subscription handler, keyed on `ids.start_id`, and record
+    /// `ids.stop_id` so a matching `_stop` frame tears the subscription down.
+    /// Returns the previously registered entry if any.
+    pub fn on_subscription<F>(
+        &mut self,
+        ids: SubscriptionFrameIds,
+        handler: F,
+    ) -> Option<SubscriptionEntry>
+    where
+        F: Fn(String, Vec<u8>) -> LocalBoxFuture<'static, Result<SubscriptionStream, Vec<u8>>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        self.stop_ids.insert(ids.stop_id);
+        self.by_start.insert(
+            ids.start_id,
+            SubscriptionEntry {
+                ids,
+                handler: Arc::new(handler),
+            },
+        )
+    }
+
+    /// Process an incoming protocol message, sending any responses or
+    /// subscription frames through `transport`. A discriminant with no
+    /// registered handler is dropped.
+    #[instrument(skip_all, fields(runtime.method = "dispatcher.dispatch"))]
+    pub async fn dispatch(&self, message: ProtocolMessage, transport: Arc<dyn Transport>) {
+        let id = message.payload.id;
+
+        if let Some(entry) = self.by_request.get(&id) {
+            // On the wire, every response is `Result<Ok, Err>`-shaped: the
+            // handler returns `Ok(bytes)` already prefixed with a `0x00`
+            // discriminant for success, and `Err(bytes)` whose bytes are the
+            // SCALE-encoded `CallError`. The error path prepends `0x01` so the
+            // wire payload is always `[disc][value...]`.
+            let request_id = message.request_id.clone();
+            let value = match (entry.handler)(request_id, message.payload.value).await {
+                Ok(value) => value,
+                Err(err_bytes) => prefix_err(err_bytes),
+            };
+            transport.send(ProtocolMessage {
+                request_id: message.request_id,
+                payload: Payload {
+                    id: entry.ids.response_id,
+                    value,
+                },
+            });
+        } else if let Some(entry) = self.by_start.get(&id) {
+            // Reserve the slot before awaiting the handler so a `_stop`
+            // arriving while the handler resolves cancels the pending
+            // subscription instead of racing the registration.
+            let token = self.subscriptions.reserve(message.request_id.clone());
+            let request_id = message.request_id.clone();
+            match (entry.handler)(request_id, message.payload.value).await {
+                Ok(stream) => {
+                    self.subscriptions.activate(
+                        token,
+                        entry.ids.receive_id,
+                        entry.ids.interrupt_id,
+                        stream,
+                        transport,
+                    );
+                }
+                Err(err_bytes) => {
+                    self.subscriptions.cancel_reservation(token);
+                    transport.send(ProtocolMessage {
+                        request_id: message.request_id,
+                        payload: Payload {
+                            id: entry.ids.interrupt_id,
+                            value: err_bytes,
+                        },
+                    });
+                }
+            }
+        } else if self.stop_ids.contains(&id) {
+            self.subscriptions.handle_stop(&message.request_id);
+        }
+        // Unknown discriminant: drop. Response / receive / interrupt frames are
+        // handled by the client side and never registered here.
+    }
+}
+
+/// Prepend the `0x01` Err discriminant to SCALE-encoded `CallError` bytes,
+/// producing the `[disc][value...]` Result wire shape the response envelope
+/// expects.
+fn prefix_err(err_bytes: Vec<u8>) -> Vec<u8> {
+    let mut value = Vec::with_capacity(1 + err_bytes.len());
+    value.push(1u8);
+    value.extend_from_slice(&err_bytes);
+    value
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use parity_scale_codec::Encode;
+    use std::sync::Mutex;
+    use truapi::CallError;
+
+    fn test_spawner() -> Spawner {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            crate::subscription::thread_per_subscription_spawner()
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            Arc::new(futures::executor::block_on)
+        }
+    }
+
+    #[derive(Default)]
+    struct RecordingTransport {
+        sent: Mutex<Vec<ProtocolMessage>>,
+    }
+
+    impl RecordingTransport {
+        fn sent(&self) -> Vec<ProtocolMessage> {
+            self.sent.lock().unwrap().clone()
+        }
+    }
+
+    impl Transport for RecordingTransport {
+        fn send(&self, message: ProtocolMessage) {
+            self.sent.lock().unwrap().push(message);
+        }
+        fn on_message(
+            &self,
+            _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+        ) -> Box<dyn FnOnce()> {
+            Box::new(|| {})
+        }
+    }
+
+    fn make_frame(id: u8, value: Vec<u8>) -> ProtocolMessage {
+        ProtocolMessage {
+            request_id: "p:1".into(),
+            payload: Payload { id, value },
+        }
+    }
+
+    /// A frame whose discriminant has no registered handler is dropped: no
+    /// response, no interrupt. (In production `register` registers every wire
+    /// method, so this only happens for malformed or client-bound ids.)
+    #[test]
+    fn dispatch_unregistered_id_sends_nothing() {
+        let dispatcher = Dispatcher::new(test_spawner());
+        let transport = Arc::new(RecordingTransport::default());
+        let transport_dyn: Arc<dyn Transport> = transport.clone();
+        let frame = make_frame(250, Vec::new());
+        futures::executor::block_on(dispatcher.dispatch(frame, transport_dyn));
+        assert!(
+            transport.sent().is_empty(),
+            "an unregistered discriminant must produce no frame"
+        );
+    }
+
+    /// A handler that returns `Err(CallError::Denied)` must produce a response
+    /// frame on the registered `response_id` whose payload begins with the
+    /// `0x01` Err discriminant byte (the Result wire shape).
+    #[test]
+    fn dispatch_request_handler_error_emits_response_with_err_discriminant() {
+        let mut dispatcher = Dispatcher::new(test_spawner());
+        let ids = RequestFrameIds {
+            request_id: 200,
+            response_id: 201,
+        };
+        dispatcher.on_request(ids, |_request_id, _bytes| {
+            Box::pin(async move {
+                let err: CallError<()> = CallError::Denied;
+                Err(crate::frame::encode_call_error_payload(err))
+            })
+        });
+        let transport = Arc::new(RecordingTransport::default());
+        let frame = make_frame(200, Vec::new());
+        futures::executor::block_on(dispatcher.dispatch(frame, transport.clone()));
+        let sent = transport.sent();
+        assert_eq!(sent.len(), 1, "exactly one response expected");
+        assert_eq!(sent[0].payload.id, 201);
+        let payload = &sent[0].payload.value;
+        assert_eq!(payload.first(), Some(&1u8), "first byte must be Err disc");
+        // After the Err disc comes the SCALE-encoded CallError; `Denied` is
+        // variant 1, so the full payload is `[0x01 disc][0x01 variant]`.
+        let err: CallError<()> = CallError::Denied;
+        let mut expected_inner = Vec::new();
+        match &err {
+            CallError::Denied => 1u8.encode_to(&mut expected_inner),
+            _ => unreachable!(),
+        }
+        let mut expected = vec![1u8];
+        expected.extend_from_slice(&expected_inner);
+        assert_eq!(payload, &expected);
+    }
+
+    /// Registering two handlers under the same key must not silently
+    /// overwrite. The contract chosen here is "loud": `on_request`
+    /// returns the previous handler, so callers can detect collisions.
+    #[test]
+    fn register_request_twice_returns_previous_handler() {
+        let mut dispatcher = Dispatcher::new(test_spawner());
+        let ids = RequestFrameIds {
+            request_id: 200,
+            response_id: 201,
+        };
+        let prev = dispatcher.on_request(ids, |_request_id, _bytes| {
+            Box::pin(async move { Ok(Vec::new()) })
+        });
+        assert!(prev.is_none(), "first registration has no predecessor");
+        let prev = dispatcher.on_request(ids, |_request_id, _bytes| {
+            Box::pin(async move { Ok(Vec::new()) })
+        });
+        assert!(
+            prev.is_some(),
+            "second registration must return the previous handler"
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/frame.rs b/rust/crates/truapi-server/src/frame.rs
new file mode 100644
index 00000000..40d46305
--- /dev/null
+++ b/rust/crates/truapi-server/src/frame.rs
@@ -0,0 +1,436 @@
+//! Wire protocol frame types.
+//!
+//! Every message on the wire is a `ProtocolMessage` containing a `requestId`
+//! and a `payload`. On the wire the envelope is:
+//!
+//! ```text
+//!   [requestId: SCALE str][discriminant: u8][payload bytes...]
+//! ```
+//!
+//! The discriminant maps to a method/kind slot via the auto-generated
+//! [`crate::generated::wire_table::WIRE_TABLE`]. Method ordering is part of
+//! the wire protocol; only ever append to the table. The payload bytes are
+//! the SCALE-encoded inner value, inlined without a length prefix.
+//!
+//! In-memory we keep the numeric id directly so dispatch does not need to
+//! reconstruct string action tags on every frame.
+
+use parity_scale_codec::{Decode, Encode, Error as CodecError, Input, Output};
+
+use truapi::CallError;
+
+use crate::generated::wire_table::{RequestFrameIds, SubscriptionFrameIds, WIRE_TABLE, WireKind};
+
+/// Top-level wire message. Encoded as `[requestId][discriminant][bytes]`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProtocolMessage {
+    /// Per-message identifier carried by both halves of a request/response.
+    pub request_id: String,
+    /// Tagged payload describing the frame kind and SCALE bytes.
+    pub payload: Payload,
+}
+
+/// Encode `CallError::MalformedFrame { reason }` as the SCALE-encoded payload
+/// bytes a handler returns on a decode failure. The dispatcher wraps these
+/// bytes into a response frame with the matching `request_id` and response
+/// tag.
+pub fn encode_decode_error(reason: String) -> Vec<u8> {
+    let err: CallError<()> = CallError::MalformedFrame { reason };
+    encode_call_error(&err)
+}
+
+/// Encode a `CallError<E>` as the SCALE-encoded payload bytes a handler
+/// returns on the error path. The dispatcher wraps these bytes into a
+/// response frame with the matching `request_id` and response tag.
+pub fn encode_call_error_payload<E: Encode>(err: CallError<E>) -> Vec<u8> {
+    encode_call_error(&err)
+}
+
+/// Encode a successful `Result` payload. The leading `0u8` is the SCALE
+/// discriminant for `Ok`, followed by the encoded success value. For `()`,
+/// this returns just the discriminant because unit encodes to zero bytes.
+pub fn encode_ok_payload<T: Encode>(value: T) -> Vec<u8> {
+    let mut out = Vec::with_capacity(1 + value.size_hint());
+    0u8.encode_to(&mut out);
+    value.encode_to(&mut out);
+    out
+}
+
+impl Encode for ProtocolMessage {
+    fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+        self.request_id.encode_to(dest);
+        self.payload.id.encode_to(dest);
+        // Payload bytes are inlined; the receiver reads "until end of frame"
+        // because each transport frame is one ProtocolMessage. This matches
+        // the public versioned enum transport shape (variant payload encoded
+        // inline, no length prefix), and constrains us to slice-shaped
+        // `Input`s on the decode side.
+        dest.write(&self.payload.value);
+    }
+}
+
+// Callers must hand `Decode` a slice-shaped `Input`; streaming inputs cannot
+// decode this envelope because the payload has no length prefix.
+impl Decode for ProtocolMessage {
+    fn decode<I: Input>(input: &mut I) -> Result<Self, CodecError> {
+        let request_id = String::decode(input)?;
+        let id = u8::decode(input)?;
+        // Unknown ids are accepted here; routing is deferred to dispatch,
+        // which drops frames with no registered handler.
+        let remaining = input
+            .remaining_len()?
+            .ok_or_else(|| CodecError::from("frame input must report remaining length"))?;
+        let mut value = vec![0u8; remaining];
+        input.read(&mut value)?;
+        Ok(ProtocolMessage {
+            request_id,
+            payload: Payload { id, value },
+        })
+    }
+}
+
+/// Tagged payload. The `id` is the wire discriminant from
+/// [`crate::generated::wire_table::WIRE_TABLE`], identifying the frame's method
+/// and kind (request/response/start/stop/interrupt/receive).
+///
+/// Note: `Payload` does not derive `Encode`/`Decode` directly; the wire
+/// representation lives on [`ProtocolMessage`]. `Payload` is kept as a plain
+/// data type for in-memory dispatch (key on `id`, value bytes already
+/// SCALE-encoded by the call site).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Payload {
+    /// Wire discriminant identifying the frame's method and kind.
+    pub id: u8,
+    /// SCALE-encoded inner value bytes.
+    pub value: Vec<u8>,
+}
+
+/// Request discriminants for a request method, by name. Walks the generated
+/// [`WIRE_TABLE`]; intended for tests and embedders that route by method
+/// string rather than holding the generated const.
+pub fn request_ids(method: &str) -> Option<RequestFrameIds> {
+    WIRE_TABLE
+        .iter()
+        .find_map(|entry| match (&entry.kind, entry.method == method) {
+            (WireKind::Request(ids), true) => Some(*ids),
+            _ => None,
+        })
+}
+
+/// Subscription discriminants for a subscription method, by name. Walks the
+/// generated [`WIRE_TABLE`].
+pub fn subscription_ids(method: &str) -> Option<SubscriptionFrameIds> {
+    WIRE_TABLE
+        .iter()
+        .find_map(|entry| match (&entry.kind, entry.method == method) {
+            (WireKind::Subscription(ids), true) => Some(*ids),
+            _ => None,
+        })
+}
+
+/// Unique ID generator with a prefix.
+pub struct IdFactory {
+    prefix: String,
+    counter: u64,
+}
+
+impl IdFactory {
+    /// Build a factory that mints IDs of the form `{prefix}{counter}`.
+    pub fn new(prefix: impl Into<String>) -> Self {
+        Self {
+            prefix: prefix.into(),
+            counter: 0,
+        }
+    }
+
+    /// Return the next ID, monotonically increasing from 1.
+    pub fn next_id(&mut self) -> String {
+        self.counter += 1;
+        format!("{}{}", self.prefix, self.counter)
+    }
+}
+
+/// Encode a `CallError<E>` as SCALE bytes. `CallError` does not derive
+/// `Encode` directly so the variants are emitted manually.
+fn encode_call_error<E: Encode>(err: &CallError<E>) -> Vec<u8> {
+    let mut out = Vec::new();
+    match err {
+        CallError::Domain(value) => {
+            0u8.encode_to(&mut out);
+            value.encode_to(&mut out);
+        }
+        CallError::Denied => {
+            1u8.encode_to(&mut out);
+        }
+        CallError::Unsupported => {
+            2u8.encode_to(&mut out);
+        }
+        CallError::MalformedFrame { reason } => {
+            3u8.encode_to(&mut out);
+            reason.encode_to(&mut out);
+        }
+        CallError::HostFailure { reason } => {
+            4u8.encode_to(&mut out);
+            reason.encode_to(&mut out);
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn build(id: u8, value: Vec<u8>) -> ProtocolMessage {
+        ProtocolMessage {
+            request_id: "p:1".to_string(),
+            payload: Payload { id, value },
+        }
+    }
+
+    fn expected_wire(id: u8, value: &[u8]) -> Vec<u8> {
+        let mut out = Vec::new();
+        "p:1".to_string().encode_to(&mut out);
+        out.push(id);
+        out.extend_from_slice(value);
+        out
+    }
+
+    #[test]
+    fn handshake_request_encodes_with_discriminant_zero() {
+        // SCALE-encoded HostHandshakeRequest::V1(1u8) = [0u8 variant][1u8 codec_version]
+        let inner: Vec<u8> = vec![0x00, 0x01];
+        let msg = build(0, inner.clone());
+        assert_eq!(msg.encode(), expected_wire(0, &inner));
+    }
+
+    #[test]
+    fn get_account_request_encodes_with_discriminant_22() {
+        let mut inner = vec![0x00]; // V1 variant
+        "foo".to_string().encode_to(&mut inner);
+        0u32.encode_to(&mut inner);
+        let msg = build(22, inner.clone());
+        assert_eq!(msg.encode(), expected_wire(22, &inner));
+    }
+
+    #[test]
+    fn round_trip_preserves_id_and_value() {
+        let inner: Vec<u8> = vec![0x00, 0x42, 0xab, 0xcd];
+        let msg = build(12, inner.clone());
+        let decoded = ProtocolMessage::decode(&mut &msg.encode()[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    /// An unknown discriminant is no longer rejected at decode; routing is
+    /// deferred to dispatch (which drops frames with no registered handler).
+    #[test]
+    fn unknown_discriminant_decodes_ok() {
+        let mut bytes = Vec::new();
+        "p:1".to_string().encode_to(&mut bytes);
+        bytes.push(250); // far outside the populated range
+        bytes.extend_from_slice(&[0xaa, 0xbb]);
+        let decoded = ProtocolMessage::decode(&mut &bytes[..]).expect("unknown id must decode");
+        assert_eq!(decoded.payload.id, 250);
+        assert_eq!(decoded.payload.value, vec![0xaa, 0xbb]);
+    }
+
+    /// All four subscription phases round-trip through the codec. Catches a
+    /// regression where `Decode` mishandles a frame whose payload is empty for
+    /// `_stop` / `_interrupt` (no inner data) but non-empty for `_start` /
+    /// `_receive`. The ids are the `account_connection_status_subscribe`
+    /// quartet (18..=21).
+    #[test]
+    fn subscription_phases_round_trip_through_codec() {
+        let cases: &[(u8, Vec<u8>)] = &[
+            (18, vec![0x00, 0xaa]),             // start
+            (19, Vec::new()),                   // stop
+            (20, Vec::new()),                   // interrupt
+            (21, vec![0x01, 0x02, 0x03, 0x04]), // receive
+        ];
+        for (id, value) in cases {
+            let msg = build(*id, value.clone());
+            let bytes = msg.encode();
+            assert_eq!(
+                bytes,
+                expected_wire(*id, value),
+                "encode mismatch for id {id}"
+            );
+            let decoded = ProtocolMessage::decode(&mut &bytes[..]).expect("decode");
+            assert_eq!(decoded, msg, "round-trip mismatch for id {id}");
+        }
+    }
+
+    /// `request_ids` / `subscription_ids` resolve a method name to its
+    /// generated discriminants without going through the codec.
+    #[test]
+    fn id_helpers_resolve_known_methods() {
+        let handshake = request_ids("system_handshake").expect("known request method");
+        assert_eq!(handshake.request_id, 0);
+        assert_eq!(handshake.response_id, 1);
+
+        let get_account = request_ids("account_get_account").expect("known request method");
+        assert_eq!(get_account.request_id, 22);
+
+        let sub =
+            subscription_ids("account_connection_status_subscribe").expect("known subscription");
+        assert_eq!(sub.start_id, 18);
+        assert_eq!(sub.stop_id, 19);
+        assert_eq!(sub.interrupt_id, 20);
+        assert_eq!(sub.receive_id, 21);
+
+        // A request method is not a subscription and vice versa.
+        assert!(subscription_ids("system_handshake").is_none());
+        assert!(request_ids("account_connection_status_subscribe").is_none());
+        assert!(request_ids("not_a_method").is_none());
+    }
+
+    /// Genuine zero-byte payload (e.g. unit-typed response). `Decode` must
+    /// handle `remaining_len == 0` without erroring or reading past EOF.
+    #[test]
+    fn empty_payload_round_trips() {
+        // local_storage_clear_response = 17.
+        let msg = build(17, Vec::new());
+        let bytes = msg.encode();
+        // [SCALE compact-len 0x0c][p][:][1][u8 17] = 4 + 1 = 5 bytes total
+        assert_eq!(bytes.len(), 5);
+        let decoded = ProtocolMessage::decode(&mut &bytes[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    /// Compact-len mode 1 kicks in for strings with length 64..=16383. Make
+    /// sure the codec handles a long requestId without truncation.
+    #[test]
+    fn long_request_id_round_trips() {
+        let long_id: String = "x".repeat(200);
+        let msg = ProtocolMessage {
+            request_id: long_id,
+            payload: Payload {
+                id: 22,
+                value: vec![0x00, 0xab, 0xcd],
+            },
+        };
+        let decoded = ProtocolMessage::decode(&mut &msg.encode()[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    /// Truncated frames must surface a `CodecError`, not panic.
+    #[test]
+    fn truncated_frames_error_cleanly() {
+        // Empty buffer.
+        assert!(ProtocolMessage::decode(&mut &[][..]).is_err());
+        // Just the requestId, no discriminant byte.
+        let mut only_request_id = Vec::new();
+        "p:1".to_string().encode_to(&mut only_request_id);
+        assert!(ProtocolMessage::decode(&mut &only_request_id[..]).is_err());
+        // RequestId header claims length=200 but the buffer is far shorter.
+        let truncated_str_header = [200u8 << 2, 0x61, 0x62, 0x63];
+        assert!(ProtocolMessage::decode(&mut &truncated_str_header[..]).is_err());
+    }
+
+    /// Empty requestId (zero-length string) is a valid SCALE-encoded `str`
+    /// (compact-len 0, no body). The codec must round-trip it without
+    /// confusing length-0 with EOF.
+    #[test]
+    fn empty_request_id_round_trips() {
+        let msg = ProtocolMessage {
+            request_id: String::new(),
+            payload: Payload {
+                id: 22,
+                value: vec![0x00, 0x01, 0x02],
+            },
+        };
+        let bytes = msg.encode();
+        // [SCALE compact-len 0 = 0x00][discriminant][payload]
+        assert_eq!(bytes[0], 0x00);
+        let decoded = ProtocolMessage::decode(&mut &bytes[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    /// Unicode characters round-trip through SCALE string encoding.
+    #[test]
+    fn unicode_request_id_round_trips() {
+        let msg = ProtocolMessage {
+            request_id: "héllo-世界-🦀".to_string(),
+            payload: Payload {
+                id: 22,
+                value: vec![0x00, 0x01],
+            },
+        };
+        let decoded = ProtocolMessage::decode(&mut &msg.encode()[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    /// Large payload (>64KiB) round-trips. Catches buffer-size assumptions
+    /// in the inline-payload read path.
+    #[test]
+    fn large_payload_round_trips() {
+        let big = vec![0xa5u8; 100 * 1024];
+        let msg = build(22, big);
+        let decoded = ProtocolMessage::decode(&mut &msg.encode()[..]).expect("decode");
+        assert_eq!(decoded, msg);
+    }
+
+    #[test]
+    fn encode_decode_error_matches_malformed_frame_variant() {
+        let bytes = encode_decode_error("bad input".to_string());
+        let mut expected = Vec::new();
+        let err: CallError<()> = CallError::MalformedFrame {
+            reason: "bad input".to_string(),
+        };
+        match &err {
+            CallError::MalformedFrame { reason } => {
+                3u8.encode_to(&mut expected);
+                reason.encode_to(&mut expected);
+            }
+            _ => unreachable!(),
+        }
+        assert_eq!(bytes, expected);
+    }
+
+    #[test]
+    fn encode_call_error_payload_matches_call_error_variants() {
+        let denied: CallError<()> = CallError::Denied;
+        assert_eq!(encode_call_error_payload(denied), vec![1u8]);
+
+        let unsupported: CallError<()> = CallError::Unsupported;
+        assert_eq!(encode_call_error_payload(unsupported), vec![2u8]);
+
+        let host: CallError<()> = CallError::HostFailure {
+            reason: "x".to_string(),
+        };
+        let mut expected = vec![4u8];
+        "x".to_string().encode_to(&mut expected);
+        assert_eq!(encode_call_error_payload(host), expected);
+    }
+
+    #[test]
+    fn encode_ok_payload_wraps_success_values() {
+        assert_eq!(encode_ok_payload(()), vec![0u8]);
+
+        let mut expected = vec![0u8];
+        7u32.encode_to(&mut expected);
+        assert_eq!(encode_ok_payload(7u32), expected);
+    }
+
+    /// IdFactory mints monotonically increasing ids prefixed with the
+    /// configured string.
+    #[test]
+    fn id_factory_minted_ids_are_unique_and_monotonic() {
+        let mut factory = IdFactory::new("p:");
+        assert_eq!(factory.next_id(), "p:1");
+        assert_eq!(factory.next_id(), "p:2");
+        assert_eq!(factory.next_id(), "p:3");
+    }
+
+    /// Two distinct factories each maintain their own counter; minting from
+    /// one does not advance the other.
+    #[test]
+    fn two_factories_dont_share_state() {
+        let mut a = IdFactory::new("a:");
+        let mut b = IdFactory::new("b:");
+        assert_eq!(a.next_id(), "a:1");
+        assert_eq!(b.next_id(), "b:1");
+        assert_eq!(a.next_id(), "a:2");
+        assert_eq!(b.next_id(), "b:2");
+    }
+}
diff --git a/rust/crates/truapi-server/src/generated/dispatcher.rs b/rust/crates/truapi-server/src/generated/dispatcher.rs
new file mode 100644
index 00000000..3eb78299
--- /dev/null
+++ b/rust/crates/truapi-server/src/generated/dispatcher.rs
@@ -0,0 +1,1471 @@
+//! Wire dispatcher for the unified `TrUApi` trait.
+//!
+//! Auto-generated by truapi-codegen. Do not edit.
+
+use std::sync::Arc;
+
+use parity_scale_codec::Decode;
+
+use truapi::CallContext;
+use truapi::api::{
+    Account, Chain, Chat, CoinPayment, Entropy, LocalStorage, Notifications, Payment, Permissions,
+    Preimage, ResourceAllocation, Signing, StatementStore, System, Theme,
+};
+use truapi::versioned;
+
+use crate::dispatcher::Dispatcher;
+use crate::frame::{encode_call_error_payload, encode_decode_error, encode_ok_payload};
+use crate::generated::wire_table;
+use crate::subscription::subscription_stream;
+
+/// Register every TrUAPI method with the dispatcher.
+pub fn register<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Account
+        + Chain
+        + Chat
+        + CoinPayment
+        + Entropy
+        + LocalStorage
+        + Notifications
+        + Payment
+        + Permissions
+        + Preimage
+        + ResourceAllocation
+        + Signing
+        + StatementStore
+        + System
+        + Theme
+        + Send
+        + Sync
+        + 'static,
+{
+    register_account(dispatcher, host.clone());
+    register_chain(dispatcher, host.clone());
+    register_chat(dispatcher, host.clone());
+    register_coin_payment(dispatcher, host.clone());
+    register_entropy(dispatcher, host.clone());
+    register_local_storage(dispatcher, host.clone());
+    register_notifications(dispatcher, host.clone());
+    register_payment(dispatcher, host.clone());
+    register_permissions(dispatcher, host.clone());
+    register_preimage(dispatcher, host.clone());
+    register_resource_allocation(dispatcher, host.clone());
+    register_signing(dispatcher, host.clone());
+    register_statement_store(dispatcher, host.clone());
+    register_system(dispatcher, host.clone());
+    register_theme(dispatcher, host);
+}
+
+fn register_account<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Account + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::ACCOUNT_CONNECTION_STATUS_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let _ = bytes;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.connection_status_subscribe(&cx).await;
+                    Ok(subscription_stream::<
+                        versioned::account::HostAccountConnectionStatusSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::ACCOUNT_GET_ACCOUNT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostAccountGetRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostAccountGetResponse =
+                        match host.get_account(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::ACCOUNT_GET_ACCOUNT_ALIAS,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostAccountGetAliasRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostAccountGetAliasResponse =
+                        match host.get_account_alias(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::ACCOUNT_CREATE_ACCOUNT_PROOF,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostAccountCreateProofRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostAccountCreateProofResponse =
+                        match host.create_account_proof(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::ACCOUNT_GET_LEGACY_ACCOUNTS,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostGetLegacyAccountsRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostGetLegacyAccountsResponse =
+                        match host.get_legacy_accounts(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::ACCOUNT_GET_USER_ID,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostGetUserIdRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostGetUserIdResponse =
+                        match host.get_user_id(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::ACCOUNT_REQUEST_LOGIN,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::account::HostRequestLoginRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::account::HostRequestLoginResponse =
+                        match host.request_login(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_chain<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Chain + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::CHAIN_FOLLOW_HEAD_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadFollowRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.follow_head_subscribe(&cx, request).await;
+                    Ok(subscription_stream::<
+                        versioned::chain::RemoteChainHeadFollowItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_HEAD_HEADER,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadHeaderRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadHeaderResponse =
+                        match host.get_head_header(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_HEAD_BODY,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadBodyRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadBodyResponse =
+                        match host.get_head_body(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_HEAD_STORAGE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadStorageRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadStorageResponse =
+                        match host.get_head_storage(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_CALL_HEAD,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadCallRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadCallResponse =
+                        match host.call_head(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_UNPIN_HEAD,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadUnpinRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadUnpinResponse =
+                        match host.unpin_head(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_CONTINUE_HEAD,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadContinueRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadContinueResponse =
+                        match host.continue_head(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_STOP_HEAD_OPERATION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainHeadStopOperationRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainHeadStopOperationResponse =
+                        match host.stop_head_operation(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_SPEC_GENESIS_HASH,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainSpecGenesisHashRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainSpecGenesisHashResponse =
+                        match host.get_spec_genesis_hash(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_SPEC_CHAIN_NAME,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainSpecChainNameRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainSpecChainNameResponse =
+                        match host.get_spec_chain_name(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_GET_SPEC_PROPERTIES,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainSpecPropertiesRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainSpecPropertiesResponse =
+                        match host.get_spec_properties(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAIN_BROADCAST_TRANSACTION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainTransactionBroadcastRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainTransactionBroadcastResponse =
+                        match host.broadcast_transaction(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::CHAIN_STOP_TRANSACTION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chain::RemoteChainTransactionStopRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chain::RemoteChainTransactionStopResponse =
+                        match host.stop_transaction(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_chat<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Chat + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAT_CREATE_ROOM,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chat::HostChatCreateRoomRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chat::HostChatCreateRoomResponse =
+                        match host.create_room(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAT_REGISTER_BOT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chat::HostChatRegisterBotRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chat::HostChatRegisterBotResponse =
+                        match host.register_bot(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::CHAT_LIST_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let _ = bytes;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.list_subscribe(&cx).await;
+                    Ok(subscription_stream::<
+                        versioned::chat::HostChatListSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::CHAT_POST_MESSAGE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chat::HostChatPostMessageRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::chat::HostChatPostMessageResponse =
+                        match host.post_message(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::CHAT_ACTION_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let _ = bytes;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.action_subscribe(&cx).await;
+                    Ok(subscription_stream::<
+                        versioned::chat::HostChatActionSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_subscription(
+            wire_table::CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::chat::ProductChatCustomMessageRenderSubscribeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.custom_message_render_subscribe(&cx, request).await;
+                    Ok(subscription_stream::<
+                        versioned::chat::ProductChatCustomMessageRenderSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+}
+
+fn register_coin_payment<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: CoinPayment + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::COIN_PAYMENT_CREATE_PURSE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentCreatePurseRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::coin_payment::HostCoinPaymentCreatePurseResponse =
+                        match host.create_purse(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::COIN_PAYMENT_QUERY_PURSE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentQueryPurseRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::coin_payment::HostCoinPaymentQueryPurseResponse =
+                        match host.query_purse(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::COIN_PAYMENT_REBALANCE_PURSE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentRebalancePurseRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.rebalance_purse(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::coin_payment::HostCoinPaymentRebalancePurseItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::COIN_PAYMENT_DELETE_PURSE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentDeletePurseRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.delete_purse(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::coin_payment::HostCoinPaymentDeletePurseItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::COIN_PAYMENT_CREATE_RECEIVABLE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentCreateReceivableRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::coin_payment::HostCoinPaymentCreateReceivableResponse =
+                        match host.create_receivable(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::COIN_PAYMENT_CREATE_CHEQUE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentCreateChequeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::coin_payment::HostCoinPaymentCreateChequeResponse =
+                        match host.create_cheque(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::COIN_PAYMENT_DEPOSIT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentDepositRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.deposit(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::coin_payment::HostCoinPaymentDepositItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::COIN_PAYMENT_REFUND,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentRefundRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.refund(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::coin_payment::HostCoinPaymentRefundItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_subscription(
+            wire_table::COIN_PAYMENT_LISTEN_FOR_PAYMENT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::coin_payment::HostCoinPaymentListenForRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.listen_for_payment(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::coin_payment::HostCoinPaymentListenForItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+}
+
+fn register_entropy<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Entropy + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::ENTROPY_DERIVE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::entropy::HostDeriveEntropyRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::entropy::HostDeriveEntropyResponse =
+                        match host.derive(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_local_storage<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: LocalStorage + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::LOCAL_STORAGE_READ,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::local_storage::HostLocalStorageReadRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::local_storage::HostLocalStorageReadResponse =
+                        match host.read(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::LOCAL_STORAGE_WRITE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::local_storage::HostLocalStorageWriteRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::local_storage::HostLocalStorageWriteResponse =
+                        match host.write(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::LOCAL_STORAGE_CLEAR,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::local_storage::HostLocalStorageClearRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::local_storage::HostLocalStorageClearResponse =
+                        match host.clear(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_notifications<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Notifications + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::NOTIFICATIONS_SEND_PUSH_NOTIFICATION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::notifications::HostPushNotificationRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::notifications::HostPushNotificationResponse =
+                        match host.send_push_notification(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::notifications::HostPushNotificationCancelRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::notifications::HostPushNotificationCancelResponse =
+                        match host.cancel_push_notification(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_payment<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Payment + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::PAYMENT_BALANCE_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::payment::HostPaymentBalanceSubscribeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.balance_subscribe(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::payment::HostPaymentBalanceSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::PAYMENT_REQUEST,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::payment::HostPaymentRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::payment::HostPaymentResponse =
+                        match host.request(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::PAYMENT_STATUS_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::payment::HostPaymentStatusSubscribeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.status_subscribe(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::payment::HostPaymentStatusSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::PAYMENT_TOP_UP,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::payment::HostPaymentTopUpRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::payment::HostPaymentTopUpResponse =
+                        match host.top_up(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_permissions<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Permissions + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::PERMISSIONS_REQUEST_DEVICE_PERMISSION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::permissions::HostDevicePermissionRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::permissions::HostDevicePermissionResponse =
+                        match host.request_device_permission(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::PERMISSIONS_REQUEST_REMOTE_PERMISSION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::permissions::RemotePermissionRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::permissions::RemotePermissionResponse =
+                        match host.request_remote_permission(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_preimage<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Preimage + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::PREIMAGE_LOOKUP_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::preimage::RemotePreimageLookupSubscribeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.lookup_subscribe(&cx, request).await;
+                    Ok(subscription_stream::<
+                        versioned::preimage::RemotePreimageLookupSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::PREIMAGE_SUBMIT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::preimage::RemotePreimageSubmitRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::preimage::RemotePreimageSubmitResponse =
+                        match host.submit(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_resource_allocation<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: ResourceAllocation + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_request(wire_table::RESOURCE_ALLOCATION_REQUEST, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::resource_allocation::HostRequestResourceAllocationRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::resource_allocation::HostRequestResourceAllocationResponse = match host.request(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+}
+
+fn register_signing<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Signing + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SIGNING_CREATE_TRANSACTION,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::signing::HostCreateTransactionRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::signing::HostCreateTransactionResponse =
+                        match host.create_transaction(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::signing::HostCreateTransactionWithLegacyAccountRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::signing::HostCreateTransactionWithLegacyAccountResponse = match host.create_transaction_with_legacy_account(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::signing::HostSignRawWithLegacyAccountRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::signing::HostSignRawWithLegacyAccountResponse =
+                        match host.sign_raw_with_legacy_account(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::signing::HostSignPayloadWithLegacyAccountRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::signing::HostSignPayloadWithLegacyAccountResponse =
+                        match host.sign_payload_with_legacy_account(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SIGNING_SIGN_RAW,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::signing::HostSignRawRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::signing::HostSignRawResponse =
+                        match host.sign_raw(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::SIGNING_SIGN_PAYLOAD,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::signing::HostSignPayloadRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::signing::HostSignPayloadResponse =
+                        match host.sign_payload(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_statement_store<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: StatementStore + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_subscription(
+            wire_table::STATEMENT_STORE_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::statement_store::RemoteStatementStoreSubscribeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = match host.subscribe(&cx, request).await {
+                        Ok(sub) => sub,
+                        Err(err) => return Err(encode_call_error_payload(err)),
+                    };
+                    Ok(subscription_stream::<
+                        versioned::statement_store::RemoteStatementStoreSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::STATEMENT_STORE_CREATE_PROOF, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreCreateProofRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::statement_store::RemoteStatementStoreCreateProofResponse = match host.create_proof(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(wire_table::STATEMENT_STORE_CREATE_PROOF_AUTHORIZED, move |request_id: String, bytes: Vec<u8>| {
+            let host = host.clone();
+            Box::pin(async move {
+                let request: versioned::statement_store::RemoteStatementStoreCreateProofAuthorizedRequest =
+                    Decode::decode(&mut &bytes[..]).map_err(|e| encode_decode_error(e.to_string()))?;
+                let cx = CallContext::with_request_id(request_id.clone());
+                let response: versioned::statement_store::RemoteStatementStoreCreateProofAuthorizedResponse = match host.create_proof_authorized(&cx, request).await {
+                    Ok(value) => value,
+                    Err(err) => return Err(encode_call_error_payload(err)),
+                };
+                Ok(encode_ok_payload(response))
+            })
+        });
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::STATEMENT_STORE_SUBMIT,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::statement_store::RemoteStatementStoreSubmitRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    match host.submit(&cx, request).await {
+                        Ok(()) => Ok(encode_ok_payload(())),
+                        Err(err) => Err(encode_call_error_payload(err)),
+                    }
+                })
+            },
+        );
+    }
+}
+
+fn register_system<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: System + Send + Sync + 'static,
+{
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SYSTEM_HANDSHAKE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::system::HostHandshakeRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::system::HostHandshakeResponse =
+                        match host.handshake(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host.clone();
+        dispatcher.on_request(
+            wire_table::SYSTEM_FEATURE_SUPPORTED,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::system::HostFeatureSupportedRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::system::HostFeatureSupportedResponse =
+                        match host.feature_supported(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+    {
+        let host = host;
+        dispatcher.on_request(
+            wire_table::SYSTEM_NAVIGATE_TO,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let request: versioned::system::HostNavigateToRequest =
+                        Decode::decode(&mut &bytes[..])
+                            .map_err(|e| encode_decode_error(e.to_string()))?;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let response: versioned::system::HostNavigateToResponse =
+                        match host.navigate_to(&cx, request).await {
+                            Ok(value) => value,
+                            Err(err) => return Err(encode_call_error_payload(err)),
+                        };
+                    Ok(encode_ok_payload(response))
+                })
+            },
+        );
+    }
+}
+
+fn register_theme<P>(dispatcher: &mut Dispatcher, host: Arc<P>)
+where
+    P: Theme + Send + Sync + 'static,
+{
+    {
+        let host = host;
+        dispatcher.on_subscription(
+            wire_table::THEME_SUBSCRIBE,
+            move |request_id: String, bytes: Vec<u8>| {
+                let host = host.clone();
+                Box::pin(async move {
+                    let _ = bytes;
+                    let cx = CallContext::with_request_id(request_id.clone());
+                    let stream = host.subscribe(&cx).await;
+                    Ok(subscription_stream::<
+                        versioned::theme::HostThemeSubscribeItem,
+                        _,
+                    >(stream))
+                })
+            },
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/generated/mod.rs b/rust/crates/truapi-server/src/generated/mod.rs
new file mode 100644
index 00000000..770a015d
--- /dev/null
+++ b/rust/crates/truapi-server/src/generated/mod.rs
@@ -0,0 +1,4 @@
+//! Generated by truapi-codegen. Do not edit.
+
+pub mod dispatcher;
+pub mod wire_table;
diff --git a/rust/crates/truapi-server/src/generated/wire_table.rs b/rust/crates/truapi-server/src/generated/wire_table.rs
new file mode 100644
index 00000000..12a72a94
--- /dev/null
+++ b/rust/crates/truapi-server/src/generated/wire_table.rs
@@ -0,0 +1,722 @@
+//! Wire-protocol discriminant table.
+//!
+//! Auto-generated by truapi-codegen. Do not edit.
+//!
+//! Each method reserves either two ids (request/response) or four
+//! (start/stop/interrupt/receive). The ids for each method are exposed
+//! as a named const (`PREIMAGE_SUBMIT`, ...); [`WIRE_TABLE`] and the
+//! generated dispatcher both reference those consts so the numbers live
+//! in exactly one place. The table is sorted by request/start id.
+
+/// Request method wire discriminants.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RequestFrameIds {
+    /// Discriminant for the request frame.
+    pub request_id: u8,
+    /// Discriminant for the response frame.
+    pub response_id: u8,
+}
+
+/// Subscription method wire discriminants.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SubscriptionFrameIds {
+    /// Discriminant for the start frame.
+    pub start_id: u8,
+    /// Discriminant for the stop frame.
+    pub stop_id: u8,
+    /// Discriminant for the interrupt frame (server-initiated termination).
+    pub interrupt_id: u8,
+    /// Discriminant for each receive frame (a streamed item).
+    pub receive_id: u8,
+}
+
+/// A single wire-table row.
+pub struct WireEntry {
+    /// Method name from the Rust trait.
+    pub method: &'static str,
+    /// What kind of slot this entry describes.
+    pub kind: WireKind,
+}
+
+/// Wire-slot shape: request/response pair or subscription quartet.
+pub enum WireKind {
+    /// Request/response method.
+    Request(RequestFrameIds),
+    /// Subscription method.
+    Subscription(SubscriptionFrameIds),
+}
+
+/// Wire discriminants for `system_handshake`.
+pub const SYSTEM_HANDSHAKE: RequestFrameIds = RequestFrameIds {
+    request_id: 0,
+    response_id: 1,
+};
+
+/// Wire discriminants for `system_feature_supported`.
+pub const SYSTEM_FEATURE_SUPPORTED: RequestFrameIds = RequestFrameIds {
+    request_id: 2,
+    response_id: 3,
+};
+
+/// Wire discriminants for `notifications_send_push_notification`.
+pub const NOTIFICATIONS_SEND_PUSH_NOTIFICATION: RequestFrameIds = RequestFrameIds {
+    request_id: 4,
+    response_id: 5,
+};
+
+/// Wire discriminants for `system_navigate_to`.
+pub const SYSTEM_NAVIGATE_TO: RequestFrameIds = RequestFrameIds {
+    request_id: 6,
+    response_id: 7,
+};
+
+/// Wire discriminants for `permissions_request_device_permission`.
+pub const PERMISSIONS_REQUEST_DEVICE_PERMISSION: RequestFrameIds = RequestFrameIds {
+    request_id: 8,
+    response_id: 9,
+};
+
+/// Wire discriminants for `permissions_request_remote_permission`.
+pub const PERMISSIONS_REQUEST_REMOTE_PERMISSION: RequestFrameIds = RequestFrameIds {
+    request_id: 10,
+    response_id: 11,
+};
+
+/// Wire discriminants for `local_storage_read`.
+pub const LOCAL_STORAGE_READ: RequestFrameIds = RequestFrameIds {
+    request_id: 12,
+    response_id: 13,
+};
+
+/// Wire discriminants for `local_storage_write`.
+pub const LOCAL_STORAGE_WRITE: RequestFrameIds = RequestFrameIds {
+    request_id: 14,
+    response_id: 15,
+};
+
+/// Wire discriminants for `local_storage_clear`.
+pub const LOCAL_STORAGE_CLEAR: RequestFrameIds = RequestFrameIds {
+    request_id: 16,
+    response_id: 17,
+};
+
+/// Wire discriminants for `account_connection_status_subscribe`.
+pub const ACCOUNT_CONNECTION_STATUS_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 18,
+    stop_id: 19,
+    interrupt_id: 20,
+    receive_id: 21,
+};
+
+/// Wire discriminants for `account_get_account`.
+pub const ACCOUNT_GET_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 22,
+    response_id: 23,
+};
+
+/// Wire discriminants for `account_get_account_alias`.
+pub const ACCOUNT_GET_ACCOUNT_ALIAS: RequestFrameIds = RequestFrameIds {
+    request_id: 24,
+    response_id: 25,
+};
+
+/// Wire discriminants for `account_create_account_proof`.
+pub const ACCOUNT_CREATE_ACCOUNT_PROOF: RequestFrameIds = RequestFrameIds {
+    request_id: 26,
+    response_id: 27,
+};
+
+/// Wire discriminants for `account_get_legacy_accounts`.
+pub const ACCOUNT_GET_LEGACY_ACCOUNTS: RequestFrameIds = RequestFrameIds {
+    request_id: 28,
+    response_id: 29,
+};
+
+/// Wire discriminants for `signing_create_transaction`.
+pub const SIGNING_CREATE_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 30,
+    response_id: 31,
+};
+
+/// Wire discriminants for `signing_create_transaction_with_legacy_account`.
+pub const SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 32,
+    response_id: 33,
+};
+
+/// Wire discriminants for `signing_sign_raw_with_legacy_account`.
+pub const SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 34,
+    response_id: 35,
+};
+
+/// Wire discriminants for `signing_sign_payload_with_legacy_account`.
+pub const SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT: RequestFrameIds = RequestFrameIds {
+    request_id: 36,
+    response_id: 37,
+};
+
+/// Wire discriminants for `chat_create_room`.
+pub const CHAT_CREATE_ROOM: RequestFrameIds = RequestFrameIds {
+    request_id: 38,
+    response_id: 39,
+};
+
+/// Wire discriminants for `chat_register_bot`.
+pub const CHAT_REGISTER_BOT: RequestFrameIds = RequestFrameIds {
+    request_id: 40,
+    response_id: 41,
+};
+
+/// Wire discriminants for `chat_list_subscribe`.
+pub const CHAT_LIST_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 42,
+    stop_id: 43,
+    interrupt_id: 44,
+    receive_id: 45,
+};
+
+/// Wire discriminants for `chat_post_message`.
+pub const CHAT_POST_MESSAGE: RequestFrameIds = RequestFrameIds {
+    request_id: 46,
+    response_id: 47,
+};
+
+/// Wire discriminants for `chat_action_subscribe`.
+pub const CHAT_ACTION_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 48,
+    stop_id: 49,
+    interrupt_id: 50,
+    receive_id: 51,
+};
+
+/// Wire discriminants for `chat_custom_message_render_subscribe`.
+pub const CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 52,
+    stop_id: 53,
+    interrupt_id: 54,
+    receive_id: 55,
+};
+
+/// Wire discriminants for `statement_store_subscribe`.
+pub const STATEMENT_STORE_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 56,
+    stop_id: 57,
+    interrupt_id: 58,
+    receive_id: 59,
+};
+
+/// Wire discriminants for `statement_store_create_proof`.
+pub const STATEMENT_STORE_CREATE_PROOF: RequestFrameIds = RequestFrameIds {
+    request_id: 60,
+    response_id: 61,
+};
+
+/// Wire discriminants for `statement_store_submit`.
+pub const STATEMENT_STORE_SUBMIT: RequestFrameIds = RequestFrameIds {
+    request_id: 62,
+    response_id: 63,
+};
+
+/// Wire discriminants for `preimage_lookup_subscribe`.
+pub const PREIMAGE_LOOKUP_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 64,
+    stop_id: 65,
+    interrupt_id: 66,
+    receive_id: 67,
+};
+
+/// Wire discriminants for `preimage_submit`.
+pub const PREIMAGE_SUBMIT: RequestFrameIds = RequestFrameIds {
+    request_id: 68,
+    response_id: 69,
+};
+
+/// Wire discriminants for `chain_follow_head_subscribe`.
+pub const CHAIN_FOLLOW_HEAD_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 76,
+    stop_id: 77,
+    interrupt_id: 78,
+    receive_id: 79,
+};
+
+/// Wire discriminants for `chain_get_head_header`.
+pub const CHAIN_GET_HEAD_HEADER: RequestFrameIds = RequestFrameIds {
+    request_id: 80,
+    response_id: 81,
+};
+
+/// Wire discriminants for `chain_get_head_body`.
+pub const CHAIN_GET_HEAD_BODY: RequestFrameIds = RequestFrameIds {
+    request_id: 82,
+    response_id: 83,
+};
+
+/// Wire discriminants for `chain_get_head_storage`.
+pub const CHAIN_GET_HEAD_STORAGE: RequestFrameIds = RequestFrameIds {
+    request_id: 84,
+    response_id: 85,
+};
+
+/// Wire discriminants for `chain_call_head`.
+pub const CHAIN_CALL_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 86,
+    response_id: 87,
+};
+
+/// Wire discriminants for `chain_unpin_head`.
+pub const CHAIN_UNPIN_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 88,
+    response_id: 89,
+};
+
+/// Wire discriminants for `chain_continue_head`.
+pub const CHAIN_CONTINUE_HEAD: RequestFrameIds = RequestFrameIds {
+    request_id: 90,
+    response_id: 91,
+};
+
+/// Wire discriminants for `chain_stop_head_operation`.
+pub const CHAIN_STOP_HEAD_OPERATION: RequestFrameIds = RequestFrameIds {
+    request_id: 92,
+    response_id: 93,
+};
+
+/// Wire discriminants for `chain_get_spec_genesis_hash`.
+pub const CHAIN_GET_SPEC_GENESIS_HASH: RequestFrameIds = RequestFrameIds {
+    request_id: 94,
+    response_id: 95,
+};
+
+/// Wire discriminants for `chain_get_spec_chain_name`.
+pub const CHAIN_GET_SPEC_CHAIN_NAME: RequestFrameIds = RequestFrameIds {
+    request_id: 96,
+    response_id: 97,
+};
+
+/// Wire discriminants for `chain_get_spec_properties`.
+pub const CHAIN_GET_SPEC_PROPERTIES: RequestFrameIds = RequestFrameIds {
+    request_id: 98,
+    response_id: 99,
+};
+
+/// Wire discriminants for `chain_broadcast_transaction`.
+pub const CHAIN_BROADCAST_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 100,
+    response_id: 101,
+};
+
+/// Wire discriminants for `chain_stop_transaction`.
+pub const CHAIN_STOP_TRANSACTION: RequestFrameIds = RequestFrameIds {
+    request_id: 102,
+    response_id: 103,
+};
+
+/// Wire discriminants for `theme_subscribe`.
+pub const THEME_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 104,
+    stop_id: 105,
+    interrupt_id: 106,
+    receive_id: 107,
+};
+
+/// Wire discriminants for `entropy_derive`.
+pub const ENTROPY_DERIVE: RequestFrameIds = RequestFrameIds {
+    request_id: 108,
+    response_id: 109,
+};
+
+/// Wire discriminants for `account_get_user_id`.
+pub const ACCOUNT_GET_USER_ID: RequestFrameIds = RequestFrameIds {
+    request_id: 110,
+    response_id: 111,
+};
+
+/// Wire discriminants for `account_request_login`.
+pub const ACCOUNT_REQUEST_LOGIN: RequestFrameIds = RequestFrameIds {
+    request_id: 112,
+    response_id: 113,
+};
+
+/// Wire discriminants for `signing_sign_raw`.
+pub const SIGNING_SIGN_RAW: RequestFrameIds = RequestFrameIds {
+    request_id: 114,
+    response_id: 115,
+};
+
+/// Wire discriminants for `signing_sign_payload`.
+pub const SIGNING_SIGN_PAYLOAD: RequestFrameIds = RequestFrameIds {
+    request_id: 116,
+    response_id: 117,
+};
+
+/// Wire discriminants for `payment_balance_subscribe`.
+pub const PAYMENT_BALANCE_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 118,
+    stop_id: 119,
+    interrupt_id: 120,
+    receive_id: 121,
+};
+
+/// Wire discriminants for `payment_top_up`.
+pub const PAYMENT_TOP_UP: RequestFrameIds = RequestFrameIds {
+    request_id: 122,
+    response_id: 123,
+};
+
+/// Wire discriminants for `payment_request`.
+pub const PAYMENT_REQUEST: RequestFrameIds = RequestFrameIds {
+    request_id: 124,
+    response_id: 125,
+};
+
+/// Wire discriminants for `payment_status_subscribe`.
+pub const PAYMENT_STATUS_SUBSCRIBE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 126,
+    stop_id: 127,
+    interrupt_id: 128,
+    receive_id: 129,
+};
+
+/// Wire discriminants for `resource_allocation_request`.
+pub const RESOURCE_ALLOCATION_REQUEST: RequestFrameIds = RequestFrameIds {
+    request_id: 130,
+    response_id: 131,
+};
+
+/// Wire discriminants for `statement_store_create_proof_authorized`.
+pub const STATEMENT_STORE_CREATE_PROOF_AUTHORIZED: RequestFrameIds = RequestFrameIds {
+    request_id: 132,
+    response_id: 133,
+};
+
+/// Wire discriminants for `notifications_cancel_push_notification`.
+pub const NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION: RequestFrameIds = RequestFrameIds {
+    request_id: 134,
+    response_id: 135,
+};
+
+/// Wire discriminants for `coin_payment_create_purse`.
+pub const COIN_PAYMENT_CREATE_PURSE: RequestFrameIds = RequestFrameIds {
+    request_id: 136,
+    response_id: 137,
+};
+
+/// Wire discriminants for `coin_payment_query_purse`.
+pub const COIN_PAYMENT_QUERY_PURSE: RequestFrameIds = RequestFrameIds {
+    request_id: 138,
+    response_id: 139,
+};
+
+/// Wire discriminants for `coin_payment_rebalance_purse`.
+pub const COIN_PAYMENT_REBALANCE_PURSE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 140,
+    stop_id: 141,
+    interrupt_id: 142,
+    receive_id: 143,
+};
+
+/// Wire discriminants for `coin_payment_delete_purse`.
+pub const COIN_PAYMENT_DELETE_PURSE: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 144,
+    stop_id: 145,
+    interrupt_id: 146,
+    receive_id: 147,
+};
+
+/// Wire discriminants for `coin_payment_create_receivable`.
+pub const COIN_PAYMENT_CREATE_RECEIVABLE: RequestFrameIds = RequestFrameIds {
+    request_id: 148,
+    response_id: 149,
+};
+
+/// Wire discriminants for `coin_payment_create_cheque`.
+pub const COIN_PAYMENT_CREATE_CHEQUE: RequestFrameIds = RequestFrameIds {
+    request_id: 150,
+    response_id: 151,
+};
+
+/// Wire discriminants for `coin_payment_deposit`.
+pub const COIN_PAYMENT_DEPOSIT: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 152,
+    stop_id: 153,
+    interrupt_id: 154,
+    receive_id: 155,
+};
+
+/// Wire discriminants for `coin_payment_refund`.
+pub const COIN_PAYMENT_REFUND: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 156,
+    stop_id: 157,
+    interrupt_id: 158,
+    receive_id: 159,
+};
+
+/// Wire discriminants for `coin_payment_listen_for_payment`.
+pub const COIN_PAYMENT_LISTEN_FOR_PAYMENT: SubscriptionFrameIds = SubscriptionFrameIds {
+    start_id: 160,
+    stop_id: 161,
+    interrupt_id: 162,
+    receive_id: 163,
+};
+
+/// The full wire table. Ordering is part of the wire protocol;
+/// only ever append. Removed methods leave their slot empty.
+pub const WIRE_TABLE: &[WireEntry] = &[
+    WireEntry {
+        method: "system_handshake",
+        kind: WireKind::Request(SYSTEM_HANDSHAKE),
+    },
+    WireEntry {
+        method: "system_feature_supported",
+        kind: WireKind::Request(SYSTEM_FEATURE_SUPPORTED),
+    },
+    WireEntry {
+        method: "notifications_send_push_notification",
+        kind: WireKind::Request(NOTIFICATIONS_SEND_PUSH_NOTIFICATION),
+    },
+    WireEntry {
+        method: "system_navigate_to",
+        kind: WireKind::Request(SYSTEM_NAVIGATE_TO),
+    },
+    WireEntry {
+        method: "permissions_request_device_permission",
+        kind: WireKind::Request(PERMISSIONS_REQUEST_DEVICE_PERMISSION),
+    },
+    WireEntry {
+        method: "permissions_request_remote_permission",
+        kind: WireKind::Request(PERMISSIONS_REQUEST_REMOTE_PERMISSION),
+    },
+    WireEntry {
+        method: "local_storage_read",
+        kind: WireKind::Request(LOCAL_STORAGE_READ),
+    },
+    WireEntry {
+        method: "local_storage_write",
+        kind: WireKind::Request(LOCAL_STORAGE_WRITE),
+    },
+    WireEntry {
+        method: "local_storage_clear",
+        kind: WireKind::Request(LOCAL_STORAGE_CLEAR),
+    },
+    WireEntry {
+        method: "account_connection_status_subscribe",
+        kind: WireKind::Subscription(ACCOUNT_CONNECTION_STATUS_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "account_get_account",
+        kind: WireKind::Request(ACCOUNT_GET_ACCOUNT),
+    },
+    WireEntry {
+        method: "account_get_account_alias",
+        kind: WireKind::Request(ACCOUNT_GET_ACCOUNT_ALIAS),
+    },
+    WireEntry {
+        method: "account_create_account_proof",
+        kind: WireKind::Request(ACCOUNT_CREATE_ACCOUNT_PROOF),
+    },
+    WireEntry {
+        method: "account_get_legacy_accounts",
+        kind: WireKind::Request(ACCOUNT_GET_LEGACY_ACCOUNTS),
+    },
+    WireEntry {
+        method: "signing_create_transaction",
+        kind: WireKind::Request(SIGNING_CREATE_TRANSACTION),
+    },
+    WireEntry {
+        method: "signing_create_transaction_with_legacy_account",
+        kind: WireKind::Request(SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "signing_sign_raw_with_legacy_account",
+        kind: WireKind::Request(SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "signing_sign_payload_with_legacy_account",
+        kind: WireKind::Request(SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT),
+    },
+    WireEntry {
+        method: "chat_create_room",
+        kind: WireKind::Request(CHAT_CREATE_ROOM),
+    },
+    WireEntry {
+        method: "chat_register_bot",
+        kind: WireKind::Request(CHAT_REGISTER_BOT),
+    },
+    WireEntry {
+        method: "chat_list_subscribe",
+        kind: WireKind::Subscription(CHAT_LIST_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chat_post_message",
+        kind: WireKind::Request(CHAT_POST_MESSAGE),
+    },
+    WireEntry {
+        method: "chat_action_subscribe",
+        kind: WireKind::Subscription(CHAT_ACTION_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chat_custom_message_render_subscribe",
+        kind: WireKind::Subscription(CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "statement_store_subscribe",
+        kind: WireKind::Subscription(STATEMENT_STORE_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "statement_store_create_proof",
+        kind: WireKind::Request(STATEMENT_STORE_CREATE_PROOF),
+    },
+    WireEntry {
+        method: "statement_store_submit",
+        kind: WireKind::Request(STATEMENT_STORE_SUBMIT),
+    },
+    WireEntry {
+        method: "preimage_lookup_subscribe",
+        kind: WireKind::Subscription(PREIMAGE_LOOKUP_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "preimage_submit",
+        kind: WireKind::Request(PREIMAGE_SUBMIT),
+    },
+    WireEntry {
+        method: "chain_follow_head_subscribe",
+        kind: WireKind::Subscription(CHAIN_FOLLOW_HEAD_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "chain_get_head_header",
+        kind: WireKind::Request(CHAIN_GET_HEAD_HEADER),
+    },
+    WireEntry {
+        method: "chain_get_head_body",
+        kind: WireKind::Request(CHAIN_GET_HEAD_BODY),
+    },
+    WireEntry {
+        method: "chain_get_head_storage",
+        kind: WireKind::Request(CHAIN_GET_HEAD_STORAGE),
+    },
+    WireEntry {
+        method: "chain_call_head",
+        kind: WireKind::Request(CHAIN_CALL_HEAD),
+    },
+    WireEntry {
+        method: "chain_unpin_head",
+        kind: WireKind::Request(CHAIN_UNPIN_HEAD),
+    },
+    WireEntry {
+        method: "chain_continue_head",
+        kind: WireKind::Request(CHAIN_CONTINUE_HEAD),
+    },
+    WireEntry {
+        method: "chain_stop_head_operation",
+        kind: WireKind::Request(CHAIN_STOP_HEAD_OPERATION),
+    },
+    WireEntry {
+        method: "chain_get_spec_genesis_hash",
+        kind: WireKind::Request(CHAIN_GET_SPEC_GENESIS_HASH),
+    },
+    WireEntry {
+        method: "chain_get_spec_chain_name",
+        kind: WireKind::Request(CHAIN_GET_SPEC_CHAIN_NAME),
+    },
+    WireEntry {
+        method: "chain_get_spec_properties",
+        kind: WireKind::Request(CHAIN_GET_SPEC_PROPERTIES),
+    },
+    WireEntry {
+        method: "chain_broadcast_transaction",
+        kind: WireKind::Request(CHAIN_BROADCAST_TRANSACTION),
+    },
+    WireEntry {
+        method: "chain_stop_transaction",
+        kind: WireKind::Request(CHAIN_STOP_TRANSACTION),
+    },
+    WireEntry {
+        method: "theme_subscribe",
+        kind: WireKind::Subscription(THEME_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "entropy_derive",
+        kind: WireKind::Request(ENTROPY_DERIVE),
+    },
+    WireEntry {
+        method: "account_get_user_id",
+        kind: WireKind::Request(ACCOUNT_GET_USER_ID),
+    },
+    WireEntry {
+        method: "account_request_login",
+        kind: WireKind::Request(ACCOUNT_REQUEST_LOGIN),
+    },
+    WireEntry {
+        method: "signing_sign_raw",
+        kind: WireKind::Request(SIGNING_SIGN_RAW),
+    },
+    WireEntry {
+        method: "signing_sign_payload",
+        kind: WireKind::Request(SIGNING_SIGN_PAYLOAD),
+    },
+    WireEntry {
+        method: "payment_balance_subscribe",
+        kind: WireKind::Subscription(PAYMENT_BALANCE_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "payment_top_up",
+        kind: WireKind::Request(PAYMENT_TOP_UP),
+    },
+    WireEntry {
+        method: "payment_request",
+        kind: WireKind::Request(PAYMENT_REQUEST),
+    },
+    WireEntry {
+        method: "payment_status_subscribe",
+        kind: WireKind::Subscription(PAYMENT_STATUS_SUBSCRIBE),
+    },
+    WireEntry {
+        method: "resource_allocation_request",
+        kind: WireKind::Request(RESOURCE_ALLOCATION_REQUEST),
+    },
+    WireEntry {
+        method: "statement_store_create_proof_authorized",
+        kind: WireKind::Request(STATEMENT_STORE_CREATE_PROOF_AUTHORIZED),
+    },
+    WireEntry {
+        method: "notifications_cancel_push_notification",
+        kind: WireKind::Request(NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION),
+    },
+    WireEntry {
+        method: "coin_payment_create_purse",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_query_purse",
+        kind: WireKind::Request(COIN_PAYMENT_QUERY_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_rebalance_purse",
+        kind: WireKind::Subscription(COIN_PAYMENT_REBALANCE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_delete_purse",
+        kind: WireKind::Subscription(COIN_PAYMENT_DELETE_PURSE),
+    },
+    WireEntry {
+        method: "coin_payment_create_receivable",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_RECEIVABLE),
+    },
+    WireEntry {
+        method: "coin_payment_create_cheque",
+        kind: WireKind::Request(COIN_PAYMENT_CREATE_CHEQUE),
+    },
+    WireEntry {
+        method: "coin_payment_deposit",
+        kind: WireKind::Subscription(COIN_PAYMENT_DEPOSIT),
+    },
+    WireEntry {
+        method: "coin_payment_refund",
+        kind: WireKind::Subscription(COIN_PAYMENT_REFUND),
+    },
+    WireEntry {
+        method: "coin_payment_listen_for_payment",
+        kind: WireKind::Subscription(COIN_PAYMENT_LISTEN_FOR_PAYMENT),
+    },
+];
diff --git a/rust/crates/truapi-server/src/host_logic/dotns.rs b/rust/crates/truapi-server/src/host_logic/dotns.rs
new file mode 100644
index 00000000..3c8dafda
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/dotns.rs
@@ -0,0 +1,562 @@
+//! dotns URL parsing, normalization, and classification.
+//!
+//! The Rust core owns the whole decision so every platform host sees the
+//! same categorization and the `navigate_to` callback only receives
+//! already-validated input.
+
+use unicode_normalization::UnicodeNormalization;
+use url::Url;
+
+/// How the input URL should be opened. Kept in one enum rather than passing
+/// a raw string so the dispatcher can reject invalid input before reaching
+/// any platform callback.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NavigateDecision {
+    /// A `.dot` identifier plus path/query/hash suffix (no leading `/`).
+    DotName {
+        /// Lower-cased `.dot` host (e.g. `mytestapp.dot`).
+        identifier: String,
+        /// Path/query/hash suffix without a leading `/`.
+        path: String,
+    },
+    /// A `localhost[:port]` URL plus path/query/hash suffix (no leading `/`).
+    Localhost {
+        /// `localhost` with optional `:port` suffix.
+        host: String,
+        /// Path/query/hash suffix without a leading `/`.
+        path: String,
+    },
+    /// An absolute external URL with an `http(s):` scheme prepended if missing.
+    External {
+        /// Canonical URL string.
+        url: String,
+    },
+    /// Input that fails every branch: empty, unparseable, or a `.dot` URL
+    /// carrying port/userinfo (both forbidden since dotns resolves via the
+    /// chain and has no notion of either).
+    Reject {
+        /// Human-readable reason for the rejection.
+        reason: String,
+    },
+}
+
+impl NavigateDecision {
+    /// Canonical URL string for the three `Open*` variants; `None` for
+    /// `Reject`. `DotName` and `Localhost` keep the dotns/localhost identity
+    /// visible so env-aware hosts (e.g. dotli rewriting `.dot` to `.dot.li`)
+    /// can re-parse and do their own assembly without losing information.
+    pub fn canonical_url(&self) -> Option<String> {
+        match self {
+            Self::DotName { identifier, path } => Some(join_url("https://", identifier, path)),
+            Self::Localhost { host, path } => Some(join_url("http://", host, path)),
+            Self::External { url } => Some(url.clone()),
+            Self::Reject { .. } => None,
+        }
+    }
+}
+
+fn join_url(scheme: &str, host: &str, path: &str) -> String {
+    if path.is_empty() {
+        format!("{scheme}{host}")
+    } else {
+        format!("{scheme}{host}/{path}")
+    }
+}
+
+/// Classify a URL the way dotli's `handleNavigateTo` does: try `.dot` first,
+/// then `localhost`, then normalize as external.
+pub fn parse_navigate(input: &str) -> NavigateDecision {
+    let trimmed = input.trim();
+    if trimmed.is_empty() {
+        return NavigateDecision::Reject {
+            reason: "empty input".to_string(),
+        };
+    }
+
+    if let Some(decision) = classify_dot(trimmed) {
+        return decision;
+    }
+
+    if let Some(decision) = classify_localhost(trimmed) {
+        return decision;
+    }
+
+    match normalize_external(trimmed) {
+        Ok(url) => NavigateDecision::External { url },
+        Err(reason) => NavigateDecision::Reject { reason },
+    }
+}
+
+/// Canonical host form: case-folded and NFC-normalized (belt-and-suspenders;
+/// `url` already applies IDNA to parsed hosts), with a trailing root dot
+/// dropped so the absolute form `example.dot.` keys identically to
+/// `example.dot`.
+fn normalize_host(host: &str) -> String {
+    let normalized: String = host.nfc().collect::<String>().to_lowercase();
+    normalized
+        .strip_suffix('.')
+        .unwrap_or(&normalized)
+        .to_string()
+}
+
+/// `.dot` TLD check, applied to the [`normalize_host`] form so `Example.DOT`
+/// and the trailing-dot FQDN `example.dot.` classify like `example.dot`.
+fn is_dot_domain(host: &str) -> bool {
+    normalize_host(host).ends_with(".dot")
+}
+
+fn parse_with_explicit_https(input: &str) -> Option<Url> {
+    if let Ok(direct) = Url::parse(input) {
+        return Some(direct);
+    }
+    Url::parse(&format!("https://{input}")).ok()
+}
+
+/// Recognize `.dot` URLs (including the `polkadot://` scheme). Returns:
+/// - `Some(DotName)` for a clean `.dot` URL
+/// - `Some(Reject)` for a `.dot` URL with port or userinfo
+/// - `None` when the input isn't a `.dot` URL (caller falls through to
+///   localhost / external)
+fn classify_dot(input: &str) -> Option<NavigateDecision> {
+    let parsed = if input.starts_with("polkadot://") {
+        Url::parse(input).ok()?
+    } else {
+        parse_with_explicit_https(input)?
+    };
+
+    let hostname = parsed.host_str()?;
+    if !is_dot_domain(hostname) {
+        return None;
+    }
+
+    if parsed.port().is_some() || !parsed.username().is_empty() || parsed.password().is_some() {
+        return Some(NavigateDecision::Reject {
+            reason: format!("{hostname} carries port or userinfo; dotns forbids both"),
+        });
+    }
+
+    Some(NavigateDecision::DotName {
+        identifier: normalize_host(hostname),
+        path: strip_leading_slash(parsed.path()) + &suffix(&parsed),
+    })
+}
+
+/// Recognize `localhost[:port]` URLs, with or without an explicit scheme.
+fn classify_localhost(input: &str) -> Option<NavigateDecision> {
+    let with_scheme = if input.starts_with("localhost") {
+        format!("http://{input}")
+    } else {
+        input.to_string()
+    };
+
+    let parsed = Url::parse(&with_scheme).ok()?;
+    if parsed.host_str()? != "localhost" {
+        return None;
+    }
+
+    let host = match parsed.port() {
+        Some(port) => format!("localhost:{port}"),
+        None => "localhost".to_string(),
+    };
+
+    Some(NavigateDecision::Localhost {
+        host,
+        path: strip_leading_slash(parsed.path()) + &suffix(&parsed),
+    })
+}
+
+/// External URL scheme allowlist. Anything outside this set is treated as
+/// a [`NavigateDecision::Reject`] so dangerous schemes (`javascript:`,
+/// `data:`, `file:`, `vbscript:`, ...) cannot reach `Platform::navigate_to`.
+const ALLOWED_EXTERNAL_SCHEMES: &[&str] = &["http", "https", "mailto", "tel", "polkadot", "dot"];
+
+/// Mirrors `normalizeUrl`: prepend `https://` if missing, otherwise pass the
+/// URL through as its canonical string form. Returns `Err(reason)` for an
+/// unparseable input or a scheme outside [`ALLOWED_EXTERNAL_SCHEMES`].
+fn normalize_external(input: &str) -> Result<String, String> {
+    // `parse_with_explicit_https` returns a successful direct parse as-is and
+    // only prepends `https://` when the direct parse fails, so a disallowed
+    // scheme (e.g. `javascript:`) is never rewritten to https: the single
+    // scheme check below rejects it.
+    let url = parse_with_explicit_https(input)
+        .ok_or_else(|| "URL constructor rejected input".to_string())?;
+    if !ALLOWED_EXTERNAL_SCHEMES.contains(&url.scheme()) {
+        return Err(format!("scheme `{}` is not allowed", url.scheme()));
+    }
+    Ok(url.to_string())
+}
+
+fn strip_leading_slash(path: &str) -> String {
+    path.strip_prefix('/').unwrap_or(path).to_string()
+}
+
+fn suffix(url: &Url) -> String {
+    let mut out = String::new();
+    if let Some(q) = url.query() {
+        out.push('?');
+        out.push_str(q);
+    }
+    if let Some(f) = url.fragment() {
+        out.push('#');
+        out.push_str(f);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn dot(identifier: &str, path: &str) -> NavigateDecision {
+        NavigateDecision::DotName {
+            identifier: identifier.to_string(),
+            path: path.to_string(),
+        }
+    }
+
+    fn localhost(host: &str, path: &str) -> NavigateDecision {
+        NavigateDecision::Localhost {
+            host: host.to_string(),
+            path: path.to_string(),
+        }
+    }
+
+    fn external(url: &str) -> NavigateDecision {
+        NavigateDecision::External {
+            url: url.to_string(),
+        }
+    }
+
+    #[test]
+    fn dot_bare() {
+        assert_eq!(parse_navigate("mytestapp.dot"), dot("mytestapp.dot", ""));
+    }
+
+    #[test]
+    fn dot_trailing_root_dot_is_a_product() {
+        // The absolute FQDN form classifies and keys like the bare name.
+        assert_eq!(parse_navigate("example.dot."), dot("example.dot", ""));
+        assert_eq!(
+            parse_navigate("https://example.dot./path"),
+            dot("example.dot", "path")
+        );
+    }
+
+    #[test]
+    fn dot_li_is_not_a_product() {
+        assert_eq!(
+            parse_navigate("mytestapp.dot.li"),
+            external("https://mytestapp.dot.li/")
+        );
+    }
+
+    #[test]
+    fn dot_with_https() {
+        assert_eq!(
+            parse_navigate("https://mytestapp.dot"),
+            dot("mytestapp.dot", "")
+        );
+    }
+
+    #[test]
+    fn dot_with_http() {
+        assert_eq!(
+            parse_navigate("http://mytestapp.dot"),
+            dot("mytestapp.dot", "")
+        );
+    }
+
+    #[test]
+    fn dot_with_path() {
+        assert_eq!(
+            parse_navigate("mytestapp.dot/some/path"),
+            dot("mytestapp.dot", "some/path")
+        );
+    }
+
+    #[test]
+    fn dot_with_query_only() {
+        assert_eq!(
+            parse_navigate("pr508.faucet.dot?embed=1"),
+            dot("pr508.faucet.dot", "?embed=1")
+        );
+    }
+
+    #[test]
+    fn dot_with_hash_only() {
+        assert_eq!(
+            parse_navigate("pr508.faucet.dot#section=main"),
+            dot("pr508.faucet.dot", "#section=main")
+        );
+    }
+
+    #[test]
+    fn dot_with_path_query_hash() {
+        assert_eq!(
+            parse_navigate("pr508.faucet.dot/nested/path?embed=1#frame=compact"),
+            dot("pr508.faucet.dot", "nested/path?embed=1#frame=compact")
+        );
+    }
+
+    #[test]
+    fn polkadot_scheme_dot_host() {
+        assert_eq!(
+            parse_navigate("polkadot://currenthost.dot/mytestapp.dot"),
+            dot("currenthost.dot", "mytestapp.dot")
+        );
+    }
+
+    #[test]
+    fn polkadot_scheme_non_dot_host_falls_through() {
+        match parse_navigate("polkadot://example.com/settings") {
+            NavigateDecision::External { .. } | NavigateDecision::Reject { .. } => {}
+            other => panic!("expected External or Reject, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn polkadot_scheme_with_path() {
+        assert_eq!(
+            parse_navigate("polkadot://currenthost.dot/mytestapp.dot/settings"),
+            dot("currenthost.dot", "mytestapp.dot/settings")
+        );
+    }
+
+    #[test]
+    fn polkadot_scheme_with_query_and_hash() {
+        assert_eq!(
+            parse_navigate("polkadot://currenthost.dot/mytestapp.dot?embed=1#frame=compact"),
+            dot("currenthost.dot", "mytestapp.dot?embed=1#frame=compact")
+        );
+    }
+
+    #[test]
+    fn dot_subdomain() {
+        assert_eq!(
+            parse_navigate("sub.acme.dot/path"),
+            dot("sub.acme.dot", "path")
+        );
+    }
+
+    #[test]
+    fn dot_with_mixed_case_normalizes() {
+        assert_eq!(
+            parse_navigate("Example.DOT/Path"),
+            dot("example.dot", "Path")
+        );
+    }
+
+    #[test]
+    fn dot_with_port_is_rejected() {
+        assert!(matches!(
+            parse_navigate("https://x.dot:8080/path"),
+            NavigateDecision::Reject { .. }
+        ));
+    }
+
+    #[test]
+    fn dot_with_userinfo_is_rejected() {
+        assert!(matches!(
+            parse_navigate("https://user:pass@x.dot/path"),
+            NavigateDecision::Reject { .. }
+        ));
+    }
+
+    #[test]
+    fn trim_whitespace() {
+        assert_eq!(
+            parse_navigate("  mytestapp.dot/path  "),
+            dot("mytestapp.dot", "path")
+        );
+    }
+
+    #[test]
+    fn localhost_bare_with_port() {
+        assert_eq!(
+            parse_navigate("localhost:3000"),
+            localhost("localhost:3000", "")
+        );
+    }
+
+    #[test]
+    fn localhost_with_port_and_path() {
+        assert_eq!(
+            parse_navigate("localhost:3000/some/path"),
+            localhost("localhost:3000", "some/path")
+        );
+    }
+
+    #[test]
+    fn localhost_with_explicit_http() {
+        assert_eq!(
+            parse_navigate("http://localhost:5000"),
+            localhost("localhost:5000", "")
+        );
+    }
+
+    #[test]
+    fn localhost_with_http_and_path() {
+        assert_eq!(
+            parse_navigate("http://localhost:5000/path"),
+            localhost("localhost:5000", "path")
+        );
+    }
+
+    #[test]
+    fn localhost_with_query_and_hash() {
+        assert_eq!(
+            parse_navigate("localhost:3000/path?q=1#h"),
+            localhost("localhost:3000", "path?q=1#h")
+        );
+    }
+
+    #[test]
+    fn localhost_without_port() {
+        assert_eq!(parse_navigate("localhost"), localhost("localhost", ""));
+    }
+
+    #[test]
+    fn localhost_without_port_with_path() {
+        assert_eq!(
+            parse_navigate("localhost/path"),
+            localhost("localhost", "path")
+        );
+    }
+
+    #[test]
+    fn external_bare_domain() {
+        assert_eq!(
+            parse_navigate("google.com"),
+            external("https://google.com/")
+        );
+    }
+
+    #[test]
+    fn external_bare_domain_with_path() {
+        assert_eq!(
+            parse_navigate("google.com/search?q=test"),
+            external("https://google.com/search?q=test")
+        );
+    }
+
+    #[test]
+    fn external_preserves_https() {
+        assert_eq!(
+            parse_navigate("https://example.com/page"),
+            external("https://example.com/page")
+        );
+    }
+
+    #[test]
+    fn external_preserves_http() {
+        assert_eq!(
+            parse_navigate("http://example.com/page"),
+            external("http://example.com/page")
+        );
+    }
+
+    #[test]
+    fn external_dot_li() {
+        assert_eq!(
+            parse_navigate("acme.dot.li/path/1"),
+            external("https://acme.dot.li/path/1")
+        );
+    }
+
+    #[test]
+    fn reject_empty() {
+        assert!(matches!(
+            parse_navigate(""),
+            NavigateDecision::Reject { .. }
+        ));
+    }
+
+    #[test]
+    fn reject_whitespace() {
+        assert!(matches!(
+            parse_navigate("   "),
+            NavigateDecision::Reject { .. }
+        ));
+    }
+
+    #[test]
+    fn reject_unparseable() {
+        assert!(matches!(
+            parse_navigate(":::invalid"),
+            NavigateDecision::Reject { .. }
+        ));
+    }
+
+    /// `javascript:` URIs must never reach the platform's `navigate_to`;
+    /// otherwise a malicious product could execute arbitrary JS in the host.
+    #[test]
+    fn reject_javascript_uri() {
+        assert!(
+            matches!(
+                parse_navigate("javascript:alert(1)"),
+                NavigateDecision::Reject { .. }
+            ),
+            "javascript: scheme must be rejected"
+        );
+    }
+
+    /// `file:` URIs leak local filesystem paths; reject them.
+    #[test]
+    fn reject_file_uri() {
+        assert!(
+            matches!(
+                parse_navigate("file:///etc/passwd"),
+                NavigateDecision::Reject { .. }
+            ),
+            "file: scheme must be rejected"
+        );
+    }
+
+    /// `data:` URIs can carry inline HTML/JS payloads; reject them.
+    #[test]
+    fn reject_data_uri() {
+        assert!(
+            matches!(
+                parse_navigate("data:text/html,<script>alert(1)</script>"),
+                NavigateDecision::Reject { .. }
+            ),
+            "data: scheme must be rejected"
+        );
+    }
+
+    /// `vbscript:` URIs are the legacy IE equivalent of `javascript:`;
+    /// reject them too even though modern browsers don't execute them.
+    #[test]
+    fn reject_vbscript_uri() {
+        assert!(
+            matches!(
+                parse_navigate("vbscript:msgbox(1)"),
+                NavigateDecision::Reject { .. }
+            ),
+            "vbscript: scheme must be rejected"
+        );
+    }
+
+    /// NFC-normalized and NFD-normalized inputs that represent the same
+    /// dotns name must produce the same `DotName.identifier` so downstream
+    /// resolution can't be fooled into looking up two different lookup keys
+    /// for one visual identity.
+    #[test]
+    fn nfc_normalization_collapses_nfd() {
+        let nfc = parse_navigate("café.dot");
+        let nfd = parse_navigate("cafe\u{0301}.dot");
+        match (&nfc, &nfd) {
+            (
+                NavigateDecision::DotName {
+                    identifier: a,
+                    path: _,
+                },
+                NavigateDecision::DotName {
+                    identifier: b,
+                    path: _,
+                },
+            ) => assert_eq!(a, b, "NFC and NFD inputs must normalize to one identifier"),
+            other => panic!("expected two DotName decisions, got {other:?}"),
+        }
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/entropy.rs b/rust/crates/truapi-server/src/host_logic/entropy.rs
new file mode 100644
index 00000000..b4a4be34
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/entropy.rs
@@ -0,0 +1,104 @@
+//! Product-scoped deterministic entropy derivation.
+//!
+//! Matches dotli's product entropy contract: three keyed BLAKE2b-256 layers
+//! over the session secret, product id, and caller key.
+
+use blake2_rfc::blake2b::blake2b;
+use thiserror::Error;
+
+const DOMAIN_SEPARATOR: &[u8] = b"product-entropy-derivation";
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum ProductEntropyError {
+    #[error("\"key\" must be between 1 and 32 bytes, got {0}")]
+    InvalidKeyLength(usize),
+    #[error("entropy secret is missing")]
+    MissingSecret,
+}
+
+pub fn derive_product_entropy(
+    entropy_secret: &[u8],
+    product_id: &str,
+    key: &[u8],
+) -> Result<[u8; 32], ProductEntropyError> {
+    let root_entropy_source = blake2b256_keyed(entropy_secret, DOMAIN_SEPARATOR);
+    derive_product_entropy_from_source(&root_entropy_source, product_id, key)
+}
+
+pub fn derive_product_entropy_from_source(
+    root_entropy_source: &[u8; 32],
+    product_id: &str,
+    key: &[u8],
+) -> Result<[u8; 32], ProductEntropyError> {
+    if key.is_empty() || key.len() > 32 {
+        return Err(ProductEntropyError::InvalidKeyLength(key.len()));
+    }
+
+    let product_id_hash = blake2b256(product_id.as_bytes());
+    let per_product_entropy = blake2b256_keyed(root_entropy_source, &product_id_hash);
+    Ok(blake2b256_keyed(&per_product_entropy, key))
+}
+
+fn blake2b256_keyed(message: &[u8], key: &[u8]) -> [u8; 32] {
+    let hash = blake2b(32, key, message);
+    hash.as_bytes()
+        .try_into()
+        .expect("BLAKE2b-256 returns 32 bytes")
+}
+
+fn blake2b256(message: &[u8]) -> [u8; 32] {
+    blake2b256_keyed(message, &[])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn secret() -> [u8; 32] {
+        let mut secret = [0u8; 32];
+        for (i, byte) in secret.iter_mut().enumerate() {
+            *byte = i as u8;
+        }
+        secret
+    }
+
+    #[test]
+    fn derives_dotli_entropy_single_byte_key_vector() {
+        let entropy = derive_product_entropy(&secret(), "myapp.dot", &[1]).unwrap();
+        assert_eq!(
+            hex::encode(entropy),
+            "4bafd6a34182959bad8914dcff88c6b6842d551d6f0067afbd407e9584223404"
+        );
+    }
+
+    #[test]
+    fn derives_dotli_entropy_text_key_vector() {
+        let entropy = derive_product_entropy(&secret(), "myapp.dot", b"product-key").unwrap();
+        assert_eq!(
+            hex::encode(entropy),
+            "ab1887248c9de3cf4b8c5a255782796d3d35a98c8eb2d7df61a410db8b14da36"
+        );
+    }
+
+    #[test]
+    fn derives_dotli_entropy_localhost_vector() {
+        let key: Vec<u8> = (0..32).map(|i| 255 - i).collect();
+        let entropy = derive_product_entropy(&secret(), "localhost:3000", &key).unwrap();
+        assert_eq!(
+            hex::encode(entropy),
+            "437d0a6236c51fe114cf6a16b79c9c2b5f95b1e105e2d5269cc254a8c593925f"
+        );
+    }
+
+    #[test]
+    fn rejects_empty_and_long_keys_like_dotli() {
+        assert_eq!(
+            derive_product_entropy(&secret(), "myapp.dot", &[]).unwrap_err(),
+            ProductEntropyError::InvalidKeyLength(0)
+        );
+        assert_eq!(
+            derive_product_entropy(&secret(), "myapp.dot", &[0u8; 33]).unwrap_err(),
+            ProductEntropyError::InvalidKeyLength(33)
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/features.rs b/rust/crates/truapi-server/src/host_logic/features.rs
new file mode 100644
index 00000000..8db69d8d
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/features.rs
@@ -0,0 +1,72 @@
+//! Feature-detection delegation.
+//!
+//! `feature_supported` is a platform syscall: each host owns the set of
+//! chains it can service. This module is a thin shim that forwards the
+//! request through to [`truapi_platform::Features`].
+
+use truapi::v01::GenericError;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi_platform::Features;
+
+/// Forward a feature-support query to the platform implementation.
+pub async fn feature_supported<P: Features>(
+    platform: &P,
+    request: HostFeatureSupportedRequest,
+) -> Result<HostFeatureSupportedResponse, GenericError> {
+    platform.feature_supported(request).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use truapi::v01;
+
+    struct AlwaysSupported;
+
+    impl Features for AlwaysSupported {
+        async fn feature_supported(
+            &self,
+            request: HostFeatureSupportedRequest,
+        ) -> Result<HostFeatureSupportedResponse, GenericError> {
+            let HostFeatureSupportedRequest::V1(_) = request;
+            Ok(HostFeatureSupportedResponse::V1(
+                v01::HostFeatureSupportedResponse { supported: true },
+            ))
+        }
+    }
+
+    struct AlwaysUnsupported;
+
+    impl Features for AlwaysUnsupported {
+        async fn feature_supported(
+            &self,
+            request: HostFeatureSupportedRequest,
+        ) -> Result<HostFeatureSupportedResponse, GenericError> {
+            let HostFeatureSupportedRequest::V1(_) = request;
+            Ok(HostFeatureSupportedResponse::V1(
+                v01::HostFeatureSupportedResponse { supported: false },
+            ))
+        }
+    }
+
+    fn req() -> HostFeatureSupportedRequest {
+        HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+            genesis_hash: vec![0u8; 32],
+        })
+    }
+
+    #[test]
+    fn delegates_supported_to_platform() {
+        let resp = futures::executor::block_on(feature_supported(&AlwaysSupported, req())).unwrap();
+        let HostFeatureSupportedResponse::V1(inner) = resp;
+        assert!(inner.supported);
+    }
+
+    #[test]
+    fn delegates_unsupported_to_platform() {
+        let resp =
+            futures::executor::block_on(feature_supported(&AlwaysUnsupported, req())).unwrap();
+        let HostFeatureSupportedResponse::V1(inner) = resp;
+        assert!(!inner.supported);
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/identity.rs b/rust/crates/truapi-server/src/host_logic/identity.rs
new file mode 100644
index 00000000..0f945a01
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/identity.rs
@@ -0,0 +1,125 @@
+//! People-chain identity lookup for paired SSO sessions.
+//!
+//! dotli's previous host-papp path read `Resources.Consumers[account]` from
+//! the People chain and used only the username fields. Keep this module narrow:
+//! it builds that storage key and decodes the leading username fields from the
+//! SCALE value. The record begins with a fixed identifier public key; credibility
+//! and statement-store slots are intentionally ignored.
+
+use parity_scale_codec::Decode;
+use sp_crypto_hashing::{blake2_128, twox_128};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PeopleIdentity {
+    pub lite_username: Option<String>,
+    pub full_username: Option<String>,
+}
+
+#[derive(Debug, Decode)]
+struct ConsumerUsernamePrefix {
+    full_username: Option<Vec<u8>>,
+    lite_username: Vec<u8>,
+}
+
+pub fn resources_consumers_storage_key(account_id: &[u8; 32]) -> Vec<u8> {
+    let mut key = Vec::with_capacity(32 + 16 + account_id.len());
+    key.extend_from_slice(&twox_128(b"Resources"));
+    key.extend_from_slice(&twox_128(b"Consumers"));
+    key.extend_from_slice(&blake2_128(account_id));
+    key.extend_from_slice(account_id);
+    key
+}
+
+pub fn decode_people_identity(value: &[u8]) -> Result<PeopleIdentity, String> {
+    if value.len() < 65 {
+        return Err(format!(
+            "invalid Resources.Consumers record: expected 65-byte identifier key, got {} bytes",
+            value.len()
+        ));
+    }
+
+    // ConsumerInfo starts with a fixed 65-byte P-256 identifier key. The
+    // username fields follow immediately after it.
+    let mut input = &value[65..];
+    let decoded = ConsumerUsernamePrefix::decode(&mut input)
+        .map_err(|err| format!("invalid Resources.Consumers record: {err}"))?;
+    let lite_username = non_empty_string(decoded.lite_username)?;
+    let full_username = decoded
+        .full_username
+        .map(non_empty_string)
+        .transpose()?
+        .flatten();
+    Ok(PeopleIdentity {
+        lite_username,
+        full_username,
+    })
+}
+
+fn non_empty_string(bytes: Vec<u8>) -> Result<Option<String>, String> {
+    if bytes.is_empty() {
+        return Ok(None);
+    }
+    let value = String::from_utf8(bytes)
+        .map_err(|err| format!("Resources.Consumers username is not UTF-8: {err}"))?;
+    if value.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(value))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use parity_scale_codec::Encode;
+
+    #[test]
+    fn resources_consumers_key_uses_expected_prefix() {
+        let key = resources_consumers_storage_key(&[0x42; 32]);
+
+        assert_eq!(key.len(), 80);
+        assert_eq!(&key[..16], &twox_128(b"Resources"));
+        assert_eq!(&key[16..32], &twox_128(b"Consumers"));
+        assert_eq!(&key[48..], &[0x42; 32]);
+    }
+
+    #[test]
+    fn twox128_matches_substrate_storage_prefix_vector() {
+        assert_eq!(
+            hex::encode(twox_128(b"System")),
+            "26aa394eea5630e07c48ae0c9558cef7"
+        );
+    }
+
+    #[test]
+    fn decodes_username_prefix_and_ignores_trailing_fields() {
+        let mut value = vec![0x04; 65];
+        value.extend((Some(b"Alice Smith".to_vec()), b"alice.01".to_vec()).encode());
+        value.extend_from_slice(&[0xff; 8]);
+
+        let decoded = decode_people_identity(&value).expect("identity should decode");
+
+        assert_eq!(decoded.full_username.as_deref(), Some("Alice Smith"));
+        assert_eq!(decoded.lite_username.as_deref(), Some("alice.01"));
+    }
+
+    #[test]
+    fn empty_full_username_is_none() {
+        let mut value = vec![0x04; 65];
+        value.extend((Some(Vec::<u8>::new()), b"alice.01".to_vec()).encode());
+
+        let decoded = decode_people_identity(&value).expect("identity should decode");
+
+        assert_eq!(decoded.full_username, None);
+        assert_eq!(decoded.lite_username.as_deref(), Some("alice.01"));
+    }
+
+    #[test]
+    fn rejects_missing_identifier_key() {
+        let value = (None::<Vec<u8>>, b"alice.01".to_vec()).encode();
+
+        let error = decode_people_identity(&value).expect_err("identity should reject");
+
+        assert!(error.contains("65-byte identifier key"));
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/mod.rs b/rust/crates/truapi-server/src/host_logic/mod.rs
new file mode 100644
index 00000000..90a2056a
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/mod.rs
@@ -0,0 +1,16 @@
+//! Host-agnostic logic the Rust core owns on behalf of every platform host.
+//!
+//! Platform callbacks are a syscall layer for OS primitives (modals, native
+//! storage, URL handler, notification center). Everything else lives here so
+//! iOS, Android, and web hosts share one canonical implementation.
+
+pub mod dotns;
+pub mod entropy;
+pub mod features;
+pub mod identity;
+pub mod permissions;
+pub mod product_account;
+pub mod session;
+pub mod sso_messages;
+pub mod sso_pairing;
+pub mod statement_store;
diff --git a/rust/crates/truapi-server/src/host_logic/permissions.rs b/rust/crates/truapi-server/src/host_logic/permissions.rs
new file mode 100644
index 00000000..31a19817
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/permissions.rs
@@ -0,0 +1,568 @@
+//! Permission state machine (ask -> granted | denied), backed by the platform
+//! [`Storage`] trait with a reserved `truapi:permissions:` key prefix.
+//!
+//! The v0.1 wire protocol keeps device permissions (camera, mic, NFC, ...)
+//! separate from remote permissions (domain access, chain submit, ...), so
+//! this module exposes two `check_or_prompt` entrypoints that route to the
+//! matching platform callback. The cache layer is shared but keys live in
+//! distinct sub-namespaces so a device grant cannot authorize a remote
+//! operation by accident.
+
+use parity_scale_codec::{Decode, Encode};
+
+use truapi::v01::{
+    HostDevicePermissionRequest, HostDevicePermissionResponse, HostLocalStorageReadError,
+    RemotePermission, RemotePermissionRequest, RemotePermissionResponse,
+};
+use truapi_platform::{Permissions, Storage};
+
+/// Reserved key prefix for permission state. Hosts must not use keys under
+/// this prefix for anything else so core can own the namespace.
+pub const PERMISSION_KEY_PREFIX: &str = "truapi:permissions:";
+
+/// Persisted answer for a single permission request.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum Decision {
+    /// User granted the permission.
+    Granted,
+    /// User denied the permission.
+    Denied,
+}
+
+/// Coordinator that inspects persisted state first, falls back to the
+/// platform's prompt callback, and writes the decision back so future calls
+/// short-circuit. Generic over the concrete `Storage` + `Permissions` impls
+/// so callers (e.g. `PlatformRuntimeHost<P>`) can stay non-`dyn`.
+pub struct PermissionsService<'a, S: Storage, P: Permissions> {
+    storage: &'a S,
+    prompt: &'a P,
+}
+
+impl<'a, S: Storage, P: Permissions> PermissionsService<'a, S, P> {
+    /// Construct a service backed by the given storage + prompt callbacks.
+    pub fn new(storage: &'a S, prompt: &'a P) -> Self {
+        Self { storage, prompt }
+    }
+
+    /// Returns the stored decision for a device permission without prompting.
+    pub async fn peek_device(
+        &self,
+        permission: &HostDevicePermissionRequest,
+    ) -> Result<Option<Decision>, HostLocalStorageReadError> {
+        peek(self.storage, &device_storage_key(permission)).await
+    }
+
+    /// Returns the stored decision for a remote permission without
+    /// prompting.
+    pub async fn peek_remote(
+        &self,
+        request: &RemotePermissionRequest,
+    ) -> Result<Option<Decision>, HostLocalStorageReadError> {
+        peek(self.storage, &remote_storage_key(request)).await
+    }
+
+    /// Returns the cached device decision if any, otherwise prompts the
+    /// platform's `device_permission` callback and persists the answer.
+    pub async fn check_or_prompt_device(
+        &self,
+        permission: HostDevicePermissionRequest,
+    ) -> Result<Decision, HostLocalStorageReadError> {
+        let key = device_storage_key(&permission);
+        if let Some(cached) = peek(self.storage, &key).await? {
+            return Ok(cached);
+        }
+        // Only a genuine user decision is persisted. A prompt-callback error is
+        // transient (UI unavailable, IPC timeout), not a denial, so fail closed
+        // for this call but do not cache it — the next request re-prompts rather
+        // than locking the capability out permanently with no revoke path.
+        let granted = match self.prompt.device_permission(permission).await {
+            Ok(HostDevicePermissionResponse { granted }) => granted,
+            Err(_) => return Ok(Decision::Denied),
+        };
+        let decision = if granted {
+            Decision::Granted
+        } else {
+            Decision::Denied
+        };
+        self.storage.write(key, decision.encode()).await?;
+        Ok(decision)
+    }
+
+    /// Returns the cached remote decision if any, otherwise prompts the
+    /// platform's `remote_permission` callback and persists the answer.
+    pub async fn check_or_prompt_remote(
+        &self,
+        request: RemotePermissionRequest,
+    ) -> Result<Decision, HostLocalStorageReadError> {
+        let key = remote_storage_key(&request);
+        if let Some(cached) = peek(self.storage, &key).await? {
+            return Ok(cached);
+        }
+        // See `check_or_prompt_device`: persist only a genuine user decision; a
+        // transient callback error fails closed for this call without caching.
+        let granted = match self.prompt.remote_permission(request).await {
+            Ok(RemotePermissionResponse { granted }) => granted,
+            Err(_) => return Ok(Decision::Denied),
+        };
+        let decision = if granted {
+            Decision::Granted
+        } else {
+            Decision::Denied
+        };
+        self.storage.write(key, decision.encode()).await?;
+        Ok(decision)
+    }
+}
+
+async fn peek<S: Storage>(
+    storage: &S,
+    key: &str,
+) -> Result<Option<Decision>, HostLocalStorageReadError> {
+    let Some(raw) = storage.read(key.to_string()).await? else {
+        return Ok(None);
+    };
+    Ok(Decision::decode(&mut &*raw).ok())
+}
+
+/// Canonical storage key for a device permission. The slug is human-readable
+/// so a host developer inspecting storage can tell what's there.
+pub fn device_storage_key(permission: &HostDevicePermissionRequest) -> String {
+    format!("{PERMISSION_KEY_PREFIX}device:{}", device_slug(permission))
+}
+
+/// Canonical storage key for a remote permission. The permission is
+/// canonicalized (domain lists lowercased, sorted, and de-duplicated) then
+/// SCALE-encoded and hex-encoded so attacker-controlled domain strings cannot
+/// collide with another permission by injecting separator characters.
+pub fn remote_storage_key(request: &RemotePermissionRequest) -> String {
+    let canonical = canonical_remote_request(request);
+    format!(
+        "{PERMISSION_KEY_PREFIX}remote:{}",
+        hex::encode(canonical.encode())
+    )
+}
+
+fn canonical_remote_request(request: &RemotePermissionRequest) -> RemotePermissionRequest {
+    let permission = match &request.permission {
+        RemotePermission::Remote { domains } => {
+            // DNS domains are case-insensitive, so a logically-identical bundle
+            // requested with different casing or duplicate entries must
+            // canonicalize to one key (no spurious re-prompt).
+            let mut canonical: Vec<String> =
+                domains.iter().map(|d| d.to_ascii_lowercase()).collect();
+            canonical.sort();
+            canonical.dedup();
+            RemotePermission::Remote { domains: canonical }
+        }
+        other => other.clone(),
+    };
+    RemotePermissionRequest { permission }
+}
+
+fn device_slug(permission: &HostDevicePermissionRequest) -> &'static str {
+    match permission {
+        HostDevicePermissionRequest::Notifications => "notifications",
+        HostDevicePermissionRequest::Camera => "camera",
+        HostDevicePermissionRequest::Microphone => "microphone",
+        HostDevicePermissionRequest::Bluetooth => "bluetooth",
+        HostDevicePermissionRequest::NFC => "nfc",
+        HostDevicePermissionRequest::Location => "location",
+        HostDevicePermissionRequest::Clipboard => "clipboard",
+        HostDevicePermissionRequest::OpenUrl => "open-url",
+        HostDevicePermissionRequest::Biometrics => "biometrics",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::lock::Mutex;
+    use std::collections::HashMap;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use truapi::v01;
+    use truapi::v01::GenericError;
+
+    #[derive(Default)]
+    struct MemStorage {
+        inner: Mutex<HashMap<String, Vec<u8>>>,
+    }
+
+    impl Storage for MemStorage {
+        async fn read(&self, key: String) -> Result<Option<Vec<u8>>, HostLocalStorageReadError> {
+            Ok(self.inner.lock().await.get(&key).cloned())
+        }
+        async fn write(
+            &self,
+            key: String,
+            value: Vec<u8>,
+        ) -> Result<(), HostLocalStorageReadError> {
+            self.inner.lock().await.insert(key, value);
+            Ok(())
+        }
+        async fn clear(&self, key: String) -> Result<(), HostLocalStorageReadError> {
+            self.inner.lock().await.remove(&key);
+            Ok(())
+        }
+    }
+
+    struct ScriptedPrompt {
+        device_answers: Mutex<Vec<bool>>,
+        remote_answers: Mutex<Vec<bool>>,
+        device_calls: AtomicUsize,
+        remote_calls: AtomicUsize,
+    }
+
+    impl ScriptedPrompt {
+        fn new(device_answers: Vec<bool>, remote_answers: Vec<bool>) -> Self {
+            Self {
+                device_answers: Mutex::new(device_answers),
+                remote_answers: Mutex::new(remote_answers),
+                device_calls: AtomicUsize::new(0),
+                remote_calls: AtomicUsize::new(0),
+            }
+        }
+    }
+
+    impl Permissions for ScriptedPrompt {
+        async fn device_permission(
+            &self,
+            _request: HostDevicePermissionRequest,
+        ) -> Result<HostDevicePermissionResponse, GenericError> {
+            self.device_calls.fetch_add(1, Ordering::SeqCst);
+            let granted = self
+                .device_answers
+                .lock()
+                .await
+                .pop()
+                .expect("ScriptedPrompt ran out of device answers");
+            Ok(v01::HostDevicePermissionResponse { granted })
+        }
+
+        async fn remote_permission(
+            &self,
+            _request: RemotePermissionRequest,
+        ) -> Result<RemotePermissionResponse, GenericError> {
+            self.remote_calls.fetch_add(1, Ordering::SeqCst);
+            let granted = self
+                .remote_answers
+                .lock()
+                .await
+                .pop()
+                .expect("ScriptedPrompt ran out of remote answers");
+            Ok(v01::RemotePermissionResponse { granted })
+        }
+    }
+
+    #[test]
+    fn storage_key_is_stable_per_variant() {
+        assert_eq!(
+            device_storage_key(&HostDevicePermissionRequest::Camera),
+            "truapi:permissions:device:camera",
+        );
+        let chain = RemotePermissionRequest {
+            permission: RemotePermission::ChainSubmit,
+        };
+        let expected = format!(
+            "truapi:permissions:remote:{}",
+            hex::encode(canonical_remote_request(&chain).encode())
+        );
+        assert_eq!(remote_storage_key(&chain), expected);
+
+        let unsorted = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec!["b.example.com".into(), "a.example.com".into()],
+            },
+        };
+        let sorted = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec!["a.example.com".into(), "b.example.com".into()],
+            },
+        };
+        assert_eq!(remote_storage_key(&unsorted), remote_storage_key(&sorted));
+    }
+
+    #[test]
+    fn remote_storage_key_is_case_insensitive_and_dedups_domains() {
+        let mixed = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec!["Example.COM".into(), "a.com".into(), "a.com".into()],
+            },
+        };
+        let canonical = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec!["a.com".into(), "example.com".into()],
+            },
+        };
+        assert_eq!(remote_storage_key(&mixed), remote_storage_key(&canonical));
+    }
+
+    #[test]
+    fn remote_storage_key_handles_separator_chars_in_domains() {
+        // Domain strings containing `|`, `,`, or the `truapi:permissions:`
+        // prefix must not be able to forge a key that matches an unrelated
+        // permission. We compare against a benign permission with the same
+        // logical set of domains but no injection attempt.
+        let injecting = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec![
+                    "a|b".into(),
+                    "c,d".into(),
+                    "truapi:permissions:remote:web-rtc".into(),
+                ],
+            },
+        };
+        let benign_same_set = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec!["x".into(), "y".into(), "z".into()],
+            },
+        };
+        let injecting_key = remote_storage_key(&injecting);
+        let benign_key = remote_storage_key(&benign_same_set);
+        assert_ne!(injecting_key, benign_key);
+
+        // The injecting permission must also be distinct from the `WebRtc`
+        // variant it tries to impersonate via crafted strings.
+        let webrtc = RemotePermissionRequest {
+            permission: RemotePermission::WebRtc,
+        };
+        assert_ne!(injecting_key, remote_storage_key(&webrtc));
+
+        // Re-ordering the same domains still collapses to a single key
+        // (canonicalization is order-independent).
+        let injecting_reordered = RemotePermissionRequest {
+            permission: RemotePermission::Remote {
+                domains: vec![
+                    "truapi:permissions:remote:web-rtc".into(),
+                    "c,d".into(),
+                    "a|b".into(),
+                ],
+            },
+        };
+        assert_eq!(injecting_key, remote_storage_key(&injecting_reordered));
+    }
+
+    #[test]
+    fn check_or_prompt_device_caches_grant() {
+        let storage = MemStorage::default();
+        let prompt = ScriptedPrompt::new(vec![true], vec![]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let first = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+        let second = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+
+        assert_eq!(first, Decision::Granted);
+        assert_eq!(second, Decision::Granted);
+        assert_eq!(prompt.device_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn check_or_prompt_remote_caches_denial() {
+        let storage = MemStorage::default();
+        let prompt = ScriptedPrompt::new(vec![], vec![false]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let request = RemotePermissionRequest {
+            permission: RemotePermission::ChainSubmit,
+        };
+        let first =
+            futures::executor::block_on(service.check_or_prompt_remote(request.clone())).unwrap();
+        let second = futures::executor::block_on(service.check_or_prompt_remote(request)).unwrap();
+
+        assert_eq!(first, Decision::Denied);
+        assert_eq!(second, Decision::Denied);
+        assert_eq!(prompt.remote_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn device_and_remote_caches_are_independent() {
+        let storage = MemStorage::default();
+        // Device denies, remote grants. If the caches collided we'd see the
+        // same answer on the second call.
+        let prompt = ScriptedPrompt::new(vec![false], vec![true]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let device = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+        let remote =
+            futures::executor::block_on(service.check_or_prompt_remote(RemotePermissionRequest {
+                permission: RemotePermission::ChainSubmit,
+            }))
+            .unwrap();
+
+        assert_eq!(device, Decision::Denied);
+        assert_eq!(remote, Decision::Granted);
+        assert_eq!(prompt.device_calls.load(Ordering::SeqCst), 1);
+        assert_eq!(prompt.remote_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn device_prompt_does_not_invoke_remote_callback() {
+        let storage = MemStorage::default();
+        let prompt = ScriptedPrompt::new(vec![true], vec![]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let _ = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+        assert_eq!(prompt.device_calls.load(Ordering::SeqCst), 1);
+        assert_eq!(prompt.remote_calls.load(Ordering::SeqCst), 0);
+    }
+
+    #[test]
+    fn remote_prompt_does_not_invoke_device_callback() {
+        let storage = MemStorage::default();
+        let prompt = ScriptedPrompt::new(vec![], vec![true]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let _ =
+            futures::executor::block_on(service.check_or_prompt_remote(RemotePermissionRequest {
+                permission: RemotePermission::WebRtc,
+            }))
+            .unwrap();
+        assert_eq!(prompt.device_calls.load(Ordering::SeqCst), 0);
+        assert_eq!(prompt.remote_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn peek_returns_none_until_decided() {
+        let storage = MemStorage::default();
+        let prompt = ScriptedPrompt::new(vec![true], vec![]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let before =
+            futures::executor::block_on(service.peek_device(&HostDevicePermissionRequest::Camera))
+                .unwrap();
+        assert_eq!(before, None);
+
+        futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+
+        let after =
+            futures::executor::block_on(service.peek_device(&HostDevicePermissionRequest::Camera))
+                .unwrap();
+        assert_eq!(after, Some(Decision::Granted));
+    }
+
+    /// Prompt callback that always errors, to exercise the transient-failure
+    /// path (fail closed for the current call, but do not persist the error).
+    struct FailingPrompt;
+
+    impl Permissions for FailingPrompt {
+        async fn device_permission(
+            &self,
+            _request: HostDevicePermissionRequest,
+        ) -> Result<HostDevicePermissionResponse, GenericError> {
+            Err(GenericError {
+                reason: "boom".into(),
+            })
+        }
+
+        async fn remote_permission(
+            &self,
+            _request: RemotePermissionRequest,
+        ) -> Result<RemotePermissionResponse, GenericError> {
+            Err(GenericError {
+                reason: "boom".into(),
+            })
+        }
+    }
+
+    #[test]
+    fn prompt_failure_denies_without_persisting() {
+        let storage = MemStorage::default();
+        let prompt = FailingPrompt;
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let decision = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .unwrap();
+        assert_eq!(decision, Decision::Denied);
+
+        // A transient callback error is fail-closed for this call but NOT
+        // cached, so peek still sees no decision and the next request
+        // re-prompts rather than permanently locking out the capability.
+        let cached =
+            futures::executor::block_on(service.peek_device(&HostDevicePermissionRequest::Camera))
+                .unwrap();
+        assert_eq!(
+            cached, None,
+            "a transient prompt error must not be persisted"
+        );
+    }
+
+    /// A corrupt SCALE-encoded cache entry must be treated as "no cache",
+    /// not panic. The service falls back to prompting.
+    #[test]
+    fn corrupt_cache_entry_returns_none() {
+        let storage = MemStorage::default();
+        // Write garbage bytes under the canonical key.
+        futures::executor::block_on(storage.write(
+            device_storage_key(&HostDevicePermissionRequest::Camera),
+            vec![0xff, 0xfe, 0xfd],
+        ))
+        .unwrap();
+
+        let prompt = ScriptedPrompt::new(vec![true], vec![]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let peeked =
+            futures::executor::block_on(service.peek_device(&HostDevicePermissionRequest::Camera))
+                .unwrap();
+        assert_eq!(peeked, None, "corrupt entry must decode as absent");
+    }
+
+    /// Storage failures must propagate to the caller; the service must not
+    /// swallow them by silently returning a default Decision.
+    #[derive(Default)]
+    struct FailingStorage;
+
+    impl Storage for FailingStorage {
+        async fn read(&self, _key: String) -> Result<Option<Vec<u8>>, HostLocalStorageReadError> {
+            Err(v01::HostLocalStorageReadError::Unknown {
+                reason: "read failed".into(),
+            })
+        }
+        async fn write(
+            &self,
+            _key: String,
+            _value: Vec<u8>,
+        ) -> Result<(), HostLocalStorageReadError> {
+            Err(v01::HostLocalStorageReadError::Unknown {
+                reason: "write failed".into(),
+            })
+        }
+        async fn clear(&self, _key: String) -> Result<(), HostLocalStorageReadError> {
+            Err(v01::HostLocalStorageReadError::Unknown {
+                reason: "clear failed".into(),
+            })
+        }
+    }
+
+    #[test]
+    fn storage_read_error_propagates() {
+        let storage = FailingStorage;
+        let prompt = ScriptedPrompt::new(vec![], vec![]);
+        let service = PermissionsService::new(&storage, &prompt);
+
+        let err = futures::executor::block_on(
+            service.check_or_prompt_device(HostDevicePermissionRequest::Camera),
+        )
+        .expect_err("read failure must surface");
+        assert!(matches!(
+            err,
+            v01::HostLocalStorageReadError::Unknown { .. }
+        ));
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/product_account.rs b/rust/crates/truapi-server/src/host_logic/product_account.rs
new file mode 100644
index 00000000..a89efbd5
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/product_account.rs
@@ -0,0 +1,171 @@
+//! Product account derivation shared by all hosts.
+//!
+//! Mirrors dotli's `packages/auth/src/account.ts`: derive an sr25519 public
+//! key through soft HDKD junctions `["product", product_id, derivation_index]`.
+
+use blake2_rfc::blake2b::blake2b;
+use parity_scale_codec::Encode;
+use schnorrkel::PublicKey;
+use schnorrkel::derive::{ChainCode, Derivation};
+use thiserror::Error;
+use unicode_normalization::UnicodeNormalization;
+
+const JUNCTION_ID_LEN: usize = 32;
+const PRODUCT_JUNCTION: &str = "product";
+const SS58_PREFIX: &[u8] = b"SS58PRE";
+const SUBSTRATE_GENERIC_SS58_PREFIX: u8 = 42;
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum ProductAccountError {
+    #[error("invalid sr25519 root public key")]
+    InvalidRootPublicKey,
+    #[error("numeric derivation junction is outside u64 range")]
+    NumericJunctionOutOfRange,
+}
+
+pub fn is_product_identifier(identifier: &str) -> bool {
+    let normalized = normalize_product_identifier(identifier);
+    normalized.ends_with(".dot")
+        || normalized == "localhost"
+        || normalized.starts_with("localhost:")
+}
+
+pub fn normalize_product_identifier(identifier: &str) -> String {
+    identifier.nfc().collect::<String>().to_lowercase()
+}
+
+pub fn derive_product_public_key(
+    root_public_key: [u8; 32],
+    product_id: &str,
+    derivation_index: u32,
+) -> Result<[u8; 32], ProductAccountError> {
+    let mut public_key = PublicKey::from_bytes(&root_public_key)
+        .map_err(|_| ProductAccountError::InvalidRootPublicKey)?;
+
+    for junction in [
+        PRODUCT_JUNCTION.to_string(),
+        product_id.to_string(),
+        derivation_index.to_string(),
+    ] {
+        let chain_code = ChainCode(create_chain_code(&junction)?);
+        let (derived, _) = public_key.derived_key_simple(chain_code, []);
+        public_key = derived;
+    }
+
+    Ok(public_key.to_bytes())
+}
+
+pub fn product_public_key_to_address(public_key: [u8; 32]) -> String {
+    let mut payload = Vec::with_capacity(35);
+    payload.push(SUBSTRATE_GENERIC_SS58_PREFIX);
+    payload.extend_from_slice(&public_key);
+
+    let mut checksum_input = Vec::with_capacity(SS58_PREFIX.len() + payload.len());
+    checksum_input.extend_from_slice(SS58_PREFIX);
+    checksum_input.extend_from_slice(&payload);
+    let checksum = blake2b(64, &[], &checksum_input);
+    payload.extend_from_slice(&checksum.as_bytes()[..2]);
+
+    bs58::encode(payload).into_string()
+}
+
+fn create_chain_code(code: &str) -> Result<[u8; 32], ProductAccountError> {
+    let encoded = if is_numeric_junction(code) {
+        code.parse::<u64>()
+            .map_err(|_| ProductAccountError::NumericJunctionOutOfRange)?
+            .encode()
+    } else {
+        code.encode()
+    };
+
+    let mut chain_code = [0u8; JUNCTION_ID_LEN];
+    if encoded.len() > JUNCTION_ID_LEN {
+        let hash = blake2b(JUNCTION_ID_LEN, &[], &encoded);
+        chain_code.copy_from_slice(hash.as_bytes());
+    } else {
+        chain_code[..encoded.len()].copy_from_slice(&encoded);
+    }
+    Ok(chain_code)
+}
+
+fn is_numeric_junction(code: &str) -> bool {
+    !code.is_empty() && code.bytes().all(|byte| byte.is_ascii_digit())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ROOT_PUBLIC_KEY: [u8; 32] = [
+        0x80, 0x05, 0x28, 0xc9, 0x55, 0x87, 0x3e, 0x4c, 0x78, 0xb7, 0xdf, 0x24, 0xf7, 0x1d, 0xb8,
+        0xf5, 0x81, 0xaa, 0x99, 0xe3, 0x49, 0x3b, 0xf4, 0x96, 0xed, 0xf1, 0x51, 0xab, 0xc1, 0xd7,
+        0x20, 0x23,
+    ];
+
+    #[test]
+    fn derives_dotli_product_account_vector() {
+        let derived = derive_product_public_key(ROOT_PUBLIC_KEY, "myapp.dot", 0).unwrap();
+        assert_eq!(
+            hex::encode(derived),
+            "281489e3dd1c4dbe88cd670a59edcc9c44d64f510d302bd527ec306f10292f08"
+        );
+    }
+
+    #[test]
+    fn derives_different_index_vector() {
+        let derived = derive_product_public_key(ROOT_PUBLIC_KEY, "myapp.dot", 1).unwrap();
+        assert_eq!(
+            hex::encode(derived),
+            "ec8a80808b46e44c1351b68e295eb975c55bda4855e5ea9fc1325be7296a2a4e"
+        );
+    }
+
+    #[test]
+    fn derives_long_product_id_vector() {
+        let derived = derive_product_public_key(
+            ROOT_PUBLIC_KEY,
+            "w-credentialless-staticblitz-com.local-credentialless.webcontainer-api.io",
+            0,
+        )
+        .unwrap();
+        assert_eq!(
+            hex::encode(derived),
+            "56769a234038defb62a7ad42f251091cc24846c2473a31b5bdd17d366c38c211"
+        );
+    }
+
+    #[test]
+    fn ss58_address_matches_dotli_vector() {
+        let derived = derive_product_public_key(ROOT_PUBLIC_KEY, "myapp.dot", 0).unwrap();
+        assert_eq!(
+            product_public_key_to_address(derived),
+            "5CyFsdhwjXy7wWpDEM6isungQ3LfGnu9UXkt7paBQ6DYRxk1"
+        );
+    }
+
+    #[test]
+    fn accepts_dot_and_localhost_product_identifiers() {
+        assert!(is_product_identifier("Example.DOT"));
+        assert!(is_product_identifier("localhost"));
+        assert!(is_product_identifier("localhost:3000"));
+        assert!(!is_product_identifier("example.com"));
+    }
+
+    #[test]
+    fn chain_code_matches_dotli_encoding_rules() {
+        let product = create_chain_code("product").unwrap();
+        assert_eq!(
+            &product[..8],
+            &[0x1c, b'p', b'r', b'o', b'd', b'u', b'c', b't']
+        );
+
+        let zero = create_chain_code("0").unwrap();
+        assert_eq!(&zero[..8], &[0; 8]);
+
+        let long = create_chain_code(
+            "w-credentialless-staticblitz-com.local-credentialless.webcontainer-api.io",
+        )
+        .unwrap();
+        assert_ne!(&long[..8], &[0; 8]);
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/session.rs b/rust/crates/truapi-server/src/host_logic/session.rs
new file mode 100644
index 00000000..f84e8859
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/session.rs
@@ -0,0 +1,446 @@
+//! Active-session state held in core. The host pushes session info via
+//! platform-specific entrypoints whenever the user pairs/unpairs.
+//! Account-management methods then read from this state instead of
+//! round-tripping a callback to the host on every product call.
+
+use futures::channel::mpsc;
+use futures::stream::{self, BoxStream, StreamExt};
+use parity_scale_codec::{Decode, Encode};
+use std::sync::{Arc, Mutex};
+
+use truapi::v01::HostAccountConnectionStatusSubscribeItem;
+use truapi::versioned::account::HostAccountConnectionStatusSubscribeItem as VersionedItem;
+
+/// Session info pushed by the host. The 32-byte sr25519 public key plus
+/// optional usernames sourced from the People-Chain identity record.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SessionInfo {
+    /// 32-byte sr25519 root public key of the paired session.
+    pub public_key: [u8; 32],
+    /// Core-owned SSO channel state. Core-run pairing fills this; unavailable
+    /// sessions restored from older test fixtures may leave it empty.
+    pub sso: Option<SsoSessionInfo>,
+    /// Wallet-provided source for deterministic product entropy.
+    pub root_entropy_source: Option<[u8; 32]>,
+    /// Wallet identity account id used for People-chain username lookup.
+    pub identity_account_id: Option<[u8; 32]>,
+    /// Short username (e.g. `alice`).
+    pub lite_username: Option<String>,
+    /// Fully qualified username (e.g. `Alice Smith`).
+    pub full_username: Option<String>,
+}
+
+/// Core-owned SSO session material negotiated with the wallet during pairing.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SsoSessionInfo {
+    /// Core's own 64-byte expanded sr25519 statement-store secret.
+    pub ss_secret: [u8; 64],
+    /// Core's own session sr25519 statement-store public key.
+    pub ss_public_key: [u8; 32],
+    /// Core's P-256 ECDH private key.
+    pub enc_secret: [u8; 32],
+    /// Wallet persistent P-256 public key.
+    pub peer_enc_pubkey: [u8; 65],
+    /// Wallet identity sr25519 account id.
+    pub identity_account_id: [u8; 32],
+    /// Core -> wallet topic id.
+    pub session_id_own: [u8; 32],
+    /// Wallet -> core topic id.
+    pub session_id_peer: [u8; 32],
+    /// Statement channel for core requests.
+    pub request_channel: [u8; 32],
+    /// Statement channel for wallet responses to core requests.
+    pub response_channel: [u8; 32],
+    /// Statement channel for wallet-initiated requests.
+    pub peer_request_channel: [u8; 32],
+}
+
+const PERSISTED_SESSION_VERSION: u8 = 3;
+
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+struct PersistedSessionV2 {
+    public_key: [u8; 32],
+    sso: Option<SsoSessionInfo>,
+    root_entropy_source: Option<[u8; 32]>,
+    lite_username: Option<String>,
+    full_username: Option<String>,
+}
+
+/// Encode the active-session fields the core currently understands into an
+/// opaque host-global session blob. Later SSO channel state should bump
+/// `PERSISTED_SESSION_VERSION` instead of extending this layout silently.
+pub fn encode_persisted_session(info: &SessionInfo) -> Vec<u8> {
+    (PERSISTED_SESSION_VERSION, info).encode()
+}
+
+/// Decode a core-owned persisted session blob.
+pub fn decode_persisted_session(blob: &[u8]) -> Result<SessionInfo, String> {
+    let mut input = blob;
+    let version = u8::decode(&mut input).map_err(|err| format!("invalid session blob: {err}"))?;
+    let info = match version {
+        2 => {
+            let legacy = PersistedSessionV2::decode(&mut input)
+                .map_err(|err| format!("invalid session blob: {err}"))?;
+            SessionInfo {
+                public_key: legacy.public_key,
+                sso: legacy.sso,
+                root_entropy_source: legacy.root_entropy_source,
+                identity_account_id: None,
+                lite_username: legacy.lite_username,
+                full_username: legacy.full_username,
+            }
+        }
+        PERSISTED_SESSION_VERSION => {
+            SessionInfo::decode(&mut input).map_err(|err| format!("invalid session blob: {err}"))?
+        }
+        _ => return Err(format!("unsupported session blob version {version}")),
+    };
+    if !input.is_empty() {
+        return Err("invalid session blob: trailing bytes".to_string());
+    }
+    Ok(info)
+}
+
+/// Holds the currently-active session and broadcasts connection-status
+/// transitions to subscribers. Cheap to clone via `Arc`.
+#[derive(Default)]
+pub struct SessionState {
+    inner: Mutex<Inner>,
+}
+
+#[derive(Default)]
+struct Inner {
+    current: Option<SessionInfo>,
+    subscribers: Vec<mpsc::UnboundedSender<VersionedItem>>,
+}
+
+impl SessionState {
+    /// Construct a fresh session holder, starting in the `Disconnected` state.
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+
+    /// Replace the active session with `info`. Emits a `Connected` event to
+    /// every live subscriber if this is a transition from no-session or an
+    /// actual session replacement.
+    pub fn set_session(&self, info: SessionInfo) {
+        let mut inner = self.inner.lock().expect("session-state mutex poisoned");
+        let should_broadcast = inner.current.as_ref() != Some(&info);
+        inner.current = Some(info);
+        if should_broadcast {
+            broadcast(
+                &mut inner.subscribers,
+                HostAccountConnectionStatusSubscribeItem::Connected,
+            );
+        }
+    }
+
+    /// Drop the active session. Emits a `Disconnected` event to every live
+    /// subscriber if there was a session to clear.
+    pub fn clear_session(&self) {
+        let mut inner = self.inner.lock().expect("session-state mutex poisoned");
+        if inner.current.take().is_some() {
+            broadcast(
+                &mut inner.subscribers,
+                HostAccountConnectionStatusSubscribeItem::Disconnected,
+            );
+        }
+    }
+
+    /// Snapshot of the current session, or `None` when nothing is paired.
+    pub fn current(&self) -> Option<SessionInfo> {
+        self.inner
+            .lock()
+            .expect("session-state mutex poisoned")
+            .current
+            .clone()
+    }
+
+    /// Stream of connection-status events. The first item emitted is the
+    /// current state (so subscribers don't have to read it separately);
+    /// subsequent items reflect every `set_session` / `clear_session`
+    /// transition.
+    pub fn subscribe(&self) -> BoxStream<'static, VersionedItem> {
+        let (tx, rx) = mpsc::unbounded();
+        let mut inner = self.inner.lock().expect("session-state mutex poisoned");
+        let initial = match inner.current {
+            Some(_) => HostAccountConnectionStatusSubscribeItem::Connected,
+            None => HostAccountConnectionStatusSubscribeItem::Disconnected,
+        };
+        inner.subscribers.push(tx);
+        let initial_item = VersionedItem::V1(initial);
+        Box::pin(stream::once(async move { initial_item }).chain(rx))
+    }
+}
+
+fn broadcast(
+    subscribers: &mut Vec<mpsc::UnboundedSender<VersionedItem>>,
+    status: HostAccountConnectionStatusSubscribeItem,
+) {
+    let item = VersionedItem::V1(status);
+    // `retain` drops senders whose receiver has been dropped, so the
+    // subscriber list self-prunes on the next broadcast after a reader
+    // unsubscribes.
+    subscribers.retain(|tx| tx.unbounded_send(item.clone()).is_ok());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::executor::block_on;
+    use futures::{FutureExt, StreamExt};
+
+    fn info(pubkey_byte: u8) -> SessionInfo {
+        SessionInfo {
+            public_key: [pubkey_byte; 32],
+            sso: None,
+            root_entropy_source: None,
+            identity_account_id: None,
+            lite_username: Some("alice".to_string()),
+            full_username: None,
+        }
+    }
+
+    #[test]
+    fn current_starts_empty() {
+        let state = SessionState::new();
+        assert!(state.current().is_none());
+    }
+
+    #[test]
+    fn set_then_current_returns_session() {
+        let state = SessionState::new();
+        state.set_session(info(0x42));
+        let got = state.current().expect("session should be present");
+        assert_eq!(got.public_key, [0x42; 32]);
+        assert_eq!(got.lite_username.as_deref(), Some("alice"));
+    }
+
+    #[test]
+    fn persisted_session_round_trips() {
+        let mut session = info(0x42);
+        session.root_entropy_source = Some([1; 32]);
+        session.full_username = Some("Alice Smith".to_string());
+
+        let blob = encode_persisted_session(&session);
+        let decoded = decode_persisted_session(&blob).expect("session should decode");
+
+        assert_eq!(decoded, session);
+    }
+
+    #[test]
+    fn persisted_sso_session_round_trips() {
+        let mut session = info(0x42);
+        session.sso = Some(SsoSessionInfo {
+            ss_secret: [1; 64],
+            ss_public_key: [2; 32],
+            enc_secret: [3; 32],
+            peer_enc_pubkey: [4; 65],
+            identity_account_id: [5; 32],
+            session_id_own: [6; 32],
+            session_id_peer: [7; 32],
+            request_channel: [8; 32],
+            response_channel: [9; 32],
+            peer_request_channel: [10; 32],
+        });
+
+        let blob = encode_persisted_session(&session);
+        let decoded = decode_persisted_session(&blob).expect("session should decode");
+
+        assert_eq!(decoded, session);
+    }
+
+    #[test]
+    fn persisted_session_rejects_unknown_version() {
+        let mut blob = encode_persisted_session(&info(0x42));
+        blob[0] = 0xff;
+
+        let err = decode_persisted_session(&blob).unwrap_err();
+
+        assert_eq!(err, "unsupported session blob version 255");
+    }
+
+    #[test]
+    fn persisted_v2_session_decodes_without_identity_account() {
+        let legacy = PersistedSessionV2 {
+            public_key: [0x42; 32],
+            sso: None,
+            root_entropy_source: Some([0x24; 32]),
+            lite_username: Some("alice".to_string()),
+            full_username: None,
+        };
+        let blob = (2u8, legacy).encode();
+
+        let decoded = decode_persisted_session(&blob).expect("v2 session should decode");
+
+        assert_eq!(decoded.public_key, [0x42; 32]);
+        assert_eq!(decoded.identity_account_id, None);
+        assert_eq!(decoded.lite_username.as_deref(), Some("alice"));
+    }
+
+    #[test]
+    fn persisted_session_rejects_trailing_bytes() {
+        let mut blob = encode_persisted_session(&info(0x42));
+        blob.push(0);
+
+        let err = decode_persisted_session(&blob).unwrap_err();
+
+        assert_eq!(err, "invalid session blob: trailing bytes");
+    }
+
+    #[test]
+    fn clear_returns_to_empty() {
+        let state = SessionState::new();
+        state.set_session(info(0x01));
+        state.clear_session();
+        assert!(state.current().is_none());
+    }
+
+    #[test]
+    fn subscribe_emits_current_state_first() {
+        let state = SessionState::new();
+        state.set_session(info(0x01));
+        let mut stream = state.subscribe();
+        let first = block_on(stream.next()).expect("expected initial item");
+        assert_eq!(
+            first,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected)
+        );
+    }
+
+    #[test]
+    fn subscribe_emits_disconnected_when_no_session() {
+        let state = SessionState::new();
+        let mut stream = state.subscribe();
+        let first = block_on(stream.next()).expect("expected initial item");
+        assert_eq!(
+            first,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Disconnected)
+        );
+    }
+
+    #[test]
+    fn set_session_broadcasts_connected_to_existing_subscribers() {
+        let state = SessionState::new();
+        let mut stream = state.subscribe();
+        let _ = block_on(stream.next());
+
+        state.set_session(info(0x01));
+        let next = block_on(stream.next()).expect("expected Connected event");
+        assert_eq!(
+            next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected)
+        );
+    }
+
+    #[test]
+    fn clear_session_broadcasts_disconnected_to_existing_subscribers() {
+        let state = SessionState::new();
+        state.set_session(info(0x01));
+        let mut stream = state.subscribe();
+        let _ = block_on(stream.next());
+
+        state.clear_session();
+        let next = block_on(stream.next()).expect("expected Disconnected event");
+        assert_eq!(
+            next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Disconnected)
+        );
+    }
+
+    #[test]
+    fn set_session_with_same_info_does_not_re_emit_connected() {
+        let state = SessionState::new();
+        state.set_session(info(0x01));
+        let mut stream = state.subscribe();
+        let _ = block_on(stream.next());
+
+        state.set_session(info(0x01));
+
+        let pending = stream.next().now_or_never();
+        assert!(
+            pending.is_none(),
+            "no transition event expected for equivalent session"
+        );
+    }
+
+    #[test]
+    fn set_session_with_replacement_re_emits_connected() {
+        let state = SessionState::new();
+        state.set_session(info(0x01));
+        let mut stream = state.subscribe();
+        let _ = block_on(stream.next());
+
+        state.set_session(info(0x02));
+
+        let next = block_on(stream.next()).expect("expected replacement Connected event");
+        assert_eq!(
+            next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected)
+        );
+    }
+
+    #[test]
+    fn multi_subscriber_broadcast() {
+        let state = SessionState::new();
+        let mut a = state.subscribe();
+        let mut b = state.subscribe();
+        // Drain initial Disconnected from both.
+        let _ = block_on(a.next());
+        let _ = block_on(b.next());
+
+        state.set_session(info(0x77));
+        let a_next = block_on(a.next()).expect("a should receive Connected");
+        let b_next = block_on(b.next()).expect("b should receive Connected");
+        assert_eq!(
+            a_next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected)
+        );
+        assert_eq!(
+            b_next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected)
+        );
+    }
+
+    /// Clearing a never-set session is a no-op and must not synthesize a
+    /// spurious `Disconnected` event for live subscribers.
+    #[test]
+    fn clear_when_empty_is_silent_no_op() {
+        let state = SessionState::new();
+        let mut stream = state.subscribe();
+        // Drain the initial Disconnected.
+        let _ = block_on(stream.next());
+
+        state.clear_session();
+
+        let pending = stream.next().now_or_never();
+        assert!(pending.is_none(), "no event expected when clear is a no-op",);
+    }
+
+    /// Dropping a subscriber's stream must remove that sender from the
+    /// broadcast list. The next broadcast prunes it; the surviving stream
+    /// still receives the event.
+    #[test]
+    fn dropped_subscriber_is_pruned() {
+        let state = SessionState::new();
+        let mut survivor = state.subscribe();
+        let dropping = state.subscribe();
+        let _ = block_on(survivor.next());
+        // Drain the initial item from the dropping stream too so we don't
+        // accidentally test buffered-but-undelivered.
+        drop(dropping);
+
+        state.set_session(info(0x33));
+        let next = block_on(survivor.next()).expect("survivor must receive Connected");
+        assert_eq!(
+            next,
+            VersionedItem::V1(HostAccountConnectionStatusSubscribeItem::Connected),
+        );
+
+        // Internally, `set_session`'s broadcast call `retain`-prunes any
+        // dropped senders. After the call the subscribers list should have
+        // exactly one entry (the survivor).
+        let inner = state.inner.lock().unwrap();
+        assert_eq!(inner.subscribers.len(), 1, "dropped subscriber not pruned");
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/sso_messages.rs b/rust/crates/truapi-server/src/host_logic/sso_messages.rs
new file mode 100644
index 00000000..36f499df
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/sso_messages.rs
@@ -0,0 +1,826 @@
+//! SCALE codecs for host-papp 0.7.9 SSO session-channel messages.
+//!
+//! These are the encrypted payloads carried inside statement-store
+//! `SsoStatementData::Request` / `Response` frames.
+
+use parity_scale_codec::{Decode, Encode, Error, Input, Output};
+use truapi::v01;
+
+use crate::host_logic::session::SsoSessionInfo;
+use crate::host_logic::sso_pairing::{
+    AES_GCM_NONCE_LEN, SsoStatementData, decrypt_session_statement_data,
+    encrypt_session_statement_data, encrypt_session_statement_data_with_nonce,
+};
+use crate::host_logic::statement_store::{
+    build_signed_session_request_statement, current_unix_secs, decode_verified_statement_data,
+    statement_expiry_elapsed,
+};
+
+const SSO_RESPONSE_CODE_SUCCESS: u8 = 0;
+
+/// Top-level wallet remote message sent over the encrypted SSO channel.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct RemoteMessage {
+    /// Correlation id used to match wallet responses to host requests.
+    pub message_id: String,
+    /// Versioned remote message body.
+    pub data: RemoteMessageData,
+}
+
+/// Versioned remote message body.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum RemoteMessageData {
+    #[codec(index = 0)]
+    V1(RemoteMessageV1),
+}
+
+/// Host-papp v1 remote message variants.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum RemoteMessageV1 {
+    #[codec(index = 0)]
+    Disconnected,
+    #[codec(index = 1)]
+    SignRequest(Box<SigningRequest>),
+    #[codec(index = 2)]
+    SignResponse(SigningResponse),
+    #[codec(index = 3)]
+    RingVrfAliasRequest(RingVrfAliasRequest),
+    #[codec(index = 4)]
+    RingVrfAliasResponse(RingVrfAliasResponse),
+    #[codec(index = 5)]
+    ResourceAllocationRequest(ResourceAllocationRequest),
+    #[codec(index = 6)]
+    ResourceAllocationResponse(ResourceAllocationResponse),
+    #[codec(index = 7)]
+    CreateTransactionRequest(CreateTransactionRequest),
+    #[codec(index = 8)]
+    CreateTransactionResponse(CreateTransactionResponse),
+}
+
+/// Signing request flavor sent to the wallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SigningRequest {
+    #[codec(index = 0)]
+    Payload(Box<SigningPayloadRequest>),
+    #[codec(index = 1)]
+    Raw(SigningRawRequest),
+}
+
+/// Product-account payload signing request mirrored from host-papp.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SigningPayloadRequest {
+    pub product_account_id: v01::ProductAccountId,
+    pub block_hash: Vec<u8>,
+    pub block_number: Vec<u8>,
+    pub era: Vec<u8>,
+    pub genesis_hash: Vec<u8>,
+    pub method: Vec<u8>,
+    pub nonce: Vec<u8>,
+    pub spec_version: Vec<u8>,
+    pub tip: Vec<u8>,
+    pub transaction_version: Vec<u8>,
+    pub signed_extensions: Vec<String>,
+    pub version: u32,
+    pub asset_id: Option<Vec<u8>>,
+    pub metadata_hash: Option<Vec<u8>>,
+    pub mode: Option<u32>,
+    pub with_signed_transaction: OptionBool,
+}
+
+impl From<v01::HostSignPayloadRequest> for SigningPayloadRequest {
+    fn from(value: v01::HostSignPayloadRequest) -> Self {
+        let payload = value.payload;
+        Self {
+            product_account_id: value.account,
+            block_hash: payload.block_hash,
+            block_number: payload.block_number,
+            era: payload.era,
+            genesis_hash: payload.genesis_hash,
+            method: payload.method,
+            nonce: payload.nonce,
+            spec_version: payload.spec_version,
+            tip: payload.tip,
+            transaction_version: payload.transaction_version,
+            signed_extensions: payload.signed_extensions,
+            version: payload.version,
+            asset_id: payload.asset_id,
+            metadata_hash: payload.metadata_hash,
+            mode: payload.mode,
+            with_signed_transaction: payload.with_signed_transaction.into(),
+        }
+    }
+}
+
+/// Raw signing request mirrored from host-papp.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SigningRawRequest {
+    pub product_account_id: v01::ProductAccountId,
+    pub data: SigningRawPayload,
+}
+
+impl From<v01::HostSignRawRequest> for SigningRawRequest {
+    fn from(value: v01::HostSignRawRequest) -> Self {
+        Self {
+            product_account_id: value.account,
+            data: value.payload.into(),
+        }
+    }
+}
+
+/// Host-papp ternary optional-bool encoding (`none`, `false`, `true`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OptionBool(pub Option<bool>);
+
+impl From<Option<bool>> for OptionBool {
+    fn from(value: Option<bool>) -> Self {
+        Self(value)
+    }
+}
+
+impl Encode for OptionBool {
+    fn size_hint(&self) -> usize {
+        1
+    }
+
+    fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+        dest.push_byte(match self.0 {
+            None => 0,
+            Some(false) => 1,
+            Some(true) => 2,
+        });
+    }
+}
+
+impl Decode for OptionBool {
+    fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+        match u8::decode(input)? {
+            0 => Ok(Self(None)),
+            1 => Ok(Self(Some(false))),
+            2 => Ok(Self(Some(true))),
+            _ => Err("invalid OptionBool discriminant".into()),
+        }
+    }
+}
+
+/// Raw signing payload shape mirrored from host-papp.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SigningRawPayload {
+    #[codec(index = 0)]
+    Bytes(Vec<u8>),
+    #[codec(index = 1)]
+    Payload(String),
+}
+
+impl From<v01::RawPayload> for SigningRawPayload {
+    fn from(value: v01::RawPayload) -> Self {
+        match value {
+            v01::RawPayload::Bytes { bytes } => Self::Bytes(bytes),
+            v01::RawPayload::Payload { payload } => Self::Payload(payload),
+        }
+    }
+}
+
+/// Wallet response to a signing request.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SigningResponse {
+    pub responding_to: String,
+    pub payload: Result<SigningPayloadResponseData, String>,
+}
+
+/// Successful signing response payload.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SigningPayloadResponseData {
+    pub signature: Vec<u8>,
+    pub signed_transaction: Option<Vec<u8>>,
+}
+
+/// Wallet alias request for a product account.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct RingVrfAliasRequest {
+    pub product_account_id: v01::ProductAccountId,
+    pub product_id: String,
+}
+
+/// Wallet alias response.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct RingVrfAliasResponse {
+    pub responding_to: String,
+    pub payload: Result<v01::HostAccountGetAliasResponse, String>,
+}
+
+/// Wallet resource-allocation request.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct ResourceAllocationRequest {
+    pub calling_product_id: String,
+    pub resources: Vec<SsoAllocatableResource>,
+    pub on_existing: OnExistingAllowancePolicy,
+}
+
+/// Resources the wallet may allocate for the calling product.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SsoAllocatableResource {
+    #[codec(index = 0)]
+    StatementStoreAllowance,
+    #[codec(index = 1)]
+    BulletInAllowance,
+    #[codec(index = 2)]
+    SmartContractAllowance(u32),
+    #[codec(index = 3)]
+    AutoSigning,
+}
+
+impl From<v01::AllocatableResource> for SsoAllocatableResource {
+    fn from(value: v01::AllocatableResource) -> Self {
+        match value {
+            v01::AllocatableResource::StatementStoreAllowance => Self::StatementStoreAllowance,
+            v01::AllocatableResource::BulletinAllowance => Self::BulletInAllowance,
+            v01::AllocatableResource::SmartContractAllowance(index) => {
+                Self::SmartContractAllowance(index)
+            }
+            v01::AllocatableResource::AutoSigning => Self::AutoSigning,
+        }
+    }
+}
+
+/// Wallet policy for already-existing resource allowance.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OnExistingAllowancePolicy {
+    #[codec(index = 0)]
+    Ignore,
+    #[codec(index = 1)]
+    Increase,
+}
+
+/// Wallet resource-allocation response.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct ResourceAllocationResponse {
+    pub responding_to: String,
+    pub payload: Result<Vec<SsoAllocationOutcome>, String>,
+}
+
+/// Per-resource allocation result from the wallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SsoAllocationOutcome {
+    #[codec(index = 0)]
+    Allocated(SsoAllocatedResource),
+    #[codec(index = 1)]
+    Rejected,
+    #[codec(index = 2)]
+    NotAvailable,
+}
+
+/// Resource material allocated by the wallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SsoAllocatedResource {
+    #[codec(index = 0)]
+    StatementStoreAllowance { slot_account_key: Vec<u8> },
+    #[codec(index = 1)]
+    BulletInAllowance { slot_account_key: Vec<u8> },
+    #[codec(index = 2)]
+    SmartContractAllowance,
+    #[codec(index = 3)]
+    AutoSigning {
+        product_derivation_secret: String,
+        product_root_private_key: Vec<u8>,
+    },
+}
+
+/// Wallet transaction-creation request.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct CreateTransactionRequest {
+    pub payload: CreateTransactionPayload,
+}
+
+/// Versioned transaction-creation payload.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum CreateTransactionPayload {
+    #[codec(index = 0)]
+    V1(v01::ProductAccountTxPayload),
+}
+
+/// Wallet transaction-creation response.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct CreateTransactionResponse {
+    pub responding_to: String,
+    pub signed_transaction: Result<Vec<u8>, String>,
+}
+
+/// Decoded inbound statement-channel outcome.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SsoSessionStatement {
+    RequestAccepted,
+    RemoteResponse(SsoRemoteResponse),
+    Disconnected,
+}
+
+/// Wallet response variants that can satisfy a pending remote request.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SsoRemoteResponse {
+    Sign(SigningResponse),
+    RingVrfAlias(RingVrfAliasResponse),
+    ResourceAllocation(ResourceAllocationResponse),
+    CreateTransaction(CreateTransactionResponse),
+}
+
+/// Decode and classify an inbound encrypted SSO session statement.
+pub fn decode_sso_session_statement(
+    session: &SsoSessionInfo,
+    statement: &[u8],
+    expected_statement_request_id: &str,
+    expected_remote_message_id: &str,
+) -> Result<Option<SsoSessionStatement>, String> {
+    let verified =
+        decode_verified_statement_data(statement, None).map_err(|err| err.to_string())?;
+    // Freshness gate against replay: a statement whose expiry is in the past
+    // is ignored. Trusts the local clock.
+    if verified
+        .expiry
+        .is_some_and(|expiry| statement_expiry_elapsed(expiry, current_unix_secs()))
+    {
+        return Ok(None);
+    }
+    let encrypted = verified.data;
+    let data = decrypt_session_statement_data(session, &encrypted)?;
+    if verified.signer == session.ss_public_key {
+        return match data {
+            SsoStatementData::Response {
+                request_id,
+                response_code,
+            } if request_id == expected_statement_request_id => {
+                if response_code == SSO_RESPONSE_CODE_SUCCESS {
+                    Ok(Some(SsoSessionStatement::RequestAccepted))
+                } else {
+                    Err(format!(
+                        "SSO request {request_id} was rejected: {}",
+                        sso_response_code_name(response_code)
+                    ))
+                }
+            }
+            _ => Ok(None),
+        };
+    }
+    if verified.signer != session.identity_account_id {
+        return Err("statement proof signer does not match expected peer".to_string());
+    }
+    match data {
+        SsoStatementData::Response {
+            request_id,
+            response_code,
+        } if request_id == expected_statement_request_id => {
+            if response_code == SSO_RESPONSE_CODE_SUCCESS {
+                Ok(Some(SsoSessionStatement::RequestAccepted))
+            } else {
+                Err(format!(
+                    "SSO request {request_id} was rejected: {}",
+                    sso_response_code_name(response_code)
+                ))
+            }
+        }
+        SsoStatementData::Response { .. } => Ok(None),
+        SsoStatementData::Request { data, .. } => {
+            for message in data {
+                let message = RemoteMessage::decode(&mut message.as_slice())
+                    .map_err(|err| format!("invalid SSO remote message: {err}"))?;
+                if matches!(
+                    &message.data,
+                    RemoteMessageData::V1(RemoteMessageV1::Disconnected)
+                ) {
+                    return Ok(Some(SsoSessionStatement::Disconnected));
+                }
+                if let Some(response) =
+                    remote_response_for_message(message, expected_remote_message_id)
+                {
+                    return Ok(Some(SsoSessionStatement::RemoteResponse(response)));
+                }
+            }
+            Ok(None)
+        }
+    }
+}
+
+fn remote_response_for_message(
+    message: RemoteMessage,
+    expected_remote_message_id: &str,
+) -> Option<SsoRemoteResponse> {
+    let RemoteMessageData::V1(data) = message.data;
+    match data {
+        RemoteMessageV1::SignResponse(response)
+            if response.responding_to == expected_remote_message_id =>
+        {
+            Some(SsoRemoteResponse::Sign(response))
+        }
+        RemoteMessageV1::RingVrfAliasResponse(response)
+            if response.responding_to == expected_remote_message_id =>
+        {
+            Some(SsoRemoteResponse::RingVrfAlias(response))
+        }
+        RemoteMessageV1::ResourceAllocationResponse(response)
+            if response.responding_to == expected_remote_message_id =>
+        {
+            Some(SsoRemoteResponse::ResourceAllocation(response))
+        }
+        RemoteMessageV1::CreateTransactionResponse(response)
+            if response.responding_to == expected_remote_message_id =>
+        {
+            Some(SsoRemoteResponse::CreateTransaction(response))
+        }
+        _ => None,
+    }
+}
+
+fn sso_response_code_name(code: u8) -> &'static str {
+    match code {
+        1 => "decodingFailed",
+        2 => "decryptionFailed",
+        3 => "unknown",
+        _ => "unrecognized response code",
+    }
+}
+
+/// Build a wallet payload-signing request message.
+pub fn sign_payload_message(
+    message_id: String,
+    request: v01::HostSignPayloadRequest,
+) -> RemoteMessage {
+    RemoteMessage {
+        message_id,
+        data: RemoteMessageData::V1(RemoteMessageV1::SignRequest(Box::new(
+            SigningRequest::Payload(Box::new(request.into())),
+        ))),
+    }
+}
+
+/// Build a wallet raw-signing request message.
+pub fn sign_raw_message(message_id: String, request: v01::HostSignRawRequest) -> RemoteMessage {
+    RemoteMessage {
+        message_id,
+        data: RemoteMessageData::V1(RemoteMessageV1::SignRequest(Box::new(SigningRequest::Raw(
+            request.into(),
+        )))),
+    }
+}
+
+/// Build a wallet account-alias request message.
+pub fn alias_request_message(
+    message_id: String,
+    product_account_id: v01::ProductAccountId,
+    product_id: String,
+) -> RemoteMessage {
+    RemoteMessage {
+        message_id,
+        data: RemoteMessageData::V1(RemoteMessageV1::RingVrfAliasRequest(RingVrfAliasRequest {
+            product_account_id,
+            product_id,
+        })),
+    }
+}
+
+/// Build a wallet resource-allocation request message.
+pub fn resource_allocation_message(
+    message_id: String,
+    calling_product_id: String,
+    resources: Vec<v01::AllocatableResource>,
+    on_existing: OnExistingAllowancePolicy,
+) -> RemoteMessage {
+    RemoteMessage {
+        message_id,
+        data: RemoteMessageData::V1(RemoteMessageV1::ResourceAllocationRequest(
+            ResourceAllocationRequest {
+                calling_product_id,
+                resources: resources.into_iter().map(Into::into).collect(),
+                on_existing,
+            },
+        )),
+    }
+}
+
+/// Build a wallet transaction-creation request message.
+pub fn create_transaction_message(
+    message_id: String,
+    payload: v01::ProductAccountTxPayload,
+) -> RemoteMessage {
+    RemoteMessage {
+        message_id,
+        data: RemoteMessageData::V1(RemoteMessageV1::CreateTransactionRequest(
+            CreateTransactionRequest {
+                payload: CreateTransactionPayload::V1(payload),
+            },
+        )),
+    }
+}
+
+/// Build a signed outbound SSO request statement with a random nonce.
+pub fn build_outgoing_request_statement(
+    session: &SsoSessionInfo,
+    statement_request_id: String,
+    messages: Vec<RemoteMessage>,
+    expiry: u64,
+) -> Result<Vec<u8>, String> {
+    let encrypted = encrypt_outgoing_request_data(session, statement_request_id, messages)?;
+    build_signed_session_request_statement(session, encrypted, expiry)
+}
+
+/// Build a signed outbound SSO request statement with a caller-supplied nonce.
+pub fn build_outgoing_request_statement_with_nonce(
+    session: &SsoSessionInfo,
+    statement_request_id: String,
+    messages: Vec<RemoteMessage>,
+    expiry: u64,
+    nonce: [u8; AES_GCM_NONCE_LEN],
+) -> Result<Vec<u8>, String> {
+    let encrypted =
+        encrypt_outgoing_request_data_with_nonce(session, statement_request_id, messages, nonce)?;
+    build_signed_session_request_statement(session, encrypted, expiry)
+}
+
+fn encrypt_outgoing_request_data(
+    session: &SsoSessionInfo,
+    statement_request_id: String,
+    messages: Vec<RemoteMessage>,
+) -> Result<Vec<u8>, String> {
+    encrypt_session_statement_data(
+        session,
+        &outgoing_request_data(statement_request_id, messages),
+    )
+}
+
+fn encrypt_outgoing_request_data_with_nonce(
+    session: &SsoSessionInfo,
+    statement_request_id: String,
+    messages: Vec<RemoteMessage>,
+    nonce: [u8; AES_GCM_NONCE_LEN],
+) -> Result<Vec<u8>, String> {
+    encrypt_session_statement_data_with_nonce(
+        session,
+        &outgoing_request_data(statement_request_id, messages),
+        nonce,
+    )
+}
+
+fn outgoing_request_data(
+    statement_request_id: String,
+    messages: Vec<RemoteMessage>,
+) -> SsoStatementData {
+    SsoStatementData::Request {
+        request_id: statement_request_id,
+        data: messages
+            .into_iter()
+            .map(|message| message.encode())
+            .collect(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::host_logic::sso_pairing::decrypt_session_statement_data;
+    use crate::host_logic::statement_store::{
+        StatementField, build_signed_statement, decode_statement_data,
+    };
+    use p256::SecretKey as P256SecretKey;
+    use p256::elliptic_curve::sec1::ToEncodedPoint;
+    use schnorrkel::{ExpansionMode, MiniSecretKey};
+
+    fn account() -> v01::ProductAccountId {
+        v01::ProductAccountId {
+            dot_ns_identifier: "myapp.dot".to_string(),
+            derivation_index: 7,
+        }
+    }
+
+    fn fresh_expiry() -> u64 {
+        (current_unix_secs() + 60) << 32
+    }
+
+    fn elapsed_expiry() -> u64 {
+        (current_unix_secs() - 60) << 32
+    }
+
+    fn session() -> SsoSessionInfo {
+        let mini_secret = MiniSecretKey::from_bytes(&[7; 32]).unwrap();
+        let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+        let core_secret = P256SecretKey::from_slice(&[1; 32]).unwrap();
+        let peer_secret = P256SecretKey::from_slice(&[2; 32]).unwrap();
+        SsoSessionInfo {
+            ss_secret: keypair.secret.to_bytes(),
+            ss_public_key: keypair.public.to_bytes(),
+            enc_secret: core_secret.to_bytes().into(),
+            peer_enc_pubkey: peer_secret
+                .public_key()
+                .to_encoded_point(false)
+                .as_bytes()
+                .try_into()
+                .unwrap(),
+            identity_account_id: [3; 32],
+            session_id_own: [4; 32],
+            session_id_peer: [5; 32],
+            request_channel: [6; 32],
+            response_channel: [7; 32],
+            peer_request_channel: [8; 32],
+        }
+    }
+
+    #[test]
+    fn disconnected_message_matches_host_papp_variant_order() {
+        let message = RemoteMessage {
+            message_id: String::new(),
+            data: RemoteMessageData::V1(RemoteMessageV1::Disconnected),
+        };
+
+        assert_eq!(message.encode(), vec![0, 0, 0]);
+    }
+
+    #[test]
+    fn raw_sign_request_uses_remote_message_variant_indices() {
+        let message = sign_raw_message(
+            "m1".to_string(),
+            v01::HostSignRawRequest {
+                account: account(),
+                payload: v01::RawPayload::Bytes {
+                    bytes: vec![0xde, 0xad],
+                },
+            },
+        );
+        let encoded = message.encode();
+
+        assert_eq!(&encoded[..3], &[8, b'm', b'1']);
+        assert_eq!(encoded[3], 0);
+        assert_eq!(encoded[4], 1);
+        assert_eq!(encoded[5], 1);
+    }
+
+    #[test]
+    fn option_bool_matches_host_papp_option_bool_encoding() {
+        let mut request = v01::HostSignPayloadRequest {
+            account: account(),
+            payload: v01::HostSignPayloadData {
+                block_hash: vec![],
+                block_number: vec![],
+                era: vec![],
+                genesis_hash: vec![],
+                method: vec![],
+                nonce: vec![],
+                spec_version: vec![],
+                tip: vec![],
+                transaction_version: vec![],
+                signed_extensions: vec![],
+                version: 4,
+                asset_id: None,
+                metadata_hash: None,
+                mode: None,
+                with_signed_transaction: Some(true),
+            },
+        };
+        let true_encoded = SigningPayloadRequest::from(request.clone()).encode();
+        request.payload.with_signed_transaction = Some(false);
+        let false_encoded = SigningPayloadRequest::from(request.clone()).encode();
+        request.payload.with_signed_transaction = None;
+        let none_encoded = SigningPayloadRequest::from(request).encode();
+
+        assert_eq!(true_encoded.last(), Some(&2));
+        assert_eq!(false_encoded.last(), Some(&1));
+        assert_eq!(none_encoded.last(), Some(&0));
+    }
+
+    #[test]
+    fn maps_public_resource_names_to_sso_dialect() {
+        let message = resource_allocation_message(
+            "alloc".to_string(),
+            "myapp.dot".to_string(),
+            vec![
+                v01::AllocatableResource::StatementStoreAllowance,
+                v01::AllocatableResource::BulletinAllowance,
+                v01::AllocatableResource::SmartContractAllowance(9),
+                v01::AllocatableResource::AutoSigning,
+            ],
+            OnExistingAllowancePolicy::Increase,
+        );
+        let RemoteMessageData::V1(RemoteMessageV1::ResourceAllocationRequest(request)) =
+            message.data
+        else {
+            panic!("expected resource allocation request");
+        };
+
+        assert_eq!(
+            request.resources,
+            vec![
+                SsoAllocatableResource::StatementStoreAllowance,
+                SsoAllocatableResource::BulletInAllowance,
+                SsoAllocatableResource::SmartContractAllowance(9),
+                SsoAllocatableResource::AutoSigning,
+            ]
+        );
+        assert_eq!(request.on_existing, OnExistingAllowancePolicy::Increase);
+    }
+
+    #[test]
+    fn builds_signed_encrypted_outgoing_request_statement() {
+        let session = session();
+        let remote_message = sign_raw_message(
+            "remote-1".to_string(),
+            v01::HostSignRawRequest {
+                account: account(),
+                payload: v01::RawPayload::Payload {
+                    payload: "<Bytes>hello</Bytes>".to_string(),
+                },
+            },
+        );
+
+        let statement = build_outgoing_request_statement_with_nonce(
+            &session,
+            "statement-1".to_string(),
+            vec![remote_message.clone()],
+            99,
+            [9; AES_GCM_NONCE_LEN],
+        )
+        .unwrap();
+        let encrypted = decode_statement_data(&statement).unwrap();
+        let decrypted = decrypt_session_statement_data(&session, &encrypted).unwrap();
+
+        let SsoStatementData::Request { request_id, data } = decrypted else {
+            panic!("expected request statement data");
+        };
+        assert_eq!(request_id, "statement-1");
+        assert_eq!(data.len(), 1);
+        assert_eq!(
+            RemoteMessage::decode(&mut data[0].as_slice()).unwrap(),
+            remote_message
+        );
+
+        let fields = Vec::<StatementField>::decode(&mut statement.as_slice()).unwrap();
+        assert_eq!(fields[1], StatementField::Expiry(99));
+        assert_eq!(fields[2], StatementField::Channel(session.request_channel));
+        assert_eq!(fields[3], StatementField::Topic1(session.session_id_own));
+    }
+
+    #[test]
+    fn ignores_own_echoed_session_request_statement() {
+        let session = session();
+        let remote_message = sign_raw_message(
+            "remote-1".to_string(),
+            v01::HostSignRawRequest {
+                account: account(),
+                payload: v01::RawPayload::Payload {
+                    payload: "<Bytes>hello</Bytes>".to_string(),
+                },
+            },
+        );
+        let statement = build_outgoing_request_statement_with_nonce(
+            &session,
+            "statement-1".to_string(),
+            vec![remote_message],
+            fresh_expiry(),
+            [9; AES_GCM_NONCE_LEN],
+        )
+        .unwrap();
+
+        let decoded =
+            decode_sso_session_statement(&session, &statement, "statement-1", "remote-1").unwrap();
+
+        assert_eq!(decoded, None);
+    }
+
+    fn response_ack_statement(session: &SsoSessionInfo, expiry: u64) -> Vec<u8> {
+        let encrypted = encrypt_session_statement_data_with_nonce(
+            session,
+            &SsoStatementData::Response {
+                request_id: "statement-1".to_string(),
+                response_code: SSO_RESPONSE_CODE_SUCCESS,
+            },
+            [9; AES_GCM_NONCE_LEN],
+        )
+        .unwrap();
+        build_signed_statement(
+            session,
+            session.response_channel,
+            session.session_id_own,
+            encrypted,
+            expiry,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn accepts_own_echoed_session_response_ack() {
+        let session = session();
+        let statement = response_ack_statement(&session, fresh_expiry());
+
+        let decoded =
+            decode_sso_session_statement(&session, &statement, "statement-1", "remote-1").unwrap();
+
+        assert_eq!(decoded, Some(SsoSessionStatement::RequestAccepted));
+    }
+
+    /// A statement whose expiry is in the past must be ignored even when it
+    /// would otherwise match the pending request (replay protection).
+    #[test]
+    fn ignores_expired_session_response_ack() {
+        let session = session();
+        let statement = response_ack_statement(&session, elapsed_expiry());
+
+        let decoded =
+            decode_sso_session_statement(&session, &statement, "statement-1", "remote-1").unwrap();
+
+        assert_eq!(decoded, None);
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/sso_pairing.rs b/rust/crates/truapi-server/src/host_logic/sso_pairing.rs
new file mode 100644
index 00000000..c5156d8b
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/sso_pairing.rs
@@ -0,0 +1,814 @@
+//! SSO pairing bootstrap helpers.
+//!
+//! This module owns the byte shape of the QR/deeplink payload described in
+//! `docs/design/host-contract-and-core-impl/H - sso-pairing-protocol.md`.
+
+use aes_gcm::aead::{Aead, KeyInit};
+use aes_gcm::{Aes256Gcm, Nonce};
+use blake2_rfc::blake2b::blake2b;
+use hkdf::Hkdf;
+use p256::ecdh::diffie_hellman;
+use p256::elliptic_curve::sec1::ToEncodedPoint;
+use p256::{PublicKey, SecretKey};
+use parity_scale_codec::{Decode, Encode};
+use schnorrkel::{ExpansionMode, MiniSecretKey};
+use sha2::Sha256;
+use thiserror::Error;
+use truapi_platform::{PairingDeeplinkScheme, RuntimeConfig};
+
+use crate::host_logic::session::SsoSessionInfo;
+
+const HANDSHAKE_TOPIC_SUFFIX: &[u8] = b"topic";
+const MAX_P256_SECRET_ATTEMPTS: usize = 64;
+/// Byte length of the AES-GCM nonce prepended to encrypted SSO payloads.
+pub const AES_GCM_NONCE_LEN: usize = 12;
+const SESSION_PREFIX: &[u8] = b"session";
+const PIN_SEPARATOR: &[u8] = b"/";
+const REQUEST_CHANNEL_SUFFIX: &[u8] = b"request";
+const RESPONSE_CHANNEL_SUFFIX: &[u8] = b"response";
+
+/// QR/deeplink bootstrap material generated by the host for one pairing flow.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PairingBootstrap {
+    pub deeplink: String,
+    pub topic: [u8; 32],
+    pub statement_store_public_key: [u8; 32],
+    pub statement_store_secret: [u8; 64],
+    pub encryption_public_key: [u8; 65],
+    pub encryption_secret_key: [u8; 32],
+}
+
+/// Persistable device identity reused across pairing attempts.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct PairingDeviceIdentity {
+    pub statement_store_secret: [u8; 64],
+    pub statement_store_public_key: [u8; 32],
+    pub encryption_secret_key: [u8; 32],
+    pub encryption_public_key: [u8; 65],
+}
+
+/// Errors that can occur while generating pairing bootstrap material.
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum PairingBootstrapError {
+    #[error("failed to generate random pairing material: {0}")]
+    Random(String),
+    #[error("failed to generate P-256 pairing key")]
+    InvalidP256Secret,
+}
+
+/// Versioned SCALE payload embedded in the pairing deeplink.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum VersionedHandshakeProposal {
+    #[codec(index = 0)]
+    ReservedV1,
+    #[codec(index = 1)]
+    V2(HandshakeProposalV2),
+}
+
+/// Host-papp v2 handshake proposal sent by the host.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct HandshakeProposalV2 {
+    pub device: HandshakeDevice,
+    pub metadata: Vec<HandshakeMetadataEntry>,
+}
+
+/// Device keys advertised in the v2 handshake proposal.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct HandshakeDevice {
+    pub statement_account_id: [u8; 32],
+    pub encryption_public_key: [u8; 65],
+}
+
+/// Metadata key/value entry attached to a v2 handshake proposal.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct HandshakeMetadataEntry(pub HandshakeMetadataKey, pub String);
+
+/// Metadata keys understood by the mobile SSO pairing flow.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum HandshakeMetadataKey {
+    #[codec(index = 0)]
+    Custom(String),
+    #[codec(index = 1)]
+    HostName,
+    #[codec(index = 2)]
+    HostVersion,
+    #[codec(index = 3)]
+    HostIcon,
+    #[codec(index = 4)]
+    PlatformType,
+    #[codec(index = 5)]
+    PlatformVersion,
+}
+
+/// Versioned encrypted response posted by the wallet to the pairing topic.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum VersionedHandshakeResponse {
+    #[codec(index = 0)]
+    V1 {
+        encrypted_message: Vec<u8>,
+        public_key: [u8; 65],
+    },
+    #[codec(index = 1)]
+    V2 {
+        encrypted_message: Vec<u8>,
+        public_key: [u8; 65],
+    },
+}
+
+/// Legacy v1 plaintext handshake answer.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SsoHandshakeAnswerV1 {
+    pub shared_secret_derivation_key: [u8; 65],
+    pub root_user_account_id: [u8; 32],
+    pub identity_account_id: [u8; 32],
+}
+
+/// Plaintext v2 wallet response after decrypting the pairing statement.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum EncryptedHandshakeResponseV2 {
+    #[codec(index = 0)]
+    Pending(HandshakeStatusV2),
+    #[codec(index = 1)]
+    Success(Box<HandshakeSuccessV2>),
+    #[codec(index = 2)]
+    Failed(String),
+}
+
+/// Intermediate v2 handshake status emitted before success/failure.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum HandshakeStatusV2 {
+    #[codec(index = 0)]
+    AllowanceAllocation,
+}
+
+/// Successful v2 handshake payload used to establish the SSO session.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct HandshakeSuccessV2 {
+    pub identity_account_id: [u8; 32],
+    pub root_account_id: [u8; 32],
+    pub identity_chat_private_key: [u8; 32],
+    pub sso_enc_pub_key: [u8; 65],
+    pub device_enc_pub_key: [u8; 65],
+    pub root_entropy_source: [u8; 32],
+}
+
+/// Encrypted statement-channel envelope shared with the wallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum SsoStatementData {
+    #[codec(index = 0)]
+    Request {
+        request_id: String,
+        data: Vec<Vec<u8>>,
+    },
+    #[codec(index = 1)]
+    Response {
+        request_id: String,
+        response_code: u8,
+    },
+}
+
+/// Decode wallet-posted pairing handshake data from SCALE bytes.
+pub fn decode_app_handshake_data(blob: &[u8]) -> Result<VersionedHandshakeResponse, String> {
+    let mut input = blob;
+    let value: VersionedHandshakeResponse =
+        Decode::decode(&mut input).map_err(|err| format!("invalid app handshake data: {err}"))?;
+    if !input.is_empty() {
+        return Err("invalid app handshake data: trailing bytes".to_string());
+    }
+    Ok(value)
+}
+
+/// Decrypt a legacy v1 handshake answer.
+pub fn decrypt_handshake_answer(
+    core_encryption_secret_key: [u8; 32],
+    wallet_ephemeral_public_key: [u8; 65],
+    encrypted_message: &[u8],
+) -> Result<SsoHandshakeAnswerV1, String> {
+    let plaintext = decrypt_p256_hkdf_aes_gcm(
+        core_encryption_secret_key,
+        wallet_ephemeral_public_key,
+        encrypted_message,
+    )?;
+    let mut input = plaintext.as_slice();
+    let value = SsoHandshakeAnswerV1::decode(&mut input)
+        .map_err(|err| format!("invalid SSO handshake answer: {err}"))?;
+    if !input.is_empty() {
+        return Err("invalid SSO handshake answer: trailing bytes".to_string());
+    }
+    Ok(value)
+}
+
+/// Decrypt a v2 handshake response.
+pub fn decrypt_v2_handshake_response(
+    core_encryption_secret_key: [u8; 32],
+    wallet_ephemeral_public_key: [u8; 65],
+    encrypted_message: &[u8],
+) -> Result<EncryptedHandshakeResponseV2, String> {
+    let plaintext = decrypt_p256_hkdf_aes_gcm(
+        core_encryption_secret_key,
+        wallet_ephemeral_public_key,
+        encrypted_message,
+    )?;
+    let mut input = plaintext.as_slice();
+    let value = EncryptedHandshakeResponseV2::decode(&mut input)
+        .map_err(|err| format!("invalid SSO V2 handshake response: {err}"))?;
+    if !input.is_empty() {
+        return Err("invalid SSO V2 handshake response: trailing bytes".to_string());
+    }
+    Ok(value)
+}
+
+/// Derive the persistent SSO session channels from a successful handshake.
+pub fn establish_sso_session_info(
+    bootstrap: &PairingBootstrap,
+    peer_statement_account_id: [u8; 32],
+    peer_sso_enc_pub_key: [u8; 65],
+) -> Result<SsoSessionInfo, String> {
+    let shared_secret = shared_secret(bootstrap.encryption_secret_key, peer_sso_enc_pub_key)?;
+    let shared_secret_bytes: [u8; 32] = (*shared_secret.raw_secret_bytes()).into();
+    let session_id_own = create_session_id(
+        shared_secret_bytes,
+        bootstrap.statement_store_public_key,
+        peer_statement_account_id,
+    );
+    let session_id_peer = create_session_id(
+        shared_secret_bytes,
+        peer_statement_account_id,
+        bootstrap.statement_store_public_key,
+    );
+
+    Ok(SsoSessionInfo {
+        ss_secret: bootstrap.statement_store_secret,
+        ss_public_key: bootstrap.statement_store_public_key,
+        enc_secret: bootstrap.encryption_secret_key,
+        peer_enc_pubkey: peer_sso_enc_pub_key,
+        identity_account_id: peer_statement_account_id,
+        session_id_own,
+        session_id_peer,
+        request_channel: keyed_hash(session_id_own, REQUEST_CHANNEL_SUFFIX),
+        response_channel: keyed_hash(session_id_own, RESPONSE_CHANNEL_SUFFIX),
+        peer_request_channel: keyed_hash(session_id_peer, REQUEST_CHANNEL_SUFFIX),
+    })
+}
+
+/// Encrypt session-channel statement data with a random nonce.
+pub fn encrypt_session_statement_data(
+    session: &SsoSessionInfo,
+    data: &SsoStatementData,
+) -> Result<Vec<u8>, String> {
+    let mut nonce = [0u8; AES_GCM_NONCE_LEN];
+    getrandom::getrandom(&mut nonce)
+        .map_err(|err| format!("failed to generate AES-GCM nonce: {err}"))?;
+    encrypt_session_statement_data_with_nonce(session, data, nonce)
+}
+
+/// Encrypt session-channel statement data with a caller-supplied nonce.
+pub fn encrypt_session_statement_data_with_nonce(
+    session: &SsoSessionInfo,
+    data: &SsoStatementData,
+    nonce: [u8; AES_GCM_NONCE_LEN],
+) -> Result<Vec<u8>, String> {
+    let aes_key = session_aes_key(session)?;
+    let cipher = Aes256Gcm::new_from_slice(&aes_key)
+        .map_err(|err| format!("failed to initialize AES-GCM: {err}"))?;
+    let mut encrypted = nonce.to_vec();
+    encrypted.extend(
+        cipher
+            .encrypt(Nonce::from_slice(&nonce), data.encode().as_slice())
+            .map_err(|err| format!("failed to encrypt SSO statement data: {err}"))?,
+    );
+    Ok(encrypted)
+}
+
+/// Decrypt session-channel statement data.
+pub fn decrypt_session_statement_data(
+    session: &SsoSessionInfo,
+    encrypted_message: &[u8],
+) -> Result<SsoStatementData, String> {
+    let plaintext = decrypt_session_message(session, encrypted_message)?;
+    let mut input = plaintext.as_slice();
+    let data = SsoStatementData::decode(&mut input)
+        .map_err(|err| format!("invalid SSO statement data: {err}"))?;
+    if !input.is_empty() {
+        return Err("invalid SSO statement data: trailing bytes".to_string());
+    }
+    Ok(data)
+}
+
+fn decrypt_p256_hkdf_aes_gcm(
+    own_secret_key: [u8; 32],
+    peer_public_key: [u8; 65],
+    encrypted_message: &[u8],
+) -> Result<Vec<u8>, String> {
+    if encrypted_message.len() < AES_GCM_NONCE_LEN {
+        return Err("encrypted SSO handshake answer is too short".to_string());
+    }
+    let shared_secret = shared_secret(own_secret_key, peer_public_key)?;
+    let aes_key = aes_key_from_shared_secret(&shared_secret)?;
+
+    decrypt_aes_gcm_with_key(aes_key, encrypted_message, "handshake answer")
+}
+
+fn decrypt_session_message(
+    session: &SsoSessionInfo,
+    encrypted_message: &[u8],
+) -> Result<Vec<u8>, String> {
+    decrypt_aes_gcm_with_key(
+        session_aes_key(session)?,
+        encrypted_message,
+        "statement data",
+    )
+}
+
+fn decrypt_aes_gcm_with_key(
+    aes_key: [u8; 32],
+    encrypted_message: &[u8],
+    label: &str,
+) -> Result<Vec<u8>, String> {
+    if encrypted_message.len() < AES_GCM_NONCE_LEN {
+        return Err(format!("encrypted SSO {label} is too short"));
+    }
+    let (nonce, ciphertext) = encrypted_message.split_at(AES_GCM_NONCE_LEN);
+    let cipher = Aes256Gcm::new_from_slice(&aes_key)
+        .map_err(|err| format!("failed to initialize AES-GCM: {err}"))?;
+    cipher
+        .decrypt(Nonce::from_slice(nonce), ciphertext)
+        .map_err(|err| format!("failed to decrypt SSO {label}: {err}"))
+}
+
+fn session_aes_key(session: &SsoSessionInfo) -> Result<[u8; 32], String> {
+    let shared_secret = shared_secret(session.enc_secret, session.peer_enc_pubkey)?;
+    aes_key_from_shared_secret(&shared_secret)
+}
+
+fn aes_key_from_shared_secret(
+    shared_secret: &p256::ecdh::SharedSecret,
+) -> Result<[u8; 32], String> {
+    let hkdf = Hkdf::<Sha256>::new(None, shared_secret.raw_secret_bytes());
+    let mut aes_key = [0u8; 32];
+    hkdf.expand(&[], &mut aes_key)
+        .map_err(|err| format!("failed to derive AES key: {err}"))?;
+    Ok(aes_key)
+}
+
+fn shared_secret(
+    own_secret_key: [u8; 32],
+    peer_public_key: [u8; 65],
+) -> Result<p256::ecdh::SharedSecret, String> {
+    let secret = SecretKey::from_slice(&own_secret_key)
+        .map_err(|err| format!("invalid P-256 secret key: {err}"))?;
+    let peer_public = PublicKey::from_sec1_bytes(&peer_public_key)
+        .map_err(|err| format!("invalid P-256 public key: {err}"))?;
+    Ok(diffie_hellman(
+        secret.to_nonzero_scalar(),
+        peer_public.as_affine(),
+    ))
+}
+
+fn create_session_id(
+    shared_secret: [u8; 32],
+    account_a: [u8; 32],
+    account_b: [u8; 32],
+) -> [u8; 32] {
+    let mut message = Vec::with_capacity(SESSION_PREFIX.len() + 32 + 32 + 2);
+    message.extend_from_slice(SESSION_PREFIX);
+    message.extend_from_slice(&account_a);
+    message.extend_from_slice(&account_b);
+    message.extend_from_slice(PIN_SEPARATOR);
+    message.extend_from_slice(PIN_SEPARATOR);
+    keyed_hash(shared_secret, &message)
+}
+
+fn keyed_hash(key: [u8; 32], message: &[u8]) -> [u8; 32] {
+    let digest = blake2b(32, &key, message);
+    let mut output = [0u8; 32];
+    output.copy_from_slice(digest.as_bytes());
+    output
+}
+
+/// Create one-shot pairing bootstrap material from runtime config.
+pub fn create_pairing_bootstrap(
+    config: &RuntimeConfig,
+) -> Result<PairingBootstrap, PairingBootstrapError> {
+    create_pairing_bootstrap_from_identity(config, generate_pairing_device_identity()?)
+}
+
+/// Generate a fresh persistable pairing device identity.
+pub fn generate_pairing_device_identity() -> Result<PairingDeviceIdentity, PairingBootstrapError> {
+    let (statement_store_secret, statement_store_public_key) = generate_statement_store_keypair()?;
+    let (encryption_secret_key, encryption_public_key) = generate_p256_keypair()?;
+
+    Ok(PairingDeviceIdentity {
+        statement_store_secret,
+        statement_store_public_key,
+        encryption_secret_key,
+        encryption_public_key,
+    })
+}
+
+/// Create pairing bootstrap material from an existing device identity.
+pub fn create_pairing_bootstrap_from_identity(
+    config: &RuntimeConfig,
+    identity: PairingDeviceIdentity,
+) -> Result<PairingBootstrap, PairingBootstrapError> {
+    let deeplink = build_pairing_deeplink(
+        config.pairing_deeplink_scheme,
+        identity.statement_store_public_key,
+        identity.encryption_public_key,
+        config,
+    );
+    let topic = bootstrap_topic(
+        identity.statement_store_public_key,
+        identity.encryption_public_key,
+    );
+
+    Ok(PairingBootstrap {
+        deeplink,
+        topic,
+        statement_store_public_key: identity.statement_store_public_key,
+        statement_store_secret: identity.statement_store_secret,
+        encryption_public_key: identity.encryption_public_key,
+        encryption_secret_key: identity.encryption_secret_key,
+    })
+}
+
+/// Build the wallet deeplink that carries the v2 handshake proposal.
+pub fn build_pairing_deeplink(
+    scheme: PairingDeeplinkScheme,
+    statement_store_public_key: [u8; 32],
+    encryption_public_key: [u8; 65],
+    config: &RuntimeConfig,
+) -> String {
+    let handshake = VersionedHandshakeProposal::V2(HandshakeProposalV2 {
+        device: HandshakeDevice {
+            statement_account_id: statement_store_public_key,
+            encryption_public_key,
+        },
+        metadata: handshake_metadata(config),
+    });
+    format!(
+        "{}pair?handshake={}",
+        deeplink_scheme_prefix(scheme),
+        hex::encode(handshake.encode())
+    )
+}
+
+fn handshake_metadata(config: &RuntimeConfig) -> Vec<HandshakeMetadataEntry> {
+    let mut entries = vec![HandshakeMetadataEntry(
+        HandshakeMetadataKey::HostName,
+        config.host_name.clone(),
+    )];
+    if let Some(value) = &config.host_version {
+        entries.push(HandshakeMetadataEntry(
+            HandshakeMetadataKey::HostVersion,
+            value.clone(),
+        ));
+    }
+    if let Some(value) = &config.host_icon {
+        entries.push(HandshakeMetadataEntry(
+            HandshakeMetadataKey::HostIcon,
+            value.clone(),
+        ));
+    }
+    if let Some(value) = &config.platform_type {
+        entries.push(HandshakeMetadataEntry(
+            HandshakeMetadataKey::PlatformType,
+            value.clone(),
+        ));
+    }
+    if let Some(value) = &config.platform_version {
+        entries.push(HandshakeMetadataEntry(
+            HandshakeMetadataKey::PlatformVersion,
+            value.clone(),
+        ));
+    }
+    entries
+}
+
+/// Derive the statement-store pairing topic from advertised host keys.
+pub fn bootstrap_topic(
+    statement_store_public_key: [u8; 32],
+    encryption_public_key: [u8; 65],
+) -> [u8; 32] {
+    let mut message =
+        Vec::with_capacity(encryption_public_key.len() + HANDSHAKE_TOPIC_SUFFIX.len());
+    message.extend_from_slice(&encryption_public_key);
+    message.extend_from_slice(HANDSHAKE_TOPIC_SUFFIX);
+
+    let digest = blake2b(32, &statement_store_public_key, &message);
+    let mut topic = [0u8; 32];
+    topic.copy_from_slice(digest.as_bytes());
+    topic
+}
+
+fn deeplink_scheme_prefix(scheme: PairingDeeplinkScheme) -> &'static str {
+    match scheme {
+        PairingDeeplinkScheme::PolkadotApp => "polkadotapp://",
+        PairingDeeplinkScheme::PolkadotAppDev => "polkadotappdev://",
+    }
+}
+
+fn generate_statement_store_keypair() -> Result<([u8; 64], [u8; 32]), PairingBootstrapError> {
+    let mut seed = [0u8; 32];
+    getrandom::getrandom(&mut seed)
+        .map_err(|err| PairingBootstrapError::Random(err.to_string()))?;
+    let mini_secret = MiniSecretKey::from_bytes(&seed)
+        .map_err(|err| PairingBootstrapError::Random(err.to_string()))?;
+    let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+    Ok((keypair.secret.to_bytes(), keypair.public.to_bytes()))
+}
+
+fn generate_p256_keypair() -> Result<([u8; 32], [u8; 65]), PairingBootstrapError> {
+    for _ in 0..MAX_P256_SECRET_ATTEMPTS {
+        let mut candidate = [0u8; 32];
+        getrandom::getrandom(&mut candidate)
+            .map_err(|err| PairingBootstrapError::Random(err.to_string()))?;
+        let Ok(secret) = SecretKey::from_slice(&candidate) else {
+            continue;
+        };
+        let public = secret.public_key().to_encoded_point(false);
+        let public = public.as_bytes();
+        if public.len() != 65 {
+            return Err(PairingBootstrapError::InvalidP256Secret);
+        }
+        let mut encryption_public_key = [0u8; 65];
+        encryption_public_key.copy_from_slice(public);
+        let mut encryption_secret_key = [0u8; 32];
+        encryption_secret_key.copy_from_slice(secret.to_bytes().as_slice());
+        return Ok((encryption_secret_key, encryption_public_key));
+    }
+
+    Err(PairingBootstrapError::InvalidP256Secret)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SS_PUBLIC: [u8; 32] = [
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+        0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+        0x1e, 0x1f,
+    ];
+    const ENC_PUBLIC: [u8; 65] = [
+        0x04, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+        0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
+        0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
+        0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a,
+        0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+    ];
+
+    fn runtime_config() -> RuntimeConfig {
+        RuntimeConfig {
+            product_label: "myapp".to_string(),
+            product_id: "myapp.dot".to_string(),
+            site_id: "test".to_string(),
+            host_name: "Polkadot Web".to_string(),
+            host_icon: Some("https://example.invalid/dotli.png".to_string()),
+            host_version: Some("1.2.3".to_string()),
+            platform_type: Some("Firefox".to_string()),
+            platform_version: Some("192.32".to_string()),
+            people_chain_genesis_hash: [0; 32],
+            pairing_deeplink_scheme: PairingDeeplinkScheme::PolkadotApp,
+        }
+    }
+
+    #[test]
+    fn builds_v2_pairing_deeplink() {
+        let config = runtime_config();
+        let deeplink = build_pairing_deeplink(
+            PairingDeeplinkScheme::PolkadotApp,
+            SS_PUBLIC,
+            ENC_PUBLIC,
+            &config,
+        );
+
+        assert!(deeplink.starts_with("polkadotapp://pair?handshake=01"));
+        let encoded = hex::decode(deeplink.split("handshake=").nth(1).unwrap()).unwrap();
+        let decoded = <VersionedHandshakeProposal as Decode>::decode(&mut &encoded[..]).unwrap();
+        let VersionedHandshakeProposal::V2(proposal) = decoded else {
+            panic!("expected V2 proposal");
+        };
+        assert_eq!(proposal.device.statement_account_id, SS_PUBLIC);
+        assert_eq!(proposal.device.encryption_public_key, ENC_PUBLIC);
+        assert!(proposal.metadata.contains(&HandshakeMetadataEntry(
+            HandshakeMetadataKey::HostName,
+            "Polkadot Web".to_string()
+        )));
+    }
+
+    #[test]
+    fn builds_dev_pairing_deeplink() {
+        let deeplink = build_pairing_deeplink(
+            PairingDeeplinkScheme::PolkadotAppDev,
+            SS_PUBLIC,
+            ENC_PUBLIC,
+            &runtime_config(),
+        );
+
+        assert!(deeplink.starts_with("polkadotappdev://pair?handshake="));
+    }
+
+    #[test]
+    fn derives_bootstrap_topic_vector() {
+        assert_eq!(
+            hex::encode(bootstrap_topic(SS_PUBLIC, ENC_PUBLIC)),
+            "031c589833c39b1dfbe3c1304ced75fa7b0d841035db008e5b407bfadd2779a4"
+        );
+    }
+
+    #[test]
+    fn generated_bootstrap_uses_real_key_shapes() {
+        let config = runtime_config();
+
+        let bootstrap = create_pairing_bootstrap(&config).unwrap();
+
+        assert!(
+            bootstrap
+                .deeplink
+                .starts_with("polkadotapp://pair?handshake=")
+        );
+        assert_eq!(bootstrap.encryption_public_key[0], 0x04);
+        assert_eq!(
+            bootstrap.topic,
+            bootstrap_topic(
+                bootstrap.statement_store_public_key,
+                bootstrap.encryption_public_key
+            )
+        );
+    }
+
+    #[test]
+    fn decodes_app_handshake_answer() {
+        let answer = VersionedHandshakeResponse::V1 {
+            encrypted_message: vec![0xde, 0xad],
+            public_key: ENC_PUBLIC,
+        };
+
+        assert_eq!(decode_app_handshake_data(&answer.encode()).unwrap(), answer);
+    }
+
+    #[test]
+    fn rejects_app_handshake_trailing_bytes() {
+        let mut encoded = VersionedHandshakeResponse::V1 {
+            encrypted_message: vec![0xde, 0xad],
+            public_key: ENC_PUBLIC,
+        }
+        .encode();
+        encoded.push(0);
+
+        assert_eq!(
+            decode_app_handshake_data(&encoded).unwrap_err(),
+            "invalid app handshake data: trailing bytes"
+        );
+    }
+
+    #[test]
+    fn decrypts_handshake_answer() {
+        let core_secret = SecretKey::from_slice(&[1; 32]).unwrap();
+        let wallet_ephemeral_secret = SecretKey::from_slice(&[2; 32]).unwrap();
+        let wallet_ephemeral_public = wallet_ephemeral_secret.public_key().to_encoded_point(false);
+        let mut wallet_ephemeral_public_bytes = [0u8; 65];
+        wallet_ephemeral_public_bytes.copy_from_slice(wallet_ephemeral_public.as_bytes());
+
+        let shared_secret = diffie_hellman(
+            wallet_ephemeral_secret.to_nonzero_scalar(),
+            core_secret.public_key().as_affine(),
+        );
+        let hkdf = Hkdf::<Sha256>::new(None, shared_secret.raw_secret_bytes());
+        let mut aes_key = [0u8; 32];
+        hkdf.expand(&[], &mut aes_key).unwrap();
+
+        let sensitive = SsoHandshakeAnswerV1 {
+            shared_secret_derivation_key: ENC_PUBLIC,
+            root_user_account_id: [7; 32],
+            identity_account_id: [8; 32],
+        };
+        let nonce = [9u8; AES_GCM_NONCE_LEN];
+        let cipher = Aes256Gcm::new_from_slice(&aes_key).unwrap();
+        let mut encrypted = nonce.to_vec();
+        encrypted.extend(
+            cipher
+                .encrypt(Nonce::from_slice(&nonce), sensitive.encode().as_slice())
+                .unwrap(),
+        );
+
+        assert_eq!(
+            decrypt_handshake_answer(
+                core_secret.to_bytes().into(),
+                wallet_ephemeral_public_bytes,
+                &encrypted
+            )
+            .unwrap(),
+            sensitive
+        );
+    }
+
+    #[test]
+    fn rejects_short_handshake_ciphertext() {
+        assert_eq!(
+            decrypt_handshake_answer([1; 32], ENC_PUBLIC, &[0; AES_GCM_NONCE_LEN - 1]).unwrap_err(),
+            "encrypted SSO handshake answer is too short"
+        );
+    }
+
+    #[test]
+    fn establishes_session_ids_and_channels() {
+        let core_secret = SecretKey::from_slice(&[1; 32]).unwrap();
+        let core_public = core_secret.public_key().to_encoded_point(false);
+        let mut core_public_bytes = [0u8; 65];
+        core_public_bytes.copy_from_slice(core_public.as_bytes());
+        let bootstrap = PairingBootstrap {
+            deeplink: "polkadotapp://pair?handshake=00".to_string(),
+            topic: [0x11; 32],
+            statement_store_public_key: [0x22; 32],
+            statement_store_secret: [0x33; 64],
+            encryption_public_key: core_public_bytes,
+            encryption_secret_key: [1; 32],
+        };
+        let peer_secret = SecretKey::from_slice(&[2; 32]).unwrap();
+        let peer_public = peer_secret.public_key().to_encoded_point(false);
+        let peer_public: [u8; 65] = peer_public.as_bytes().try_into().unwrap();
+
+        let info = establish_sso_session_info(&bootstrap, [0x55; 32], peer_public).unwrap();
+
+        assert_eq!(info.ss_secret, [0x33; 64]);
+        assert_eq!(info.ss_public_key, [0x22; 32]);
+        assert_eq!(info.enc_secret, [1; 32]);
+        assert_eq!(info.peer_enc_pubkey, peer_public);
+        assert_eq!(info.identity_account_id, [0x55; 32]);
+        assert_ne!(info.session_id_own, info.session_id_peer);
+        assert_eq!(
+            info.request_channel,
+            keyed_hash(info.session_id_own, b"request")
+        );
+        assert_eq!(
+            info.response_channel,
+            keyed_hash(info.session_id_own, b"response")
+        );
+        assert_eq!(
+            info.peer_request_channel,
+            keyed_hash(info.session_id_peer, b"request")
+        );
+    }
+
+    #[test]
+    fn statement_data_codec_round_trips_request_and_response() {
+        let request = SsoStatementData::Request {
+            request_id: "req-1".to_string(),
+            data: vec![vec![0xde, 0xad], vec![0xbe, 0xef]],
+        };
+        let response = SsoStatementData::Response {
+            request_id: "req-1".to_string(),
+            response_code: 0,
+        };
+
+        assert_eq!(
+            SsoStatementData::decode(&mut &request.encode()[..]).unwrap(),
+            request
+        );
+        assert_eq!(
+            SsoStatementData::decode(&mut &response.encode()[..]).unwrap(),
+            response
+        );
+        assert_eq!(request.encode()[0], 0);
+        assert_eq!(response.encode()[0], 1);
+    }
+
+    #[test]
+    fn encrypts_and_decrypts_session_statement_data() {
+        let core_secret = SecretKey::from_slice(&[1; 32]).unwrap();
+        let core_public = core_secret.public_key().to_encoded_point(false);
+        let mut core_public_bytes = [0u8; 65];
+        core_public_bytes.copy_from_slice(core_public.as_bytes());
+        let bootstrap = PairingBootstrap {
+            deeplink: "polkadotapp://pair?handshake=00".to_string(),
+            topic: [0x11; 32],
+            statement_store_public_key: [0x22; 32],
+            statement_store_secret: [0x33; 64],
+            encryption_public_key: core_public_bytes,
+            encryption_secret_key: [1; 32],
+        };
+        let peer_secret = SecretKey::from_slice(&[2; 32]).unwrap();
+        let peer_public = peer_secret
+            .public_key()
+            .to_encoded_point(false)
+            .as_bytes()
+            .try_into()
+            .unwrap();
+        let session = establish_sso_session_info(&bootstrap, [0x55; 32], peer_public).unwrap();
+        let data = SsoStatementData::Request {
+            request_id: "req-1".to_string(),
+            data: vec![vec![0xde, 0xad]],
+        };
+        let nonce = [9u8; AES_GCM_NONCE_LEN];
+
+        let encrypted = encrypt_session_statement_data_with_nonce(&session, &data, nonce).unwrap();
+
+        assert_eq!(&encrypted[..AES_GCM_NONCE_LEN], nonce);
+        assert_eq!(
+            decrypt_session_statement_data(&session, &encrypted).unwrap(),
+            data
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/host_logic/statement_store.rs b/rust/crates/truapi-server/src/host_logic/statement_store.rs
new file mode 100644
index 00000000..f138f14e
--- /dev/null
+++ b/rust/crates/truapi-server/src/host_logic/statement_store.rs
@@ -0,0 +1,1038 @@
+//! People-chain statement-store JSON-RPC helpers.
+//!
+//! The core talks to the statement-store pallet through the host-provided
+//! `ChainProvider` JSON-RPC connection. These helpers keep dotli-compatible
+//! request shapes in one place.
+
+use parity_scale_codec::{Compact, Decode, Encode};
+use schnorrkel::{PublicKey, SecretKey, Signature};
+use serde_json::Value;
+use serde_json::json;
+use thiserror::Error;
+use truapi::v01;
+
+use crate::host_logic::session::SsoSessionInfo;
+
+/// Statement-store RPC method used to open a topic subscription.
+pub const SUBSCRIBE_STATEMENT_METHOD: &str = "statement_subscribeStatement";
+/// Statement-store RPC method used for subscription notifications.
+pub const STATEMENT_NOTIFICATION_METHOD: &str = "statement_statement";
+/// Statement-store RPC method used to close a topic subscription.
+pub const UNSUBSCRIBE_STATEMENT_METHOD: &str = "statement_unsubscribeStatement";
+/// Statement-store RPC method used to submit a signed statement.
+pub const SUBMIT_STATEMENT_METHOD: &str = "statement_submit";
+/// Maximum `matchAll` topic count accepted by the statement-store RPC.
+pub const MAX_MATCH_ALL_TOPICS: usize = 4;
+/// Maximum `matchAny` topic count accepted by the statement-store RPC.
+pub const MAX_MATCH_ANY_TOPICS: usize = 128;
+const SR25519_SIGNING_CONTEXT: &[u8] = b"substrate";
+
+/// Decoded `newStatements` subscription notification.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NewStatements {
+    /// Remote subscription id included in the notification.
+    pub remote_subscription_id: String,
+    /// SCALE-encoded signed statements carried by the notification.
+    pub statements: Vec<Vec<u8>>,
+    /// Optional server-side backlog count.
+    pub remaining: Option<u64>,
+}
+
+/// Error while parsing statement-store JSON-RPC or SCALE statement payloads.
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum StatementStoreParseError {
+    #[error("invalid json-rpc frame: {0}")]
+    InvalidJson(String),
+    #[error("invalid statement hex: {0}")]
+    InvalidStatementHex(String),
+    #[error("invalid statement scale: {0}")]
+    InvalidStatementScale(String),
+    #[error("malformed statement-store frame: {0}")]
+    Malformed(String),
+    #[error("invalid statement proof: {0}")]
+    InvalidStatementProof(String),
+}
+
+/// Topic filter flavor used by statement-store subscribe requests.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TopicFilterKind {
+    /// Require every listed topic to match.
+    MatchAll,
+    /// Accept any listed topic match.
+    MatchAny,
+}
+
+/// Verified statement payload plus the sr25519 signer recovered from proof.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VerifiedStatementData {
+    /// Raw statement data field.
+    pub data: Vec<u8>,
+    /// Sr25519 signer recovered from the proof.
+    pub signer: [u8; 32],
+    /// Raw `Expiry` field, if present: unix seconds in the upper 32 bits.
+    pub expiry: Option<u64>,
+}
+
+/// SCALE statement proof variants mirrored from the statement-store pallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum StatementProof {
+    #[codec(index = 0)]
+    Sr25519 {
+        signature: [u8; 64],
+        signer: [u8; 32],
+    },
+    #[codec(index = 1)]
+    Ed25519 {
+        signature: [u8; 64],
+        signer: [u8; 32],
+    },
+    #[codec(index = 2)]
+    Ecdsa {
+        signature: [u8; 65],
+        signer: [u8; 33],
+    },
+    #[codec(index = 3)]
+    OnChain {
+        who: [u8; 32],
+        block_hash: [u8; 32],
+        event: u64,
+    },
+}
+
+/// SCALE statement field variants mirrored from the statement-store pallet.
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum StatementField {
+    #[codec(index = 0)]
+    Proof(StatementProof),
+    #[codec(index = 1)]
+    DecryptionKey([u8; 32]),
+    #[codec(index = 2)]
+    Expiry(u64),
+    #[codec(index = 3)]
+    Channel([u8; 32]),
+    #[codec(index = 4)]
+    Topic1([u8; 32]),
+    #[codec(index = 5)]
+    Topic2([u8; 32]),
+    #[codec(index = 6)]
+    Topic3([u8; 32]),
+    #[codec(index = 7)]
+    Topic4([u8; 32]),
+    #[codec(index = 8)]
+    Data(Vec<u8>),
+}
+
+/// Build a statement-store subscription request that requires all topics.
+pub fn subscribe_match_all_request(id: &str, topics: &[[u8; 32]]) -> String {
+    subscribe_request(id, TopicFilterKind::MatchAll, topics)
+}
+
+/// Build a statement-store subscription request that accepts any topic.
+pub fn subscribe_match_any_request(id: &str, topics: &[[u8; 32]]) -> String {
+    subscribe_request(id, TopicFilterKind::MatchAny, topics)
+}
+
+/// Build a statement-store subscription JSON-RPC request.
+pub fn subscribe_request(id: &str, kind: TopicFilterKind, topics: &[[u8; 32]]) -> String {
+    let topics = topics.iter().map(hex_topic).collect::<Vec<_>>();
+    match kind {
+        TopicFilterKind::MatchAll => json!({
+            "jsonrpc": "2.0",
+            "id": id,
+            "method": SUBSCRIBE_STATEMENT_METHOD,
+            "params": [{ "matchAll": topics }],
+        }),
+        TopicFilterKind::MatchAny => json!({
+            "jsonrpc": "2.0",
+            "id": id,
+            "method": SUBSCRIBE_STATEMENT_METHOD,
+            "params": [{ "matchAny": topics }],
+        }),
+    }
+    .to_string()
+}
+
+/// Build a statement-store unsubscribe JSON-RPC request.
+pub fn unsubscribe_request(id: &str, remote_subscription_id: &str) -> String {
+    json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "method": UNSUBSCRIBE_STATEMENT_METHOD,
+        "params": [remote_subscription_id],
+    })
+    .to_string()
+}
+
+/// Build a statement-store submit JSON-RPC request for a signed statement.
+pub fn submit_statement_request(id: &str, statement: &[u8]) -> String {
+    json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "method": SUBMIT_STATEMENT_METHOD,
+        "params": [format!("0x{}", hex::encode(statement))],
+    })
+    .to_string()
+}
+
+/// Parse the subscription acknowledgement for `expected_id`.
+pub fn parse_subscribe_ack(
+    frame: &str,
+    expected_id: &str,
+) -> Result<Option<String>, StatementStoreParseError> {
+    let value = parse_frame(frame)?;
+    if value.get("id").and_then(Value::as_str) != Some(expected_id) {
+        return Ok(None);
+    }
+    if is_json_rpc_request_echo(&value) {
+        return Ok(None);
+    }
+    if let Some(error) = value.get("error") {
+        return Err(StatementStoreParseError::Malformed(
+            error
+                .get("message")
+                .and_then(Value::as_str)
+                .unwrap_or("statement-store subscribe failed")
+                .to_string(),
+        ));
+    }
+    let Some(result) = value.get("result").and_then(Value::as_str) else {
+        return Err(StatementStoreParseError::Malformed(
+            "missing subscribe result".to_string(),
+        ));
+    };
+    Ok(Some(result.to_string()))
+}
+
+/// Parse the submit acknowledgement for `expected_id`.
+pub fn parse_submit_ack(
+    frame: &str,
+    expected_id: &str,
+) -> Result<Option<()>, StatementStoreParseError> {
+    let value = parse_frame(frame)?;
+    if value.get("id").and_then(Value::as_str) != Some(expected_id) {
+        return Ok(None);
+    }
+    if is_json_rpc_request_echo(&value) {
+        return Ok(None);
+    }
+    if let Some(error) = value.get("error") {
+        return Err(StatementStoreParseError::Malformed(
+            error
+                .get("message")
+                .and_then(Value::as_str)
+                .unwrap_or("statement-store submit failed")
+                .to_string(),
+        ));
+    }
+    if value.get("result").is_none() {
+        return Err(StatementStoreParseError::Malformed(
+            "missing submit result".to_string(),
+        ));
+    }
+    Ok(Some(()))
+}
+
+/// Parse a statement-store `newStatements` notification.
+pub fn parse_new_statements(
+    frame: &str,
+) -> Result<Option<NewStatements>, StatementStoreParseError> {
+    let value = parse_frame(frame)?;
+    let method = value.get("method").and_then(Value::as_str);
+    if method != Some(SUBSCRIBE_STATEMENT_METHOD) && method != Some(STATEMENT_NOTIFICATION_METHOD) {
+        return Ok(None);
+    }
+    let params = value
+        .get("params")
+        .ok_or_else(|| StatementStoreParseError::Malformed("missing params".to_string()))?;
+    let remote_subscription_id = params
+        .get("subscription")
+        .and_then(Value::as_str)
+        .ok_or_else(|| StatementStoreParseError::Malformed("missing subscription id".to_string()))?
+        .to_string();
+    let result = params
+        .get("result")
+        .ok_or_else(|| StatementStoreParseError::Malformed("missing result".to_string()))?;
+    if result.get("event").and_then(Value::as_str) != Some("newStatements") {
+        return Ok(None);
+    }
+    let data = result
+        .get("data")
+        .ok_or_else(|| StatementStoreParseError::Malformed("missing data".to_string()))?;
+    let statement_values = data
+        .get("statements")
+        .and_then(Value::as_array)
+        .ok_or_else(|| StatementStoreParseError::Malformed("missing statements".to_string()))?;
+    let statements = statement_values
+        .iter()
+        .map(|value| {
+            let Some(hex) = value.as_str() else {
+                return Err(StatementStoreParseError::Malformed(
+                    "statement is not a hex string".to_string(),
+                ));
+            };
+            decode_hex(hex)
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let remaining = match data.get("remaining") {
+        Some(value) => Some(value.as_u64().ok_or_else(|| {
+            StatementStoreParseError::Malformed("remaining is not an integer".to_string())
+        })?),
+        None => None,
+    };
+
+    Ok(Some(NewStatements {
+        remote_subscription_id,
+        statements,
+        remaining,
+    }))
+}
+
+/// Extract the raw `Data` field from a SCALE-encoded statement.
+pub fn decode_statement_data(statement: &[u8]) -> Result<Vec<u8>, StatementStoreParseError> {
+    statement_data_from_fields(decode_statement_fields(statement)?)
+}
+
+/// Verify statement proof and extract signer, expiry, and raw `Data` field.
+pub fn decode_verified_statement_data(
+    statement: &[u8],
+    expected_signer: Option<[u8; 32]>,
+) -> Result<VerifiedStatementData, StatementStoreParseError> {
+    let fields = decode_statement_fields(statement)?;
+    let signer = verify_statement_proof(&fields, expected_signer)?;
+    let expiry = fields.iter().find_map(|field| match field {
+        StatementField::Expiry(value) => Some(*value),
+        _ => None,
+    });
+    let data = statement_data_from_fields(fields)?;
+    Ok(VerifiedStatementData {
+        data,
+        signer,
+        expiry,
+    })
+}
+
+/// Whether a statement `Expiry` field (unix seconds in the upper 32 bits) is
+/// in the past relative to `now_unix_secs`.
+pub fn statement_expiry_elapsed(expiry: u64, now_unix_secs: u64) -> bool {
+    (expiry >> 32) < now_unix_secs
+}
+
+/// Current unix time in seconds, used to stamp outgoing statement expiries
+/// and to gate inbound statement freshness. Trusts the local clock on both
+/// native and wasm targets.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn current_unix_secs() -> u64 {
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+/// Current unix time in seconds on wasm32, sourced from the JS clock.
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn current_unix_secs() -> u64 {
+    (js_sys::Date::now() / 1000.0) as u64
+}
+
+/// Decode a SCALE signed statement into the public v01 statement shape.
+pub fn decode_signed_statement(
+    statement: &[u8],
+) -> Result<v01::SignedStatement, StatementStoreParseError> {
+    signed_statement_from_fields(decode_statement_fields(statement)?)
+}
+
+/// Build a signed statement on the active SSO request channel.
+pub fn build_signed_session_request_statement(
+    session: &SsoSessionInfo,
+    encrypted_data: Vec<u8>,
+    expiry: u64,
+) -> Result<Vec<u8>, String> {
+    build_signed_statement(
+        session,
+        session.request_channel,
+        session.session_id_own,
+        encrypted_data,
+        expiry,
+    )
+}
+
+/// Build a signed statement for an arbitrary channel/topic pair.
+pub fn build_signed_statement(
+    session: &SsoSessionInfo,
+    channel: [u8; 32],
+    topic1: [u8; 32],
+    data: Vec<u8>,
+    expiry: u64,
+) -> Result<Vec<u8>, String> {
+    let fields = vec![
+        StatementField::Expiry(expiry),
+        StatementField::Channel(channel),
+        StatementField::Topic1(topic1),
+        StatementField::Data(data),
+    ];
+    sign_statement_fields(session.ss_secret, session.ss_public_key, fields)
+        .map(|fields| fields.encode())
+}
+
+/// Sort fields, insert an sr25519 proof, and return signed fields.
+pub fn sign_statement_fields(
+    ss_secret: [u8; 64],
+    expected_public_key: [u8; 32],
+    mut fields: Vec<StatementField>,
+) -> Result<Vec<StatementField>, String> {
+    if fields
+        .iter()
+        .any(|field| matches!(field, StatementField::Proof(_)))
+    {
+        return Err("statement is already signed".to_string());
+    }
+    fields.sort_by_key(statement_field_sort_index);
+
+    let secret =
+        SecretKey::from_bytes(&ss_secret).map_err(|err| format!("invalid ss_secret: {err}"))?;
+    let public = secret.to_public();
+    if public.to_bytes() != expected_public_key {
+        return Err("ss_secret does not match session statement public key".to_string());
+    }
+
+    let signing_payload = statement_signing_payload(&fields)?;
+    let signature = secret
+        .sign_simple(SR25519_SIGNING_CONTEXT, &signing_payload, &public)
+        .to_bytes();
+
+    let mut signed = Vec::with_capacity(fields.len() + 1);
+    signed.push(StatementField::Proof(StatementProof::Sr25519 {
+        signature,
+        signer: expected_public_key,
+    }));
+    signed.extend(fields);
+    Ok(signed)
+}
+
+/// Build the statement signing payload from sorted fields.
+pub fn statement_signing_payload(fields: &[StatementField]) -> Result<Vec<u8>, String> {
+    let encoded = fields.to_vec().encode();
+    let mut input = encoded.as_slice();
+    let _: Compact<u32> =
+        Decode::decode(&mut input).map_err(|err| format!("invalid statement vector: {err}"))?;
+    let compact_len = encoded.len() - input.len();
+    Ok(encoded[compact_len..].to_vec())
+}
+
+fn decode_statement_fields(
+    statement: &[u8],
+) -> Result<Vec<StatementField>, StatementStoreParseError> {
+    let mut input = statement;
+    let fields: Vec<StatementField> = Decode::decode(&mut input)
+        .map_err(|err| StatementStoreParseError::InvalidStatementScale(err.to_string()))?;
+    if !input.is_empty() {
+        return Err(StatementStoreParseError::Malformed(
+            "statement has trailing bytes".to_string(),
+        ));
+    }
+    Ok(fields)
+}
+
+fn statement_data_from_fields(
+    fields: Vec<StatementField>,
+) -> Result<Vec<u8>, StatementStoreParseError> {
+    fields
+        .into_iter()
+        .find_map(|field| match field {
+            StatementField::Data(value) => Some(value),
+            _ => None,
+        })
+        .ok_or_else(|| StatementStoreParseError::Malformed("statement has no data".to_string()))
+}
+
+fn verify_statement_proof(
+    fields: &[StatementField],
+    expected_signer: Option<[u8; 32]>,
+) -> Result<[u8; 32], StatementStoreParseError> {
+    let mut proof = None;
+    let mut unsigned_fields = Vec::with_capacity(fields.len().saturating_sub(1));
+    for field in fields {
+        match field {
+            StatementField::Proof(StatementProof::Sr25519 { signature, signer }) => {
+                if proof.replace((*signature, *signer)).is_some() {
+                    return Err(StatementStoreParseError::InvalidStatementProof(
+                        "statement has duplicate proof".to_string(),
+                    ));
+                }
+            }
+            StatementField::Proof(_) => {
+                return Err(StatementStoreParseError::InvalidStatementProof(
+                    "statement proof is not sr25519".to_string(),
+                ));
+            }
+            field => unsigned_fields.push(field.clone()),
+        }
+    }
+    let (signature, signer) = proof.ok_or_else(|| {
+        StatementStoreParseError::InvalidStatementProof("statement has no proof".to_string())
+    })?;
+    if let Some(expected) = expected_signer
+        && signer != expected
+    {
+        return Err(StatementStoreParseError::InvalidStatementProof(
+            "statement proof signer does not match expected peer".to_string(),
+        ));
+    }
+
+    unsigned_fields.sort_by_key(statement_field_sort_index);
+    let payload =
+        statement_signing_payload(&unsigned_fields).map_err(StatementStoreParseError::Malformed)?;
+    let public = PublicKey::from_bytes(&signer).map_err(|err| {
+        StatementStoreParseError::InvalidStatementProof(format!("invalid sr25519 signer: {err}"))
+    })?;
+    let signature = Signature::from_bytes(&signature).map_err(|err| {
+        StatementStoreParseError::InvalidStatementProof(format!("invalid sr25519 signature: {err}"))
+    })?;
+    public
+        .verify_simple(SR25519_SIGNING_CONTEXT, &payload, &signature)
+        .map_err(|err| {
+            StatementStoreParseError::InvalidStatementProof(format!(
+                "sr25519 signature verification failed: {err}"
+            ))
+        })?;
+    Ok(signer)
+}
+
+/// Convert a public v01 statement into SCALE statement fields.
+pub fn statement_fields_from_v01(statement: v01::Statement) -> Result<Vec<StatementField>, String> {
+    let mut fields = Vec::new();
+    if let Some(proof) = statement.proof {
+        fields.push(StatementField::Proof(statement_proof_from_v01(proof)));
+    }
+    if let Some(decryption_key) = statement.decryption_key {
+        fields.push(StatementField::DecryptionKey(decryption_key));
+    }
+    if let Some(expiry) = statement.expiry {
+        fields.push(StatementField::Expiry(expiry));
+    }
+    if let Some(channel) = statement.channel {
+        fields.push(StatementField::Channel(channel));
+    }
+    push_statement_topics(&mut fields, statement.topics)?;
+    if let Some(data) = statement.data {
+        fields.push(StatementField::Data(data));
+    }
+    Ok(fields)
+}
+
+/// Convert a public v01 signed statement into SCALE bytes.
+pub fn signed_statement_to_scale(statement: v01::SignedStatement) -> Result<Vec<u8>, String> {
+    Ok(signed_statement_fields(statement)?.encode())
+}
+
+fn signed_statement_fields(statement: v01::SignedStatement) -> Result<Vec<StatementField>, String> {
+    let mut fields = vec![StatementField::Proof(statement_proof_from_v01(
+        statement.proof,
+    ))];
+    if let Some(decryption_key) = statement.decryption_key {
+        fields.push(StatementField::DecryptionKey(decryption_key));
+    }
+    if let Some(expiry) = statement.expiry {
+        fields.push(StatementField::Expiry(expiry));
+    }
+    if let Some(channel) = statement.channel {
+        fields.push(StatementField::Channel(channel));
+    }
+    push_statement_topics(&mut fields, statement.topics)?;
+    if let Some(data) = statement.data {
+        fields.push(StatementField::Data(data));
+    }
+    fields.sort_by_key(statement_field_sort_index);
+    Ok(fields)
+}
+
+fn signed_statement_from_fields(
+    fields: Vec<StatementField>,
+) -> Result<v01::SignedStatement, StatementStoreParseError> {
+    let mut proof = None;
+    let mut decryption_key = None;
+    let mut expiry = None;
+    let mut channel = None;
+    let mut topics = Vec::new();
+    let mut data = None;
+
+    for field in fields {
+        match field {
+            StatementField::Proof(value) => {
+                if proof.replace(statement_proof_to_v01(value)).is_some() {
+                    return Err(StatementStoreParseError::Malformed(
+                        "statement has duplicate proof".to_string(),
+                    ));
+                }
+            }
+            StatementField::DecryptionKey(value) => {
+                if decryption_key.replace(value).is_some() {
+                    return Err(StatementStoreParseError::Malformed(
+                        "statement has duplicate decryption key".to_string(),
+                    ));
+                }
+            }
+            StatementField::Expiry(value) => {
+                if expiry.replace(value).is_some() {
+                    return Err(StatementStoreParseError::Malformed(
+                        "statement has duplicate expiry".to_string(),
+                    ));
+                }
+            }
+            StatementField::Channel(value) => {
+                if channel.replace(value).is_some() {
+                    return Err(StatementStoreParseError::Malformed(
+                        "statement has duplicate channel".to_string(),
+                    ));
+                }
+            }
+            StatementField::Topic1(value)
+            | StatementField::Topic2(value)
+            | StatementField::Topic3(value)
+            | StatementField::Topic4(value) => topics.push(value),
+            StatementField::Data(value) => {
+                if data.replace(value).is_some() {
+                    return Err(StatementStoreParseError::Malformed(
+                        "statement has duplicate data".to_string(),
+                    ));
+                }
+            }
+        }
+    }
+
+    let proof = proof
+        .ok_or_else(|| StatementStoreParseError::Malformed("statement has no proof".to_string()))?;
+    Ok(v01::SignedStatement {
+        proof,
+        decryption_key,
+        expiry,
+        channel,
+        topics,
+        data,
+    })
+}
+
+/// Convert an internal proof into the public v01 proof shape.
+pub fn statement_proof_to_v01(proof: StatementProof) -> v01::StatementProof {
+    match proof {
+        StatementProof::Sr25519 { signature, signer } => {
+            v01::StatementProof::Sr25519 { signature, signer }
+        }
+        StatementProof::Ed25519 { signature, signer } => {
+            v01::StatementProof::Ed25519 { signature, signer }
+        }
+        StatementProof::Ecdsa { signature, signer } => {
+            v01::StatementProof::Ecdsa { signature, signer }
+        }
+        StatementProof::OnChain {
+            who,
+            block_hash,
+            event,
+        } => v01::StatementProof::OnChain {
+            who,
+            block_hash,
+            event,
+        },
+    }
+}
+
+fn statement_proof_from_v01(proof: v01::StatementProof) -> StatementProof {
+    match proof {
+        v01::StatementProof::Sr25519 { signature, signer } => {
+            StatementProof::Sr25519 { signature, signer }
+        }
+        v01::StatementProof::Ed25519 { signature, signer } => {
+            StatementProof::Ed25519 { signature, signer }
+        }
+        v01::StatementProof::Ecdsa { signature, signer } => {
+            StatementProof::Ecdsa { signature, signer }
+        }
+        v01::StatementProof::OnChain {
+            who,
+            block_hash,
+            event,
+        } => StatementProof::OnChain {
+            who,
+            block_hash,
+            event,
+        },
+    }
+}
+
+fn push_statement_topics(
+    fields: &mut Vec<StatementField>,
+    topics: Vec<[u8; 32]>,
+) -> Result<(), String> {
+    if topics.len() > 4 {
+        return Err(format!(
+            "statement has {} topics, maximum is 4",
+            topics.len()
+        ));
+    }
+    for (index, topic) in topics.into_iter().enumerate() {
+        fields.push(match index {
+            0 => StatementField::Topic1(topic),
+            1 => StatementField::Topic2(topic),
+            2 => StatementField::Topic3(topic),
+            3 => StatementField::Topic4(topic),
+            _ => unreachable!("topic count checked above"),
+        });
+    }
+    Ok(())
+}
+
+fn statement_field_sort_index(field: &StatementField) -> u8 {
+    match field {
+        StatementField::Proof(_) => 0,
+        StatementField::DecryptionKey(_) => 1,
+        StatementField::Expiry(_) => 2,
+        StatementField::Channel(_) => 3,
+        StatementField::Topic1(_) => 4,
+        StatementField::Topic2(_) => 5,
+        StatementField::Topic3(_) => 6,
+        StatementField::Topic4(_) => 7,
+        StatementField::Data(_) => 8,
+    }
+}
+
+fn hex_topic(topic: &[u8; 32]) -> String {
+    format!("0x{}", hex::encode(topic))
+}
+
+fn parse_frame(frame: &str) -> Result<Value, StatementStoreParseError> {
+    serde_json::from_str(frame)
+        .map_err(|error| StatementStoreParseError::InvalidJson(error.to_string()))
+}
+
+fn is_json_rpc_request_echo(value: &Value) -> bool {
+    value.get("method").and_then(Value::as_str).is_some()
+        && value.get("params").is_some()
+        && value.get("result").is_none()
+        && value.get("error").is_none()
+}
+
+fn decode_hex(value: &str) -> Result<Vec<u8>, StatementStoreParseError> {
+    hex::decode(value.strip_prefix("0x").unwrap_or(value))
+        .map_err(|error| StatementStoreParseError::InvalidStatementHex(error.to_string()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::host_logic::session::SsoSessionInfo;
+    use schnorrkel::{ExpansionMode, MiniSecretKey, PublicKey, Signature};
+    use serde_json::Value;
+
+    fn test_session() -> SsoSessionInfo {
+        let mini_secret = MiniSecretKey::from_bytes(&[7; 32]).unwrap();
+        let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+        SsoSessionInfo {
+            ss_secret: keypair.secret.to_bytes(),
+            ss_public_key: keypair.public.to_bytes(),
+            enc_secret: [1; 32],
+            peer_enc_pubkey: [2; 65],
+            identity_account_id: [3; 32],
+            session_id_own: [4; 32],
+            session_id_peer: [5; 32],
+            request_channel: [6; 32],
+            response_channel: [7; 32],
+            peer_request_channel: [8; 32],
+        }
+    }
+
+    #[test]
+    fn builds_match_all_subscribe_request_like_dotli_sdk() {
+        let topic = [7u8; 32];
+        let request = subscribe_match_all_request("truapi:ss:1", &[topic]);
+        let value: Value = serde_json::from_str(&request).unwrap();
+
+        assert_eq!(value["jsonrpc"], "2.0");
+        assert_eq!(value["id"], "truapi:ss:1");
+        assert_eq!(value["method"], SUBSCRIBE_STATEMENT_METHOD);
+        assert_eq!(
+            value["params"][0]["matchAll"][0],
+            "0x0707070707070707070707070707070707070707070707070707070707070707"
+        );
+    }
+
+    #[test]
+    fn builds_match_any_subscribe_request_like_dotli_sdk() {
+        let topic = [8u8; 32];
+        let request = subscribe_match_any_request("truapi:ss:any", &[topic]);
+        let value: Value = serde_json::from_str(&request).unwrap();
+
+        assert_eq!(value["method"], SUBSCRIBE_STATEMENT_METHOD);
+        assert_eq!(
+            value["params"][0]["matchAny"][0],
+            "0x0808080808080808080808080808080808080808080808080808080808080808"
+        );
+    }
+
+    #[test]
+    fn builds_unsubscribe_request_with_remote_id() {
+        let request = unsubscribe_request("truapi:ss:2", "remote-sub");
+        let value: Value = serde_json::from_str(&request).unwrap();
+
+        assert_eq!(value["method"], UNSUBSCRIBE_STATEMENT_METHOD);
+        assert_eq!(value["params"][0], "remote-sub");
+    }
+
+    #[test]
+    fn builds_submit_request_like_dotli_sdk() {
+        let request = submit_statement_request("truapi:ss:3", &[0xde, 0xad, 0xbe, 0xef]);
+        let value: Value = serde_json::from_str(&request).unwrap();
+
+        assert_eq!(value["method"], SUBMIT_STATEMENT_METHOD);
+        assert_eq!(value["params"][0], "0xdeadbeef");
+    }
+
+    #[test]
+    fn parses_subscribe_ack_for_expected_request_id() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:ss:1","result":"remote-sub"}"#;
+
+        assert_eq!(
+            parse_subscribe_ack(frame, "truapi:ss:1").unwrap(),
+            Some("remote-sub".to_string())
+        );
+        assert_eq!(parse_subscribe_ack(frame, "other").unwrap(), None);
+    }
+
+    #[test]
+    fn ignores_echoed_subscribe_request_for_expected_request_id() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:ss:1","method":"statement_subscribeStatement","params":[{"matchAll":["0x0707070707070707070707070707070707070707070707070707070707070707"]}]}"#;
+
+        assert_eq!(parse_subscribe_ack(frame, "truapi:ss:1").unwrap(), None);
+    }
+
+    #[test]
+    fn parses_submit_ack_for_expected_request_id() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:ss:submit","result":"0xabc"}"#;
+
+        assert_eq!(
+            parse_submit_ack(frame, "truapi:ss:submit").unwrap(),
+            Some(())
+        );
+        assert_eq!(parse_submit_ack(frame, "other").unwrap(), None);
+    }
+
+    #[test]
+    fn ignores_echoed_submit_request_for_expected_request_id() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:ss:submit","method":"statement_submit","params":["0xdeadbeef"]}"#;
+
+        assert_eq!(parse_submit_ack(frame, "truapi:ss:submit").unwrap(), None);
+    }
+
+    #[test]
+    fn maps_subscribe_error_to_malformed_frame() {
+        let frame =
+            r#"{"jsonrpc":"2.0","id":"truapi:ss:1","error":{"code":-32000,"message":"no peers"}}"#;
+
+        assert_eq!(
+            parse_subscribe_ack(frame, "truapi:ss:1").unwrap_err(),
+            StatementStoreParseError::Malformed("no peers".to_string())
+        );
+    }
+
+    #[test]
+    fn parses_dotli_sdk_new_statements_notification() {
+        let frame = r#"{"jsonrpc":"2.0","method":"statement_statement","params":{"subscription":"remote-sub","result":{"event":"newStatements","data":{"statements":["0xdeadbeef","0xcafe"],"remaining":0}}}}"#;
+
+        assert_eq!(
+            parse_new_statements(frame).unwrap(),
+            Some(NewStatements {
+                remote_subscription_id: "remote-sub".to_string(),
+                statements: vec![vec![0xde, 0xad, 0xbe, 0xef], vec![0xca, 0xfe]],
+                remaining: Some(0),
+            })
+        );
+    }
+
+    #[test]
+    fn ignores_non_statement_notifications_and_non_new_statement_events() {
+        assert_eq!(
+            parse_new_statements(
+                r#"{"jsonrpc":"2.0","method":"chainHead_v1_followEvent","params":{}}"#
+            )
+            .unwrap(),
+            None
+        );
+        assert_eq!(
+            parse_new_statements(
+                r#"{"jsonrpc":"2.0","method":"statement_subscribeStatement","params":{"subscription":"remote-sub","result":{"event":"other","data":{}}}}"#
+            )
+            .unwrap(),
+            None
+        );
+    }
+
+    #[test]
+    fn decodes_statement_data_field() {
+        let statement = vec![
+            StatementField::Proof(StatementProof::Sr25519 {
+                signature: [1; 64],
+                signer: [2; 32],
+            }),
+            StatementField::Expiry(42),
+            StatementField::Channel([3; 32]),
+            StatementField::Topic1([4; 32]),
+            StatementField::Data(vec![0xde, 0xad, 0xbe, 0xef]),
+        ]
+        .encode();
+
+        assert_eq!(
+            decode_statement_data(&statement).unwrap(),
+            vec![0xde, 0xad, 0xbe, 0xef]
+        );
+    }
+
+    #[test]
+    fn signed_statement_scale_round_trips_public_shape() {
+        let signed = v01::SignedStatement {
+            proof: v01::StatementProof::Sr25519 {
+                signature: [9; 64],
+                signer: [8; 32],
+            },
+            decryption_key: Some([7; 32]),
+            expiry: Some(99),
+            channel: Some([6; 32]),
+            topics: vec![[1; 32], [2; 32]],
+            data: Some(vec![3, 4, 5]),
+        };
+
+        let encoded = signed_statement_to_scale(signed.clone()).unwrap();
+
+        assert_eq!(decode_signed_statement(&encoded).unwrap(), signed);
+    }
+
+    #[test]
+    fn signing_payload_strips_scale_vec_compact_len() {
+        let fields = vec![
+            StatementField::Expiry(42),
+            StatementField::Channel([3; 32]),
+            StatementField::Topic1([4; 32]),
+            StatementField::Data(vec![0xde, 0xad, 0xbe, 0xef]),
+        ];
+        let encoded = fields.encode();
+
+        assert_eq!(encoded[0], 16);
+        assert_eq!(statement_signing_payload(&fields).unwrap(), encoded[1..]);
+    }
+
+    #[test]
+    fn builds_signed_session_request_statement() {
+        let session = test_session();
+
+        let statement =
+            build_signed_session_request_statement(&session, vec![0xde, 0xad], 42).unwrap();
+        let mut input = statement.as_slice();
+        let fields = Vec::<StatementField>::decode(&mut input).unwrap();
+
+        assert!(input.is_empty());
+        assert_eq!(fields.len(), 5);
+        let StatementField::Proof(StatementProof::Sr25519 { signature, signer }) = fields[0] else {
+            panic!("expected sr25519 proof");
+        };
+        assert_eq!(signer, session.ss_public_key);
+        assert_eq!(fields[1], StatementField::Expiry(42));
+        assert_eq!(fields[2], StatementField::Channel(session.request_channel));
+        assert_eq!(fields[3], StatementField::Topic1(session.session_id_own));
+        assert_eq!(fields[4], StatementField::Data(vec![0xde, 0xad]));
+
+        let payload = statement_signing_payload(&fields[1..]).unwrap();
+        let public = PublicKey::from_bytes(&signer).unwrap();
+        let signature = Signature::from_bytes(&signature).unwrap();
+        public
+            .verify_simple(SR25519_SIGNING_CONTEXT, &payload, &signature)
+            .unwrap();
+    }
+
+    #[test]
+    fn verified_statement_data_accepts_valid_sr25519_proof() {
+        let session = test_session();
+        let statement =
+            build_signed_session_request_statement(&session, vec![0xde, 0xad], 42).unwrap();
+
+        let verified =
+            decode_verified_statement_data(&statement, Some(session.ss_public_key)).unwrap();
+
+        assert_eq!(
+            verified,
+            VerifiedStatementData {
+                data: vec![0xde, 0xad],
+                signer: session.ss_public_key,
+                expiry: Some(42),
+            }
+        );
+    }
+
+    #[test]
+    fn verified_statement_data_rejects_tampered_signature() {
+        let session = test_session();
+        let statement =
+            build_signed_session_request_statement(&session, vec![0xde, 0xad], 42).unwrap();
+        let mut fields = Vec::<StatementField>::decode(&mut statement.as_slice()).unwrap();
+        let StatementField::Proof(StatementProof::Sr25519 { signature, .. }) = &mut fields[0]
+        else {
+            panic!("expected sr25519 proof");
+        };
+        signature[0] ^= 0xff;
+
+        let err = decode_verified_statement_data(&fields.encode(), Some(session.ss_public_key))
+            .unwrap_err();
+
+        assert!(
+            matches!(err, StatementStoreParseError::InvalidStatementProof(reason) if reason.contains("signature verification failed"))
+        );
+    }
+
+    #[test]
+    fn verified_statement_data_rejects_wrong_expected_signer() {
+        let session = test_session();
+        let statement =
+            build_signed_session_request_statement(&session, vec![0xde, 0xad], 42).unwrap();
+
+        assert_eq!(
+            decode_verified_statement_data(&statement, Some([0xaa; 32])).unwrap_err(),
+            StatementStoreParseError::InvalidStatementProof(
+                "statement proof signer does not match expected peer".to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn signing_rejects_mismatched_session_key_material() {
+        let mut session = test_session();
+        session.ss_public_key = [0xff; 32];
+
+        assert_eq!(
+            build_signed_session_request_statement(&session, vec![0xde], 42).unwrap_err(),
+            "ss_secret does not match session statement public key"
+        );
+    }
+
+    #[test]
+    fn signing_rejects_already_signed_statements() {
+        let session = test_session();
+        let fields = vec![StatementField::Proof(StatementProof::Sr25519 {
+            signature: [1; 64],
+            signer: session.ss_public_key,
+        })];
+
+        assert_eq!(
+            sign_statement_fields(session.ss_secret, session.ss_public_key, fields).unwrap_err(),
+            "statement is already signed"
+        );
+    }
+
+    #[test]
+    fn rejects_statement_without_data_field() {
+        let statement = vec![StatementField::Expiry(42)].encode();
+
+        assert_eq!(
+            decode_statement_data(&statement).unwrap_err(),
+            StatementStoreParseError::Malformed("statement has no data".to_string())
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/lib.rs b/rust/crates/truapi-server/src/lib.rs
new file mode 100644
index 00000000..9eec2eef
--- /dev/null
+++ b/rust/crates/truapi-server/src/lib.rs
@@ -0,0 +1,58 @@
+//! TrUAPI server runtime: dispatcher, frames, SCALE encoding, stream management.
+//!
+//! The platform path (`TrUApiCore::from_platform_with_config`) wraps a
+//! [`truapi_platform::Platform`] in a `PlatformRuntimeHost` that implements
+//! every `truapi::api::*` trait by delegating to platform callbacks.
+//!
+//! Host-facing bridges:
+//! - [`ws_bridge`] (feature `ws-bridge`): localhost WebSocket bridge for
+//!   native WebView hosts (Android/iOS).
+//! - [`native`]: UniFFI surface exposing `NativeTrUApiCore` + `HostCallbacks`.
+//! - [`wasm`] (wasm32 only): wasm-bindgen surface exposing `WasmTrUApiCore`.
+
+#![forbid(unsafe_code)]
+
+pub mod chain_runtime;
+pub mod core;
+pub mod dispatcher;
+pub mod frame;
+pub mod host_logic;
+pub mod logging;
+pub mod runtime;
+pub mod subscription;
+pub mod transport;
+
+#[cfg(test)]
+pub(crate) mod test_support;
+
+pub mod generated;
+
+#[cfg(feature = "smoldot")]
+pub mod smoldot_provider;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "ws-bridge"))]
+pub mod ws_bridge;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod native;
+
+#[cfg(target_arch = "wasm32")]
+pub mod wasm;
+
+pub use crate::core::TrUApiCore;
+pub use dispatcher::*;
+pub use frame::*;
+pub use runtime::PlatformRuntimeHost;
+pub use subscription::*;
+pub use transport::*;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "ws-bridge"))]
+pub use ws_bridge::*;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use native::*;
+
+#[cfg(target_arch = "wasm32")]
+pub use wasm::*;
+
+uniffi::setup_scaffolding!();
diff --git a/rust/crates/truapi-server/src/logging.rs b/rust/crates/truapi-server/src/logging.rs
new file mode 100644
index 00000000..1331b524
--- /dev/null
+++ b/rust/crates/truapi-server/src/logging.rs
@@ -0,0 +1,127 @@
+//! Level-controlled `tracing` output, routed to the host console.
+//!
+//! Events emitted via the `tracing` macros (`info!`, `debug!`, …) and
+//! `#[instrument]` spans flow through a single subscriber installed once by
+//! [`init`]. A reloadable [`LevelFilter`] decides what reaches the console, so
+//! the verbosity is tunable at runtime via [`set_level`] (exposed to JS as
+//! `setLogLevel`). Disabled by default ([`LevelFilter::OFF`]).
+//!
+//! On wasm each level maps to the matching `console` method
+//! (`error`/`warn`/`info`/`debug`); on native everything goes to stderr.
+//! In Chrome, `debug`/`trace` land on `console.debug`, which the DevTools
+//! console hides unless its level dropdown includes "Verbose".
+//!
+//! Output is plaintext, so never log secret material (key bytes, session
+//! tokens, signatures).
+
+use std::fmt::{self, Write as _};
+use std::sync::OnceLock;
+
+use tracing::field::{Field, Visit};
+use tracing::{Event, Level, Subscriber};
+use tracing_subscriber::Registry;
+use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::layer::{Context, Layer, SubscriberExt as _};
+use tracing_subscriber::reload;
+
+static RELOAD_HANDLE: OnceLock<reload::Handle<LevelFilter, Registry>> = OnceLock::new();
+
+/// Install the global subscriber. Idempotent: the first call wins, later
+/// calls (and a foreign subscriber already being set) are no-ops.
+pub fn init() {
+    if RELOAD_HANDLE.get().is_some() {
+        return;
+    }
+    let (filter, handle) = reload::Layer::<LevelFilter, Registry>::new(LevelFilter::OFF);
+    let subscriber = Registry::default().with(ConsoleLayer.with_filter(filter));
+    if tracing::subscriber::set_global_default(subscriber).is_ok() {
+        let _ = RELOAD_HANDLE.set(handle);
+    }
+}
+
+/// Set the live verbosity threshold. No-op until [`init`] has run.
+pub fn set_level(level: LevelFilter) {
+    if let Some(handle) = RELOAD_HANDLE.get() {
+        let _ = handle.reload(level);
+    }
+}
+
+/// Apply a host-supplied level string, installing the subscriber first so the
+/// call works regardless of whether the core has been constructed yet, then
+/// emitting a confirmation event so hosts can verify the logging pipeline end
+/// to end. The confirmation is logged at `INFO` (mapping to `console.info`,
+/// visible without DevTools "Verbose") rather than at the level just set, so it
+/// surfaces even when `debug`/`trace` events land on the hidden `console.debug`.
+pub fn set_level_from_str(level: &str) {
+    init();
+    set_level(parse_level(level));
+    tracing::info!(level, "log level set");
+}
+
+/// Parse a host-supplied level string. Unknown values disable logging.
+pub fn parse_level(level: &str) -> LevelFilter {
+    match level.to_ascii_lowercase().as_str() {
+        "error" => LevelFilter::ERROR,
+        "warn" | "warning" => LevelFilter::WARN,
+        "info" => LevelFilter::INFO,
+        "debug" => LevelFilter::DEBUG,
+        "trace" => LevelFilter::TRACE,
+        _ => LevelFilter::OFF,
+    }
+}
+
+/// Routes each event to the console method matching its level.
+struct ConsoleLayer;
+
+impl<S: Subscriber> Layer<S> for ConsoleLayer {
+    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
+        let meta = event.metadata();
+        let mut visitor = EventVisitor::default();
+        event.record(&mut visitor);
+
+        let mut line = format!("[truapi] {} {}", meta.level(), meta.target());
+        if !visitor.message.is_empty() {
+            let _ = write!(line, ": {}", visitor.message);
+        }
+        if !visitor.fields.is_empty() {
+            let _ = write!(line, " {{{}}}", visitor.fields);
+        }
+        emit(*meta.level(), &line);
+    }
+}
+
+/// Collects the implicit `message` field separately from explicit key-values.
+#[derive(Default)]
+struct EventVisitor {
+    message: String,
+    fields: String,
+}
+
+impl Visit for EventVisitor {
+    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+        if field.name() == "message" {
+            let _ = write!(self.message, "{value:?}");
+        } else {
+            if !self.fields.is_empty() {
+                self.fields.push_str(", ");
+            }
+            let _ = write!(self.fields, "{}={value:?}", field.name());
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn emit(_level: Level, line: &str) {
+    eprintln!("{line}");
+}
+
+#[cfg(target_arch = "wasm32")]
+fn emit(level: Level, line: &str) {
+    let js = wasm_bindgen::JsValue::from_str(line);
+    match level {
+        Level::ERROR => web_sys::console::error_1(&js),
+        Level::WARN => web_sys::console::warn_1(&js),
+        Level::INFO => web_sys::console::info_1(&js),
+        Level::DEBUG | Level::TRACE => web_sys::console::debug_1(&js),
+    }
+}
diff --git a/rust/crates/truapi-server/src/native.rs b/rust/crates/truapi-server/src/native.rs
new file mode 100644
index 00000000..1d12e37b
--- /dev/null
+++ b/rust/crates/truapi-server/src/native.rs
@@ -0,0 +1,1767 @@
+//! UniFFI-facing native bridge. Exposes [`NativeTrUApiCore`] and the
+//! [`HostCallbacks`] callback interface that iOS and Android call into.
+//!
+//! The native side builds a [`CallbackPlatform`] that adapts every
+//! [`truapi_platform::Platform`] trait to a corresponding callback. The
+//! resulting platform is fed into [`TrUApiCore::from_platform_with_config`] so the rest
+//! of the dispatcher pipeline behaves identically to the WS-bridge and wasm
+//! flavors.
+
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+use futures::channel::mpsc;
+use futures::executor::ThreadPool;
+use futures::future::BoxFuture;
+use futures::stream::{self, BoxStream, StreamExt};
+use futures::task::SpawnExt;
+use parity_scale_codec::Encode;
+use truapi::v01;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi_platform::PairingDeeplinkScheme as PlatformPairingDeeplinkScheme;
+use truapi_platform::{
+    AuthPresenter, ChainProvider, Features, JsonRpcConnection, Navigation, Notifications,
+    Permissions, PreimageHost, RuntimeConfig, RuntimeConfigValidationError, SessionStore, Storage,
+    ThemeHost, UserConfirmation,
+};
+
+use crate::TrUApiCore;
+use crate::subscription::Spawner;
+#[cfg(feature = "ws-bridge")]
+use crate::ws_bridge::{BridgeLogger, WsBridge, WsBridgeEndpoint, WsBridgeStartError};
+
+/// Native-friendly storage error. Mirrors the v0.1 wire shape so the
+/// callback surface stays SCALE-free.
+#[derive(Debug, Clone, thiserror::Error, uniffi::Error)]
+pub enum HostStorageError {
+    /// Quota exhausted.
+    #[error("storage quota exhausted")]
+    Full,
+    /// Catch-all.
+    #[error("{reason}")]
+    Unknown {
+        /// Human-readable failure reason.
+        reason: String,
+    },
+}
+
+impl From<HostStorageError> for v01::HostLocalStorageReadError {
+    fn from(err: HostStorageError) -> Self {
+        match err {
+            HostStorageError::Full => v01::HostLocalStorageReadError::Full,
+            HostStorageError::Unknown { reason } => {
+                v01::HostLocalStorageReadError::Unknown { reason }
+            }
+        }
+    }
+}
+
+/// Native-friendly rejection error returned by callback methods that map
+/// onto [`truapi::v01::GenericError`].
+#[derive(Debug, Clone, thiserror::Error, uniffi::Error)]
+pub enum HostRejection {
+    /// Caller rejected the operation.
+    #[error("{reason}")]
+    Rejected {
+        /// Human-readable rejection reason.
+        reason: String,
+    },
+}
+
+impl From<HostRejection> for v01::GenericError {
+    fn from(err: HostRejection) -> Self {
+        let HostRejection::Rejected { reason } = err;
+        v01::GenericError { reason }
+    }
+}
+
+/// Native-friendly navigation error.
+#[derive(Debug, Clone, thiserror::Error, uniffi::Error)]
+pub enum HostNavigateRejection {
+    /// User declined the navigation.
+    #[error("navigation denied by user")]
+    PermissionDenied,
+    /// Catch-all.
+    #[error("{reason}")]
+    Unknown {
+        /// Human-readable reason.
+        reason: String,
+    },
+}
+
+/// Native-friendly theme enum.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum HostTheme {
+    /// Light host theme.
+    Light,
+    /// Dark host theme.
+    Dark,
+}
+
+impl From<HostTheme> for v01::ThemeVariant {
+    fn from(theme: HostTheme) -> Self {
+        match theme {
+            HostTheme::Light => v01::ThemeVariant::Light,
+            HostTheme::Dark => v01::ThemeVariant::Dark,
+        }
+    }
+}
+
+/// Native-friendly mirror of [`truapi_platform::SessionUiInfo`]: decoded
+/// session fields for host account UI, with byte arrays widened to `Vec<u8>`
+/// for the FFI surface.
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
+pub struct SessionUiInfo {
+    /// Whether a session is currently active. When `false` every other
+    /// field is `None`.
+    pub connected: bool,
+    /// 32-byte sr25519 root public key of the active session.
+    pub public_key: Option<Vec<u8>>,
+    /// Wallet identity account id used for People-chain username lookup.
+    pub identity_account_id: Option<Vec<u8>>,
+    /// Short username from the People-chain identity record.
+    pub lite_username: Option<String>,
+    /// Fully qualified username from the People-chain identity record.
+    pub full_username: Option<String>,
+}
+
+impl From<truapi_platform::SessionUiInfo> for SessionUiInfo {
+    fn from(info: truapi_platform::SessionUiInfo) -> Self {
+        Self {
+            connected: info.connected,
+            public_key: info.public_key.map(|key| key.to_vec()),
+            identity_account_id: info.identity_account_id.map(|id| id.to_vec()),
+            lite_username: info.lite_username,
+            full_username: info.full_username,
+        }
+    }
+}
+
+/// Native-friendly mirror of [`truapi_platform::AuthState`]. The core emits
+/// these in transition order through `HostCallbacks::auth_state_changed`.
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
+pub enum AuthState {
+    /// No active session and no login in progress.
+    Disconnected,
+    /// A login is in progress: present the pairing deeplink/QR.
+    Pairing {
+        /// Wallet pairing deeplink to render as a QR code or open directly.
+        deeplink: String,
+    },
+    /// A session is active.
+    Connected {
+        /// Decoded session fields for host account UI.
+        info: SessionUiInfo,
+    },
+    /// The last login attempt failed; show the reason and offer a retry.
+    LoginFailed {
+        /// Human-readable failure reason.
+        reason: String,
+    },
+}
+
+impl From<truapi_platform::AuthState> for AuthState {
+    fn from(state: truapi_platform::AuthState) -> Self {
+        match state {
+            truapi_platform::AuthState::Disconnected => AuthState::Disconnected,
+            truapi_platform::AuthState::Pairing { deeplink } => AuthState::Pairing { deeplink },
+            truapi_platform::AuthState::Connected(info) => {
+                AuthState::Connected { info: info.into() }
+            }
+            truapi_platform::AuthState::LoginFailed { reason } => AuthState::LoginFailed { reason },
+        }
+    }
+}
+
+/// Native-friendly SSO deeplink scheme.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum NativePairingDeeplinkScheme {
+    /// Production Polkadot app.
+    PolkadotApp,
+    /// Development Polkadot app.
+    PolkadotAppDev,
+}
+
+impl From<NativePairingDeeplinkScheme> for PlatformPairingDeeplinkScheme {
+    fn from(scheme: NativePairingDeeplinkScheme) -> Self {
+        match scheme {
+            NativePairingDeeplinkScheme::PolkadotApp => PlatformPairingDeeplinkScheme::PolkadotApp,
+            NativePairingDeeplinkScheme::PolkadotAppDev => {
+                PlatformPairingDeeplinkScheme::PolkadotAppDev
+            }
+        }
+    }
+}
+
+/// Native runtime configuration supplied before product calls are handled.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct NativeRuntimeConfig {
+    /// Human-readable dotli label, e.g. `my-app`.
+    pub product_label: String,
+    /// Canonical product identifier used for account derivation.
+    pub product_id: String,
+    /// Host deployment/site identifier.
+    pub site_id: String,
+    /// Host name shown by the wallet during SSO pairing.
+    pub host_name: String,
+    /// Optional host icon URL shown by the wallet during SSO pairing.
+    pub host_icon: Option<String>,
+    /// Optional host version shown by the wallet during SSO pairing.
+    pub host_version: Option<String>,
+    /// Optional platform/browser name shown by the wallet during SSO pairing.
+    pub platform_type: Option<String>,
+    /// Optional platform/browser version shown by the wallet during SSO pairing.
+    pub platform_version: Option<String>,
+    /// People-chain genesis hash. Must be exactly 32 bytes.
+    pub people_chain_genesis_hash: Vec<u8>,
+    /// Deeplink scheme used in pairing QR payloads.
+    pub pairing_deeplink_scheme: NativePairingDeeplinkScheme,
+}
+
+/// Native runtime config validation error.
+#[derive(Debug, Clone, thiserror::Error, uniffi::Error)]
+pub enum NativeRuntimeConfigError {
+    /// Required string field was empty or whitespace-only.
+    #[error("{field} must not be empty")]
+    EmptyField {
+        /// Field name.
+        field: String,
+    },
+    /// People-chain genesis hash was not exactly 32 bytes.
+    #[error("people_chain_genesis_hash must be exactly 32 bytes, got {actual}")]
+    InvalidPeopleChainGenesisHash {
+        /// Supplied byte length.
+        actual: u64,
+    },
+    /// Host icon URL could not be parsed.
+    #[error("host_icon must be an absolute HTTPS URL: {reason}")]
+    InvalidHostIcon {
+        /// Parse failure reason.
+        reason: String,
+    },
+    /// Host icon URL used a non-HTTPS scheme.
+    #[error("host_icon must use https scheme, got {scheme:?}")]
+    InsecureHostIcon {
+        /// Actual URL scheme.
+        scheme: String,
+    },
+}
+
+impl TryFrom<NativeRuntimeConfig> for RuntimeConfig {
+    type Error = NativeRuntimeConfigError;
+
+    fn try_from(config: NativeRuntimeConfig) -> Result<Self, Self::Error> {
+        let people_chain_genesis_hash =
+            <[u8; 32]>::try_from(config.people_chain_genesis_hash.as_slice()).map_err(|_| {
+                NativeRuntimeConfigError::InvalidPeopleChainGenesisHash {
+                    actual: config.people_chain_genesis_hash.len() as u64,
+                }
+            })?;
+        let runtime_config = Self {
+            product_label: config.product_label,
+            product_id: config.product_id,
+            site_id: config.site_id,
+            host_name: config.host_name,
+            host_icon: config.host_icon,
+            host_version: config.host_version,
+            platform_type: config.platform_type,
+            platform_version: config.platform_version,
+            people_chain_genesis_hash,
+            pairing_deeplink_scheme: config.pairing_deeplink_scheme.into(),
+        };
+        runtime_config.validate()?;
+        Ok(runtime_config)
+    }
+}
+
+impl From<RuntimeConfigValidationError> for NativeRuntimeConfigError {
+    fn from(err: RuntimeConfigValidationError) -> Self {
+        match err {
+            RuntimeConfigValidationError::EmptyField { field } => Self::EmptyField {
+                field: field.to_string(),
+            },
+            RuntimeConfigValidationError::InvalidHostIcon { reason } => {
+                Self::InvalidHostIcon { reason }
+            }
+            RuntimeConfigValidationError::InsecureHostIcon { scheme } => {
+                Self::InsecureHostIcon { scheme }
+            }
+        }
+    }
+}
+
+impl From<HostNavigateRejection> for v01::HostNavigateToError {
+    fn from(err: HostNavigateRejection) -> Self {
+        match err {
+            HostNavigateRejection::PermissionDenied => v01::HostNavigateToError::PermissionDenied,
+            HostNavigateRejection::Unknown { reason } => {
+                v01::HostNavigateToError::Unknown { reason }
+            }
+        }
+    }
+}
+
+/// Callback surface that iOS and Android implement.
+///
+/// Threading contract: every callback is invoked on a background thread
+/// owned by the Rust core, never the host's main/UI thread. UI-decision
+/// callbacks (`navigate_to`, `device_permission`, `remote_permission`,
+/// the `confirm_*` family) plus the potentially slow `submit_preimage` run
+/// on the tokio blocking pool, so an implementation may block its calling
+/// thread until the user decides without stalling concurrent dispatches.
+/// All other callbacks run inline on the dispatcher thread and must return
+/// promptly; in particular `auth_state_changed` should only hand the state
+/// to the host UI thread, never wait for the user. As the one exception to
+/// the background-thread rule, `auth_state_changed` can also arrive
+/// synchronously on whichever thread calls `NativeTrUApiCore::cancel_login`.
+#[uniffi::export(callback_interface)]
+pub trait HostCallbacks: Send + Sync {
+    /// Lifecycle logger. Marker is a stable slug, detail is free-form.
+    fn on_core_log(&self, marker: String, detail: String);
+
+    /// Open a URL in the system browser.
+    fn navigate_to(&self, url: String) -> Result<(), HostNavigateRejection>;
+
+    /// Deliver a push notification. The payload is the SCALE-encoded
+    /// [`v01::HostPushNotificationRequest`].
+    fn push_notification(&self, payload: Vec<u8>) -> Result<u32, HostRejection>;
+
+    /// Cancel a notification by id.
+    fn cancel_notification(&self, id: u32) -> Result<(), HostRejection>;
+
+    /// Prompt the user for a device-level permission (camera, mic, ...).
+    /// `request` is the SCALE-encoded
+    /// [`v01::HostDevicePermissionRequest`]; the host returns whether the
+    /// permission was granted.
+    fn device_permission(&self, request: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Prompt the user for a remote (product-scoped) permission bundle.
+    /// `request` is the SCALE-encoded [`v01::RemotePermissionRequest`].
+    fn remote_permission(&self, request: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Observe an auth state change. Emitted only when the state actually
+    /// changes, in transition order: render `Pairing` as the pairing QR UI,
+    /// `Connected`/`Disconnected` as the account badge, `LoginFailed` as a
+    /// retryable error. User cancellation is reported through
+    /// `NativeTrUApiCore.cancel_login()`.
+    fn auth_state_changed(&self, state: AuthState);
+
+    /// Read the opaque core-owned SSO session blob from host-global storage.
+    fn read_session(&self) -> Result<Option<Vec<u8>>, HostRejection>;
+
+    /// Persist the opaque core-owned SSO session blob in host-global storage.
+    fn write_session(&self, value: Vec<u8>) -> Result<(), HostRejection>;
+
+    /// Clear the persisted core-owned SSO session blob.
+    fn clear_session(&self) -> Result<(), HostRejection>;
+
+    /// Open a JSON-RPC connection for a chain. Return a host-assigned
+    /// connection id, or `None` when unsupported.
+    fn chain_connect(&self, genesis_hash: Vec<u8>) -> Result<Option<u32>, HostRejection>;
+
+    /// Send one JSON-RPC request over a previously opened chain connection.
+    fn chain_send(&self, connection_id: u32, request: String) -> Result<(), HostRejection>;
+
+    /// Close a previously opened chain connection.
+    fn chain_close(&self, connection_id: u32) -> Result<(), HostRejection>;
+
+    /// Confirm a sign-payload request. `review` is a SCALE-encoded review
+    /// payload owned by the Rust core.
+    fn confirm_sign_payload(&self, review: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Confirm a sign-raw request. `review` is a SCALE-encoded review payload
+    /// owned by the Rust core.
+    fn confirm_sign_raw(&self, review: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Confirm a create-transaction request. `review` is a SCALE-encoded
+    /// review payload owned by the Rust core.
+    fn confirm_create_transaction(&self, review: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Confirm a cross-domain account-alias request. `review` is a
+    /// SCALE-encoded review payload owned by the Rust core.
+    fn confirm_account_alias(&self, review: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Confirm a resource-allocation request. `review` is a SCALE-encoded
+    /// review payload owned by the Rust core.
+    fn confirm_resource_allocation(&self, review: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Confirm preimage submission before the host stores it.
+    fn confirm_preimage_submit(&self, size: u64) -> Result<(), HostRejection>;
+
+    /// Submit the preimage through the host backend and return its key.
+    fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, HostRejection>;
+
+    /// Look up one preimage value by key. The native shim emits this as the
+    /// current item in its subscription stream.
+    fn lookup_preimage(&self, key: Vec<u8>) -> Result<Option<Vec<u8>>, HostRejection>;
+
+    /// Current host theme. The native shim emits this as the current item in
+    /// its subscription stream.
+    fn current_theme(&self) -> Result<HostTheme, HostRejection>;
+
+    /// Answer a feature-support query. `request` is the SCALE-encoded
+    /// [`HostFeatureSupportedRequest`].
+    fn feature_supported(&self, request: Vec<u8>) -> Result<bool, HostRejection>;
+
+    /// Read a value from the host's scoped key-value store.
+    fn local_storage_read(&self, key: String) -> Result<Option<Vec<u8>>, HostStorageError>;
+    /// Write a value to the host's scoped key-value store.
+    fn local_storage_write(&self, key: String, value: Vec<u8>) -> Result<(), HostStorageError>;
+    /// Clear a value from the host's scoped key-value store.
+    fn local_storage_clear(&self, key: String) -> Result<(), HostStorageError>;
+}
+
+/// UniFFI object exposing the TrUAPI core to native hosts.
+#[derive(uniffi::Object)]
+pub struct NativeTrUApiCore {
+    core: Arc<TrUApiCore>,
+    events: Arc<NativeEventBus>,
+    #[cfg(feature = "ws-bridge")]
+    callbacks: Arc<dyn HostCallbacks>,
+    #[cfg(feature = "ws-bridge")]
+    bridge: std::sync::Mutex<Option<WsBridge>>,
+}
+
+#[uniffi::export]
+impl NativeTrUApiCore {
+    /// Construct the core with explicit product and pairing runtime config.
+    #[uniffi::constructor]
+    pub fn with_runtime_config(
+        callbacks: Box<dyn HostCallbacks>,
+        runtime_config: NativeRuntimeConfig,
+    ) -> Result<Arc<Self>, NativeRuntimeConfigError> {
+        Ok(native_core_from_platform_config(
+            callbacks,
+            runtime_config.try_into()?,
+        ))
+    }
+
+    /// Core-owned logout/disconnect. Best-effort notifies the SSO peer when
+    /// the session has channel material, then clears in-memory and persisted
+    /// session state.
+    pub fn disconnect(&self) {
+        self.core.disconnect();
+    }
+
+    /// Notify this core that host-global session storage changed outside a
+    /// direct core write/clear. Native hosts call this after cross-process or
+    /// platform storage notifications so the core re-reads `SessionStore`.
+    pub fn notify_session_store_changed(&self) {
+        self.events.notify_session_store_changed();
+    }
+
+    /// Cancel any in-flight `request_login` pairing (e.g. the user dismissed
+    /// the pairing UI). The host receives a `Disconnected` auth state
+    /// immediately and the pending login resolves to `Rejected`. A no-op
+    /// when no login is in progress.
+    pub fn cancel_login(&self) {
+        self.core.cancel_login();
+    }
+
+    /// Push a host theme update to active TrUAPI theme subscriptions.
+    pub fn notify_theme_changed(&self, theme: HostTheme) {
+        self.events.notify_theme_changed(theme.into());
+    }
+
+    /// Push a preimage lookup update to active subscriptions for `key`.
+    ///
+    /// `value == None` represents a known miss; `Some(bytes)` represents the
+    /// current preimage value.
+    pub fn notify_preimage_changed(&self, key: Vec<u8>, value: Option<Vec<u8>>) {
+        self.events.notify_preimage_changed(&key, value);
+    }
+
+    /// Push a JSON-RPC response from a native chain connection into the core.
+    pub fn notify_chain_response(&self, connection_id: u32, json: String) {
+        self.events.notify_chain_response(connection_id, json);
+    }
+
+    /// Notify the core that a native chain connection closed externally.
+    pub fn notify_chain_closed(&self, connection_id: u32) {
+        self.events.notify_chain_closed(connection_id);
+    }
+}
+
+/// Set the live log level (`off`/`error`/`warn`/`info`/`debug`/`trace`) for
+/// the `tracing` output, which on native routes to stderr (system logs on
+/// iOS/Android). Most native diagnostics flow through `on_core_log` instead;
+/// this controls the cross-platform `tracing` events shared with wasm.
+#[uniffi::export]
+pub fn set_log_level(level: String) {
+    crate::logging::set_level_from_str(&level);
+}
+
+fn native_core_from_platform_config(
+    callbacks: Box<dyn HostCallbacks>,
+    runtime_config: RuntimeConfig,
+) -> Arc<NativeTrUApiCore> {
+    crate::logging::init();
+    let callbacks: Arc<dyn HostCallbacks> = callbacks.into();
+    callbacks.on_core_log(
+        "truapi.native.core.boot".to_string(),
+        "core ready".to_string(),
+    );
+
+    let events = Arc::new(NativeEventBus::default());
+    let platform = Arc::new(CallbackPlatform {
+        callbacks: callbacks.clone(),
+        events: events.clone(),
+    });
+    let spawner = native_thread_pool_spawner(&callbacks);
+    Arc::new(NativeTrUApiCore {
+        core: Arc::new(TrUApiCore::from_platform_with_config(
+            platform,
+            runtime_config,
+            spawner,
+        )),
+        events,
+        #[cfg(feature = "ws-bridge")]
+        callbacks,
+        #[cfg(feature = "ws-bridge")]
+        bridge: std::sync::Mutex::new(None),
+    })
+}
+
+#[cfg(feature = "ws-bridge")]
+#[uniffi::export]
+impl NativeTrUApiCore {
+    /// Start the localhost WebSocket bridge. Returns the descriptor the
+    /// host hands to the product so it can dial back in.
+    pub fn start_ws_bridge(&self, bind_port: u16) -> Result<WsBridgeEndpoint, WsBridgeStartError> {
+        let mut guard = self.bridge.lock().unwrap();
+        if guard.is_some() {
+            return Err(WsBridgeStartError::AlreadyRunning);
+        }
+        let logger: BridgeLogger = {
+            let callbacks = self.callbacks.clone();
+            Arc::new(move |marker: &str, detail: &str| {
+                callbacks.on_core_log(marker.to_string(), detail.to_string());
+            })
+        };
+        let (bridge, endpoint) = WsBridge::start(bind_port, self.core.clone(), logger)?;
+        *guard = Some(bridge);
+        Ok(endpoint)
+    }
+
+    /// Stop the localhost WebSocket bridge (if running).
+    pub fn stop_ws_bridge(&self) {
+        if let Some(mut bridge) = self.bridge.lock().unwrap().take() {
+            bridge.stop();
+        }
+    }
+}
+
+/// Build a [`Spawner`] backed by a shared `futures::executor::ThreadPool`.
+/// The pool is sized at the default (one worker per logical CPU). Falls
+/// back to a thread-per-subscription spawner if the pool fails to build,
+/// which only ever happens if the host has no available threads at all.
+fn native_thread_pool_spawner(callbacks: &Arc<dyn HostCallbacks>) -> Spawner {
+    match ThreadPool::new() {
+        Ok(pool) => {
+            let callbacks = callbacks.clone();
+            Arc::new(move |fut: BoxFuture<'static, ()>| {
+                if let Err(err) = pool.spawn(fut) {
+                    callbacks.on_core_log(
+                        "truapi.native.core.subscription.spawn_failed".to_string(),
+                        format!("{err}"),
+                    );
+                }
+            })
+        }
+        Err(err) => {
+            callbacks.on_core_log(
+                "truapi.native.core.subscription.pool_unavailable".to_string(),
+                format!("{err}; falling back to thread-per-subscription"),
+            );
+            crate::subscription::thread_per_subscription_spawner()
+        }
+    }
+}
+
+struct CallbackPlatform {
+    callbacks: Arc<dyn HostCallbacks>,
+    events: Arc<NativeEventBus>,
+}
+
+/// Run a host callback that may block awaiting a user decision.
+///
+/// UI-decision callbacks are allowed to block their calling thread until the
+/// user decides. Running them inline would stall the single-threaded
+/// WS-bridge dispatcher (and deadlock if the decision UI itself issues a
+/// TrUAPI call), so inside a tokio runtime the callback is moved to the
+/// blocking pool. Outside a tokio context the callback runs inline.
+async fn run_blocking_callback<T, F>(callback: F) -> T
+where
+    T: Send + 'static,
+    F: FnOnce() -> T + Send + 'static,
+{
+    #[cfg(feature = "ws-bridge")]
+    if let Ok(handle) = tokio::runtime::Handle::try_current() {
+        return handle
+            .spawn_blocking(callback)
+            .await
+            .expect("blocking host callback panicked");
+    }
+    callback()
+}
+
+#[derive(Default)]
+struct NativeEventBus {
+    session_store_ticks: Mutex<Vec<mpsc::UnboundedSender<Result<(), v01::GenericError>>>>,
+    theme_changes: Mutex<Vec<mpsc::UnboundedSender<Result<v01::ThemeVariant, v01::GenericError>>>>,
+    preimage_changes: Mutex<Vec<PreimageSubscription>>,
+    chain_responses: Mutex<HashMap<u32, mpsc::UnboundedSender<String>>>,
+}
+
+struct PreimageSubscription {
+    key: Vec<u8>,
+    tx: mpsc::UnboundedSender<Result<Option<Vec<u8>>, v01::GenericError>>,
+}
+
+impl NativeEventBus {
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), v01::GenericError>> {
+        let (tx, rx) = mpsc::unbounded();
+        self.session_store_ticks
+            .lock()
+            .expect("native session store subscribers mutex poisoned")
+            .push(tx);
+        stream::once(async { Ok(()) }).chain(rx).boxed()
+    }
+
+    fn notify_session_store_changed(&self) {
+        self.session_store_ticks
+            .lock()
+            .expect("native session store subscribers mutex poisoned")
+            .retain(|tx| tx.unbounded_send(Ok(())).is_ok());
+    }
+
+    fn subscribe_theme(
+        &self,
+        current: Result<v01::ThemeVariant, v01::GenericError>,
+    ) -> BoxStream<'static, Result<v01::ThemeVariant, v01::GenericError>> {
+        let (tx, rx) = mpsc::unbounded();
+        self.theme_changes
+            .lock()
+            .expect("native theme subscribers mutex poisoned")
+            .push(tx);
+        stream::once(async move { current }).chain(rx).boxed()
+    }
+
+    fn notify_theme_changed(&self, theme: v01::ThemeVariant) {
+        self.theme_changes
+            .lock()
+            .expect("native theme subscribers mutex poisoned")
+            .retain(|tx| tx.unbounded_send(Ok(theme)).is_ok());
+    }
+
+    fn subscribe_preimage(
+        &self,
+        key: Vec<u8>,
+        current: Result<Option<Vec<u8>>, v01::GenericError>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, v01::GenericError>> {
+        let (tx, rx) = mpsc::unbounded();
+        self.preimage_changes
+            .lock()
+            .expect("native preimage subscribers mutex poisoned")
+            .push(PreimageSubscription { key, tx });
+        stream::once(async move { current }).chain(rx).boxed()
+    }
+
+    fn notify_preimage_changed(&self, key: &[u8], value: Option<Vec<u8>>) {
+        self.preimage_changes
+            .lock()
+            .expect("native preimage subscribers mutex poisoned")
+            .retain(|sub| {
+                if sub.key != key {
+                    return true;
+                }
+                sub.tx.unbounded_send(Ok(value.clone())).is_ok()
+            });
+    }
+
+    fn register_chain(&self, connection_id: u32) -> mpsc::UnboundedReceiver<String> {
+        let (tx, rx) = mpsc::unbounded();
+        self.chain_responses
+            .lock()
+            .expect("native chain subscribers mutex poisoned")
+            .insert(connection_id, tx);
+        rx
+    }
+
+    fn notify_chain_response(&self, connection_id: u32, json: String) {
+        let mut responses = self
+            .chain_responses
+            .lock()
+            .expect("native chain subscribers mutex poisoned");
+        let Some(tx) = responses.get(&connection_id) else {
+            return;
+        };
+        if tx.unbounded_send(json).is_err() {
+            responses.remove(&connection_id);
+        }
+    }
+
+    fn notify_chain_closed(&self, connection_id: u32) {
+        self.chain_responses
+            .lock()
+            .expect("native chain subscribers mutex poisoned")
+            .remove(&connection_id);
+    }
+}
+
+impl Navigation for CallbackPlatform {
+    async fn navigate_to(&self, url: String) -> Result<(), v01::HostNavigateToError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.navigate_to".to_string(),
+            url.clone(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.navigate_to(url))
+            .await
+            .map_err(Into::into)
+    }
+}
+
+impl Notifications for CallbackPlatform {
+    async fn push_notification(
+        &self,
+        notification: v01::HostPushNotificationRequest,
+    ) -> Result<v01::HostPushNotificationResponse, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.push_notification".to_string(),
+            notification.text.clone(),
+        );
+        let id = self
+            .callbacks
+            .push_notification(notification.encode())
+            .map_err(v01::GenericError::from)?;
+        Ok(v01::HostPushNotificationResponse { id })
+    }
+
+    async fn cancel_notification(&self, id: u32) -> Result<(), v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.cancel_notification".to_string(),
+            id.to_string(),
+        );
+        self.callbacks
+            .cancel_notification(id)
+            .map_err(v01::GenericError::from)
+    }
+}
+
+impl Permissions for CallbackPlatform {
+    async fn device_permission(
+        &self,
+        request: v01::HostDevicePermissionRequest,
+    ) -> Result<v01::HostDevicePermissionResponse, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.device_permission".to_string(),
+            format!("{request}"),
+        );
+        let callbacks = self.callbacks.clone();
+        let payload = request.encode();
+        let granted = run_blocking_callback(move || callbacks.device_permission(payload))
+            .await
+            .map_err(v01::GenericError::from)?;
+        Ok(v01::HostDevicePermissionResponse { granted })
+    }
+
+    async fn remote_permission(
+        &self,
+        request: v01::RemotePermissionRequest,
+    ) -> Result<v01::RemotePermissionResponse, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.remote_permission".to_string(),
+            format!("{request}"),
+        );
+        let callbacks = self.callbacks.clone();
+        let payload = request.encode();
+        let granted = run_blocking_callback(move || callbacks.remote_permission(payload))
+            .await
+            .map_err(v01::GenericError::from)?;
+        Ok(v01::RemotePermissionResponse { granted })
+    }
+}
+
+impl Features for CallbackPlatform {
+    async fn feature_supported(
+        &self,
+        request: HostFeatureSupportedRequest,
+    ) -> Result<HostFeatureSupportedResponse, v01::GenericError> {
+        let supported = self
+            .callbacks
+            .feature_supported(request.encode())
+            .map_err(v01::GenericError::from)?;
+        Ok(HostFeatureSupportedResponse::V1(
+            v01::HostFeatureSupportedResponse { supported },
+        ))
+    }
+}
+
+impl Storage for CallbackPlatform {
+    async fn read(&self, key: String) -> Result<Option<Vec<u8>>, v01::HostLocalStorageReadError> {
+        self.callbacks.local_storage_read(key).map_err(Into::into)
+    }
+
+    async fn write(
+        &self,
+        key: String,
+        value: Vec<u8>,
+    ) -> Result<(), v01::HostLocalStorageReadError> {
+        self.callbacks
+            .local_storage_write(key, value)
+            .map_err(Into::into)
+    }
+
+    async fn clear(&self, key: String) -> Result<(), v01::HostLocalStorageReadError> {
+        self.callbacks.local_storage_clear(key).map_err(Into::into)
+    }
+}
+
+struct NativeJsonRpcConnection {
+    id: u32,
+    callbacks: Arc<dyn HostCallbacks>,
+    events: Arc<NativeEventBus>,
+    response_rx: Mutex<Option<mpsc::UnboundedReceiver<String>>>,
+    closed: AtomicBool,
+}
+
+impl JsonRpcConnection for NativeJsonRpcConnection {
+    fn send(&self, request: String) {
+        if self.closed.load(Ordering::Relaxed) {
+            return;
+        }
+        if let Err(err) = self.callbacks.chain_send(self.id, request) {
+            self.callbacks.on_core_log(
+                "truapi.native.callback.chain_send_failed".to_string(),
+                err.to_string(),
+            );
+        }
+    }
+
+    fn responses(&self) -> BoxStream<'static, String> {
+        let mut guard = self.response_rx.lock().unwrap();
+        match guard.take() {
+            Some(rx) => rx.boxed(),
+            None => {
+                self.callbacks.on_core_log(
+                    "truapi.native.chain.responses_reused".to_string(),
+                    "responses() called more than once".to_string(),
+                );
+                stream::empty().boxed()
+            }
+        }
+    }
+}
+
+impl Drop for NativeJsonRpcConnection {
+    fn drop(&mut self) {
+        if self.closed.swap(true, Ordering::Relaxed) {
+            return;
+        }
+        self.events.notify_chain_closed(self.id);
+        if let Err(err) = self.callbacks.chain_close(self.id) {
+            self.callbacks.on_core_log(
+                "truapi.native.callback.chain_close_failed".to_string(),
+                err.to_string(),
+            );
+        }
+    }
+}
+
+impl ChainProvider for CallbackPlatform {
+    async fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<Box<dyn JsonRpcConnection>, v01::GenericError> {
+        let Some(connection_id) = self
+            .callbacks
+            .chain_connect(genesis_hash)
+            .map_err(v01::GenericError::from)?
+        else {
+            return Err(v01::GenericError {
+                reason: "chain provider unavailable".to_string(),
+            });
+        };
+        let response_rx = self.events.register_chain(connection_id);
+        Ok(Box::new(NativeJsonRpcConnection {
+            id: connection_id,
+            callbacks: self.callbacks.clone(),
+            events: self.events.clone(),
+            response_rx: Mutex::new(Some(response_rx)),
+            closed: AtomicBool::new(false),
+        }))
+    }
+}
+
+impl AuthPresenter for CallbackPlatform {
+    fn auth_state_changed(&self, state: truapi_platform::AuthState) {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.auth_state_changed".to_string(),
+            String::new(),
+        );
+        self.callbacks.auth_state_changed(state.into());
+    }
+}
+
+impl SessionStore for CallbackPlatform {
+    async fn read_session(&self) -> Result<Option<Vec<u8>>, v01::GenericError> {
+        self.callbacks
+            .read_session()
+            .map_err(v01::GenericError::from)
+    }
+
+    async fn write_session(&self, value: Vec<u8>) -> Result<(), v01::GenericError> {
+        self.callbacks
+            .write_session(value)
+            .map_err(v01::GenericError::from)?;
+        self.events.notify_session_store_changed();
+        Ok(())
+    }
+
+    async fn clear_session(&self) -> Result<(), v01::GenericError> {
+        self.callbacks
+            .clear_session()
+            .map_err(v01::GenericError::from)?;
+        self.events.notify_session_store_changed();
+        Ok(())
+    }
+
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), v01::GenericError>> {
+        self.events.subscribe_session_store()
+    }
+}
+
+impl UserConfirmation for CallbackPlatform {
+    async fn confirm_sign_payload(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.confirm_sign_payload".to_string(),
+            String::new(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_sign_payload(review))
+            .await
+            .map_err(v01::GenericError::from)
+    }
+
+    async fn confirm_sign_raw(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.confirm_sign_raw".to_string(),
+            String::new(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_sign_raw(review))
+            .await
+            .map_err(v01::GenericError::from)
+    }
+
+    async fn confirm_create_transaction(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.confirm_create_transaction".to_string(),
+            String::new(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_create_transaction(review))
+            .await
+            .map_err(v01::GenericError::from)
+    }
+
+    async fn confirm_account_alias(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.confirm_account_alias".to_string(),
+            String::new(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_account_alias(review))
+            .await
+            .map_err(v01::GenericError::from)
+    }
+
+    async fn confirm_resource_allocation(
+        &self,
+        review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        self.callbacks.on_core_log(
+            "truapi.native.callback.confirm_resource_allocation".to_string(),
+            String::new(),
+        );
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_resource_allocation(review))
+            .await
+            .map_err(v01::GenericError::from)
+    }
+}
+
+impl ThemeHost for CallbackPlatform {
+    fn subscribe_theme(&self) -> BoxStream<'static, Result<v01::ThemeVariant, v01::GenericError>> {
+        let current = self
+            .callbacks
+            .current_theme()
+            .map(v01::ThemeVariant::from)
+            .map_err(v01::GenericError::from);
+        self.events.subscribe_theme(current)
+    }
+}
+
+impl PreimageHost for CallbackPlatform {
+    async fn confirm_preimage_submit(&self, size: u64) -> Result<(), v01::PreimageSubmitError> {
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.confirm_preimage_submit(size))
+            .await
+            .map_err(|err| v01::PreimageSubmitError::Unknown {
+                reason: err.to_string(),
+            })
+    }
+
+    async fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, v01::PreimageSubmitError> {
+        let callbacks = self.callbacks.clone();
+        run_blocking_callback(move || callbacks.submit_preimage(value))
+            .await
+            .map_err(|err| v01::PreimageSubmitError::Unknown {
+                reason: err.to_string(),
+            })
+    }
+
+    fn lookup_preimage(
+        &self,
+        key: Vec<u8>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, v01::GenericError>> {
+        let current = self
+            .callbacks
+            .lookup_preimage(key.clone())
+            .map_err(v01::GenericError::from);
+        self.events.subscribe_preimage(key, current)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    type PreimageFixtureEntries = Vec<(Vec<u8>, Option<Vec<u8>>)>;
+
+    struct EventCallbacks {
+        theme: Mutex<HostTheme>,
+        preimages: Mutex<PreimageFixtureEntries>,
+        auth_states: Mutex<Vec<AuthState>>,
+        chain_id: Mutex<Option<u32>>,
+        chain_connects: Mutex<Vec<Vec<u8>>>,
+        chain_sends: Mutex<Vec<(u32, String)>>,
+        chain_closes: Mutex<Vec<u32>>,
+    }
+
+    impl EventCallbacks {
+        fn new() -> Self {
+            Self {
+                theme: Mutex::new(HostTheme::Light),
+                preimages: Mutex::new(Vec::new()),
+                auth_states: Mutex::new(Vec::new()),
+                chain_id: Mutex::new(None),
+                chain_connects: Mutex::new(Vec::new()),
+                chain_sends: Mutex::new(Vec::new()),
+                chain_closes: Mutex::new(Vec::new()),
+            }
+        }
+    }
+
+    impl HostCallbacks for EventCallbacks {
+        fn on_core_log(&self, _marker: String, _detail: String) {}
+        fn navigate_to(&self, _url: String) -> Result<(), HostNavigateRejection> {
+            Ok(())
+        }
+        fn push_notification(&self, _payload: Vec<u8>) -> Result<u32, HostRejection> {
+            Ok(0)
+        }
+        fn cancel_notification(&self, _id: u32) -> Result<(), HostRejection> {
+            Ok(())
+        }
+        fn device_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn remote_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn auth_state_changed(&self, state: AuthState) {
+            self.auth_states
+                .lock()
+                .expect("auth state mutex poisoned")
+                .push(state);
+        }
+        fn read_session(&self) -> Result<Option<Vec<u8>>, HostRejection> {
+            Ok(None)
+        }
+        fn write_session(&self, _value: Vec<u8>) -> Result<(), HostRejection> {
+            Ok(())
+        }
+        fn clear_session(&self) -> Result<(), HostRejection> {
+            Ok(())
+        }
+        fn chain_connect(&self, genesis_hash: Vec<u8>) -> Result<Option<u32>, HostRejection> {
+            self.chain_connects
+                .lock()
+                .expect("chain connects mutex poisoned")
+                .push(genesis_hash);
+            Ok(*self.chain_id.lock().expect("chain id mutex poisoned"))
+        }
+        fn chain_send(&self, connection_id: u32, request: String) -> Result<(), HostRejection> {
+            self.chain_sends
+                .lock()
+                .expect("chain sends mutex poisoned")
+                .push((connection_id, request));
+            Ok(())
+        }
+        fn chain_close(&self, connection_id: u32) -> Result<(), HostRejection> {
+            self.chain_closes
+                .lock()
+                .expect("chain closes mutex poisoned")
+                .push(connection_id);
+            Ok(())
+        }
+        fn confirm_sign_payload(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn confirm_sign_raw(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn confirm_create_transaction(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn confirm_account_alias(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn confirm_resource_allocation(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn confirm_preimage_submit(&self, _size: u64) -> Result<(), HostRejection> {
+            Ok(())
+        }
+        fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, HostRejection> {
+            Ok(value)
+        }
+        fn lookup_preimage(&self, key: Vec<u8>) -> Result<Option<Vec<u8>>, HostRejection> {
+            Ok(self
+                .preimages
+                .lock()
+                .expect("preimage map mutex poisoned")
+                .iter()
+                .find(|(stored_key, _)| stored_key == &key)
+                .and_then(|(_, value)| value.clone()))
+        }
+        fn current_theme(&self) -> Result<HostTheme, HostRejection> {
+            Ok(*self.theme.lock().expect("theme mutex poisoned"))
+        }
+        fn feature_supported(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+            Ok(false)
+        }
+        fn local_storage_read(&self, _key: String) -> Result<Option<Vec<u8>>, HostStorageError> {
+            Ok(None)
+        }
+        fn local_storage_write(
+            &self,
+            _key: String,
+            _value: Vec<u8>,
+        ) -> Result<(), HostStorageError> {
+            Ok(())
+        }
+        fn local_storage_clear(&self, _key: String) -> Result<(), HostStorageError> {
+            Ok(())
+        }
+    }
+
+    fn event_platform() -> (Arc<EventCallbacks>, Arc<NativeEventBus>, CallbackPlatform) {
+        let callbacks = Arc::new(EventCallbacks::new());
+        let events = Arc::new(NativeEventBus::default());
+        let platform = CallbackPlatform {
+            callbacks: callbacks.clone(),
+            events: events.clone(),
+        };
+        (callbacks, events, platform)
+    }
+
+    #[test]
+    fn native_auth_presenter_forwards_states_across_the_ffi_mirror() {
+        let (callbacks, _events, platform) = event_platform();
+
+        platform.auth_state_changed(truapi_platform::AuthState::Pairing {
+            deeplink: "polkadotapp://pair?handshake=00".to_string(),
+        });
+        platform.auth_state_changed(truapi_platform::AuthState::Connected(
+            truapi_platform::SessionUiInfo {
+                connected: true,
+                public_key: Some([7; 32]),
+                identity_account_id: None,
+                lite_username: Some("alice".to_string()),
+                full_username: None,
+            },
+        ));
+        platform.auth_state_changed(truapi_platform::AuthState::Disconnected);
+
+        assert_eq!(
+            callbacks
+                .auth_states
+                .lock()
+                .expect("auth state mutex poisoned")
+                .as_slice(),
+            &[
+                AuthState::Pairing {
+                    deeplink: "polkadotapp://pair?handshake=00".to_string(),
+                },
+                AuthState::Connected {
+                    info: SessionUiInfo {
+                        connected: true,
+                        public_key: Some(vec![7; 32]),
+                        identity_account_id: None,
+                        lite_username: Some("alice".to_string()),
+                        full_username: None,
+                    },
+                },
+                AuthState::Disconnected,
+            ]
+        );
+    }
+
+    #[test]
+    fn native_session_store_subscription_emits_current_then_notified_ticks() {
+        let (_callbacks, events, platform) = event_platform();
+        let mut stream = platform.subscribe_session_store();
+
+        let first = futures::executor::block_on(stream.next()).unwrap();
+        events.notify_session_store_changed();
+        let second = futures::executor::block_on(stream.next()).unwrap();
+
+        assert!(first.is_ok());
+        assert!(second.is_ok());
+    }
+
+    #[test]
+    fn native_theme_subscription_emits_current_then_notified_changes() {
+        let (callbacks, events, platform) = event_platform();
+        let mut stream = platform.subscribe_theme();
+
+        let first = futures::executor::block_on(stream.next()).unwrap();
+        *callbacks.theme.lock().expect("theme mutex poisoned") = HostTheme::Dark;
+        events.notify_theme_changed(v01::ThemeVariant::Dark);
+        let second = futures::executor::block_on(stream.next()).unwrap();
+
+        assert_eq!(first.unwrap(), v01::ThemeVariant::Light);
+        assert_eq!(second.unwrap(), v01::ThemeVariant::Dark);
+    }
+
+    #[test]
+    fn native_preimage_subscription_emits_current_then_notified_value() {
+        let (callbacks, events, platform) = event_platform();
+        let key = vec![7; 32];
+        callbacks
+            .preimages
+            .lock()
+            .expect("preimage map mutex poisoned")
+            .push((key.clone(), Some(vec![1, 2, 3])));
+        let mut stream = platform.lookup_preimage(key.clone());
+
+        let first = futures::executor::block_on(stream.next()).unwrap();
+        events.notify_preimage_changed(&key, Some(vec![4, 5, 6]));
+        let second = futures::executor::block_on(stream.next()).unwrap();
+
+        assert_eq!(first.unwrap(), Some(vec![1, 2, 3]));
+        assert_eq!(second.unwrap(), Some(vec![4, 5, 6]));
+    }
+
+    #[test]
+    fn native_chain_provider_forwards_send_response_and_close() {
+        let (callbacks, events, platform) = event_platform();
+        *callbacks.chain_id.lock().expect("chain id mutex poisoned") = Some(42);
+        let genesis = vec![9; 32];
+
+        let connection =
+            futures::executor::block_on(ChainProvider::connect(&platform, genesis.clone()))
+                .expect("chain connection should open");
+        connection.send(r#"{"jsonrpc":"2.0","id":1}"#.to_string());
+        let mut responses = connection.responses();
+        events.notify_chain_response(42, r#"{"jsonrpc":"2.0","id":1,"result":true}"#.to_string());
+        let response = futures::executor::block_on(responses.next()).unwrap();
+        drop(responses);
+        drop(connection);
+
+        assert_eq!(
+            callbacks
+                .chain_connects
+                .lock()
+                .expect("chain connects mutex poisoned")
+                .as_slice(),
+            &[genesis]
+        );
+        assert_eq!(
+            callbacks
+                .chain_sends
+                .lock()
+                .expect("chain sends mutex poisoned")
+                .as_slice(),
+            &[(42, r#"{"jsonrpc":"2.0","id":1}"#.to_string())]
+        );
+        assert_eq!(response, r#"{"jsonrpc":"2.0","id":1,"result":true}"#);
+        assert_eq!(
+            callbacks
+                .chain_closes
+                .lock()
+                .expect("chain closes mutex poisoned")
+                .as_slice(),
+            &[42]
+        );
+    }
+
+    #[test]
+    fn runtime_config_rejects_wrong_size_genesis_hash() {
+        let err = RuntimeConfig::try_from(NativeRuntimeConfig {
+            product_label: "app".to_string(),
+            product_id: "app.dot".to_string(),
+            site_id: "dot.li".to_string(),
+            host_name: "Polkadot Web".to_string(),
+            host_icon: Some("https://example.invalid/dotli.png".to_string()),
+            host_version: None,
+            platform_type: None,
+            platform_version: None,
+            people_chain_genesis_hash: vec![0; 31],
+            pairing_deeplink_scheme: NativePairingDeeplinkScheme::PolkadotApp,
+        })
+        .unwrap_err();
+
+        assert!(matches!(
+            err,
+            NativeRuntimeConfigError::InvalidPeopleChainGenesisHash { actual: 31 }
+        ));
+    }
+
+    #[test]
+    fn runtime_config_rejects_empty_required_fields() {
+        let err = RuntimeConfig::try_from(NativeRuntimeConfig {
+            product_label: "app".to_string(),
+            product_id: " ".to_string(),
+            site_id: "dot.li".to_string(),
+            host_name: "Polkadot Web".to_string(),
+            host_icon: Some("https://example.invalid/dotli.png".to_string()),
+            host_version: None,
+            platform_type: None,
+            platform_version: None,
+            people_chain_genesis_hash: vec![0; 32],
+            pairing_deeplink_scheme: NativePairingDeeplinkScheme::PolkadotApp,
+        })
+        .unwrap_err();
+
+        assert!(matches!(
+            err,
+            NativeRuntimeConfigError::EmptyField { field } if field == "product_id"
+        ));
+    }
+
+    #[test]
+    fn runtime_config_rejects_relative_host_icon() {
+        let err = RuntimeConfig::try_from(NativeRuntimeConfig {
+            product_label: "app".to_string(),
+            product_id: "app.dot".to_string(),
+            site_id: "dot.li".to_string(),
+            host_name: "Polkadot Web".to_string(),
+            host_icon: Some("/dotli.png".to_string()),
+            host_version: None,
+            platform_type: None,
+            platform_version: None,
+            people_chain_genesis_hash: vec![0; 32],
+            pairing_deeplink_scheme: NativePairingDeeplinkScheme::PolkadotApp,
+        })
+        .unwrap_err();
+
+        assert!(matches!(
+            err,
+            NativeRuntimeConfigError::InvalidHostIcon { .. }
+        ));
+    }
+
+    #[test]
+    fn runtime_config_rejects_non_https_host_icon() {
+        let err = RuntimeConfig::try_from(NativeRuntimeConfig {
+            product_label: "app".to_string(),
+            product_id: "app.dot".to_string(),
+            site_id: "dot.li".to_string(),
+            host_name: "Polkadot Web".to_string(),
+            host_icon: Some("http://localhost:3000/dotli.png".to_string()),
+            host_version: None,
+            platform_type: None,
+            platform_version: None,
+            people_chain_genesis_hash: vec![0; 32],
+            pairing_deeplink_scheme: NativePairingDeeplinkScheme::PolkadotApp,
+        })
+        .unwrap_err();
+
+        assert!(matches!(
+            err,
+            NativeRuntimeConfigError::InsecureHostIcon { scheme } if scheme == "http"
+        ));
+    }
+
+    /// Calling `start_ws_bridge` twice on the same `NativeTrUApiCore`
+    /// without an intervening `stop_ws_bridge` is a hard error. The bridge
+    /// is single-instance per core, so the second start must surface
+    /// `AlreadyRunning` rather than silently leaking a worker thread.
+    #[cfg(feature = "ws-bridge")]
+    #[test]
+    fn start_ws_bridge_twice_returns_already_running() {
+        struct Noop;
+        impl HostCallbacks for Noop {
+            fn on_core_log(&self, _marker: String, _detail: String) {}
+            fn navigate_to(&self, _url: String) -> Result<(), HostNavigateRejection> {
+                Ok(())
+            }
+            fn push_notification(&self, _payload: Vec<u8>) -> Result<u32, HostRejection> {
+                Ok(0)
+            }
+            fn cancel_notification(&self, _id: u32) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn device_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn remote_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn auth_state_changed(&self, _state: AuthState) {}
+            fn read_session(&self) -> Result<Option<Vec<u8>>, HostRejection> {
+                Ok(None)
+            }
+            fn write_session(&self, _value: Vec<u8>) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn clear_session(&self) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn chain_connect(&self, _genesis_hash: Vec<u8>) -> Result<Option<u32>, HostRejection> {
+                Ok(None)
+            }
+            fn chain_send(
+                &self,
+                _connection_id: u32,
+                _request: String,
+            ) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn chain_close(&self, _connection_id: u32) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn confirm_sign_payload(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_sign_raw(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_create_transaction(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_account_alias(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_resource_allocation(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_preimage_submit(&self, _size: u64) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, HostRejection> {
+                Ok(value)
+            }
+            fn lookup_preimage(&self, _key: Vec<u8>) -> Result<Option<Vec<u8>>, HostRejection> {
+                Ok(None)
+            }
+            fn current_theme(&self) -> Result<HostTheme, HostRejection> {
+                Ok(HostTheme::Light)
+            }
+            fn feature_supported(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn local_storage_read(
+                &self,
+                _key: String,
+            ) -> Result<Option<Vec<u8>>, HostStorageError> {
+                Ok(None)
+            }
+            fn local_storage_write(
+                &self,
+                _key: String,
+                _value: Vec<u8>,
+            ) -> Result<(), HostStorageError> {
+                Ok(())
+            }
+            fn local_storage_clear(&self, _key: String) -> Result<(), HostStorageError> {
+                Ok(())
+            }
+        }
+
+        let core = NativeTrUApiCore::with_runtime_config(
+            Box::new(Noop),
+            NativeRuntimeConfig {
+                product_label: "dotli".to_string(),
+                product_id: "dotli.dot".to_string(),
+                site_id: "dot.li".to_string(),
+                host_name: "Polkadot Web".to_string(),
+                host_icon: Some("https://dot.li/dotli.png".to_string()),
+                host_version: None,
+                platform_type: None,
+                platform_version: None,
+                people_chain_genesis_hash: [0xa2; 32].to_vec(),
+                pairing_deeplink_scheme: NativePairingDeeplinkScheme::PolkadotApp,
+            },
+        )
+        .expect("runtime config should be valid");
+        let _first = core.start_ws_bridge(0).expect("first start must succeed");
+        let err = core
+            .start_ws_bridge(0)
+            .expect_err("second start must error");
+        assert!(matches!(err, WsBridgeStartError::AlreadyRunning));
+        core.stop_ws_bridge();
+    }
+
+    /// A permission callback that blocks awaiting the user's decision runs on
+    /// the blocking pool, so an unrelated request on the same connection
+    /// still round-trips while the callback is blocked.
+    #[cfg(feature = "ws-bridge")]
+    #[test]
+    fn blocked_permission_callback_does_not_stall_bridge() {
+        use std::sync::atomic::{AtomicBool, Ordering};
+
+        use futures::SinkExt;
+        use parity_scale_codec::Decode;
+        use tokio_tungstenite::tungstenite::Message as WsMessage;
+        use truapi::versioned::permissions::HostDevicePermissionRequest;
+        use truapi_platform::PairingDeeplinkScheme;
+
+        use crate::frame::{Payload, ProtocolMessage, request_ids};
+
+        /// `device_permission` blocks until the test sends on `release`;
+        /// every other callback is a trivial success.
+        struct GatedPermissionCallbacks {
+            permission_entered: Arc<AtomicBool>,
+            release: Mutex<std::sync::mpsc::Receiver<()>>,
+        }
+
+        impl HostCallbacks for GatedPermissionCallbacks {
+            fn on_core_log(&self, _marker: String, _detail: String) {}
+            fn navigate_to(&self, _url: String) -> Result<(), HostNavigateRejection> {
+                Ok(())
+            }
+            fn push_notification(&self, _payload: Vec<u8>) -> Result<u32, HostRejection> {
+                Ok(0)
+            }
+            fn cancel_notification(&self, _id: u32) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn device_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                self.permission_entered.store(true, Ordering::SeqCst);
+                self.release
+                    .lock()
+                    .expect("release receiver mutex poisoned")
+                    .recv()
+                    .expect("release signal");
+                Ok(true)
+            }
+            fn remote_permission(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn auth_state_changed(&self, _state: AuthState) {}
+            fn read_session(&self) -> Result<Option<Vec<u8>>, HostRejection> {
+                Ok(None)
+            }
+            fn write_session(&self, _value: Vec<u8>) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn clear_session(&self) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn chain_connect(&self, _genesis_hash: Vec<u8>) -> Result<Option<u32>, HostRejection> {
+                Ok(None)
+            }
+            fn chain_send(
+                &self,
+                _connection_id: u32,
+                _request: String,
+            ) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn chain_close(&self, _connection_id: u32) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn confirm_sign_payload(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_sign_raw(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_create_transaction(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_account_alias(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_resource_allocation(&self, _review: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(false)
+            }
+            fn confirm_preimage_submit(&self, _size: u64) -> Result<(), HostRejection> {
+                Ok(())
+            }
+            fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, HostRejection> {
+                Ok(value)
+            }
+            fn lookup_preimage(&self, _key: Vec<u8>) -> Result<Option<Vec<u8>>, HostRejection> {
+                Ok(None)
+            }
+            fn current_theme(&self) -> Result<HostTheme, HostRejection> {
+                Ok(HostTheme::Light)
+            }
+            fn feature_supported(&self, _request: Vec<u8>) -> Result<bool, HostRejection> {
+                Ok(true)
+            }
+            fn local_storage_read(
+                &self,
+                _key: String,
+            ) -> Result<Option<Vec<u8>>, HostStorageError> {
+                Ok(None)
+            }
+            fn local_storage_write(
+                &self,
+                _key: String,
+                _value: Vec<u8>,
+            ) -> Result<(), HostStorageError> {
+                Ok(())
+            }
+            fn local_storage_clear(&self, _key: String) -> Result<(), HostStorageError> {
+                Ok(())
+            }
+        }
+
+        let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
+        let permission_entered = Arc::new(AtomicBool::new(false));
+        let callbacks: Arc<dyn HostCallbacks> = Arc::new(GatedPermissionCallbacks {
+            permission_entered: permission_entered.clone(),
+            release: Mutex::new(release_rx),
+        });
+        let events = Arc::new(NativeEventBus::default());
+        let platform = Arc::new(CallbackPlatform { callbacks, events });
+        let core = Arc::new(TrUApiCore::from_platform_with_config(
+            platform,
+            RuntimeConfig {
+                product_label: "dotli".to_string(),
+                product_id: "dotli.dot".to_string(),
+                site_id: "dot.li".to_string(),
+                host_name: "Polkadot Web".to_string(),
+                host_icon: Some("https://dot.li/dotli.png".to_string()),
+                host_version: None,
+                platform_type: None,
+                platform_version: None,
+                people_chain_genesis_hash: [0xa2; 32],
+                pairing_deeplink_scheme: PairingDeeplinkScheme::PolkadotApp,
+            },
+            crate::subscription::thread_per_subscription_spawner(),
+        ));
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        let url = format!("ws://127.0.0.1:{}/?t={}", endpoint.port, endpoint.token);
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+
+        let permission_ids =
+            request_ids("permissions_request_device_permission").expect("known request method");
+        let feature_ids = request_ids("system_feature_supported").expect("known request method");
+        let (feature_response, permission_response) = rt.block_on(async {
+            let (mut ws, _) = tokio_tungstenite::connect_async(&url).await.expect("dial");
+
+            let permission_frame = ProtocolMessage {
+                request_id: "p:permission".into(),
+                payload: Payload {
+                    id: permission_ids.request_id,
+                    value: HostDevicePermissionRequest::V1(
+                        v01::HostDevicePermissionRequest::Camera,
+                    )
+                    .encode(),
+                },
+            };
+            ws.send(WsMessage::Binary(permission_frame.encode()))
+                .await
+                .expect("send device permission");
+
+            // Wait until the permission callback is blocked on the decision.
+            for _ in 0..1000 {
+                if permission_entered.load(Ordering::SeqCst) {
+                    break;
+                }
+                tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+            }
+            assert!(
+                permission_entered.load(Ordering::SeqCst),
+                "permission callback was not invoked"
+            );
+
+            let feature_frame = ProtocolMessage {
+                request_id: "p:feature".into(),
+                payload: Payload {
+                    id: feature_ids.request_id,
+                    value: HostFeatureSupportedRequest::V1(
+                        v01::HostFeatureSupportedRequest::Chain {
+                            genesis_hash: vec![0u8; 32],
+                        },
+                    )
+                    .encode(),
+                },
+            };
+            ws.send(WsMessage::Binary(feature_frame.encode()))
+                .await
+                .expect("send feature_supported");
+
+            let feature_response =
+                tokio::time::timeout(std::time::Duration::from_secs(10), async {
+                    loop {
+                        match ws.next().await {
+                            Some(Ok(WsMessage::Binary(bytes))) => {
+                                break ProtocolMessage::decode(&mut &bytes[..])
+                                    .expect("decode response");
+                            }
+                            Some(Ok(_)) => continue,
+                            Some(Err(err)) => panic!("ws error: {err}"),
+                            None => panic!("connection closed before response"),
+                        }
+                    }
+                })
+                .await
+                .expect("feature_supported must answer while the permission is blocked");
+
+            release_tx.send(()).expect("release permission callback");
+            let permission_response =
+                tokio::time::timeout(std::time::Duration::from_secs(10), async {
+                    loop {
+                        match ws.next().await {
+                            Some(Ok(WsMessage::Binary(bytes))) => {
+                                break ProtocolMessage::decode(&mut &bytes[..])
+                                    .expect("decode response");
+                            }
+                            Some(Ok(_)) => continue,
+                            Some(Err(err)) => panic!("ws error: {err}"),
+                            None => panic!("connection closed before response"),
+                        }
+                    }
+                })
+                .await
+                .expect("released permission must answer");
+
+            (feature_response, permission_response)
+        });
+
+        assert_eq!(feature_response.request_id, "p:feature");
+        assert_eq!(feature_response.payload.id, feature_ids.response_id);
+
+        assert_eq!(permission_response.request_id, "p:permission");
+        assert_eq!(permission_response.payload.id, permission_ids.response_id);
+        // [Ok 0x00][V1 0x00][granted=1]
+        assert_eq!(permission_response.payload.value, vec![0x00, 0x00, 0x01]);
+
+        bridge.stop();
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime.rs b/rust/crates/truapi-server/src/runtime.rs
new file mode 100644
index 00000000..7aa00c7a
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime.rs
@@ -0,0 +1,3244 @@
+//! `PlatformRuntimeHost<P>` adapts a [`truapi_platform::Platform`] into the
+//! typed `truapi::api::*` host traits the generated dispatcher routes to.
+//!
+//! Most methods are straight delegations to the platform; the rest carry
+//! host-agnostic logic owned by the core (the chainHead-v1 runtime behind
+//! the Chain surface, `dotns` URL parsing for `navigate_to`, and the
+//! permission cache layer). Methods with no platform backing return
+//! `CallError::unavailable()`.
+
+pub(crate) mod auth_state;
+mod identity;
+pub(crate) mod sso_pairing;
+pub(crate) mod sso_remote;
+pub(crate) mod statement_store;
+
+use std::sync::Arc;
+
+use crate::chain_runtime::{
+    ChainRuntime, RuntimeChainProvider, RuntimeFailure, RuntimeFailureKind,
+};
+use crate::host_logic::dotns::{NavigateDecision, parse_navigate};
+use crate::host_logic::entropy::derive_product_entropy_from_source;
+use crate::host_logic::features::feature_supported;
+use crate::host_logic::permissions::{Decision, PermissionsService};
+use crate::host_logic::product_account::{
+    derive_product_public_key, is_product_identifier, normalize_product_identifier,
+    product_public_key_to_address,
+};
+use crate::host_logic::session::{
+    SessionInfo, SessionState, decode_persisted_session, encode_persisted_session,
+};
+use crate::host_logic::sso_messages::{
+    OnExistingAllowancePolicy, SsoAllocationOutcome, SsoRemoteResponse, alias_request_message,
+    create_transaction_message, resource_allocation_message, sign_payload_message,
+    sign_raw_message,
+};
+use crate::subscription::Spawner;
+use auth_state::AuthStateMachine;
+use identity::resolve_session_identity_with_chain;
+use sso_pairing::PAIRING_DEVICE_IDENTITY_STORAGE_KEY;
+use sso_remote::{SSO_LOCAL_DISCONNECT_REASON, SessionDisconnects, sso_message_id};
+
+use futures::StreamExt;
+use parity_scale_codec::Encode;
+use tracing::{debug, info, instrument};
+use truapi::api::{
+    Account, Chain, Chat, CoinPayment, Entropy, LocalStorage, Notifications, Payment, Permissions,
+    Preimage, ResourceAllocation, Signing, System, Theme,
+};
+use truapi::v01;
+use truapi::versioned::account::{
+    HostAccountConnectionStatusSubscribeItem, HostAccountCreateProofError,
+    HostAccountCreateProofRequest, HostAccountCreateProofResponse, HostAccountGetAliasError,
+    HostAccountGetAliasRequest, HostAccountGetAliasResponse, HostAccountGetError,
+    HostAccountGetRequest, HostAccountGetResponse, HostGetLegacyAccountsError,
+    HostGetLegacyAccountsRequest, HostGetLegacyAccountsResponse, HostGetUserIdError,
+    HostGetUserIdRequest, HostGetUserIdResponse, HostRequestLoginError, HostRequestLoginRequest,
+    HostRequestLoginResponse,
+};
+use truapi::versioned::chain::{
+    RemoteChainHeadBodyError, RemoteChainHeadBodyRequest, RemoteChainHeadBodyResponse,
+    RemoteChainHeadCallError, RemoteChainHeadCallRequest, RemoteChainHeadCallResponse,
+    RemoteChainHeadContinueError, RemoteChainHeadContinueRequest, RemoteChainHeadContinueResponse,
+    RemoteChainHeadFollowItem, RemoteChainHeadFollowRequest, RemoteChainHeadHeaderError,
+    RemoteChainHeadHeaderRequest, RemoteChainHeadHeaderResponse, RemoteChainHeadStopOperationError,
+    RemoteChainHeadStopOperationRequest, RemoteChainHeadStopOperationResponse,
+    RemoteChainHeadStorageError, RemoteChainHeadStorageRequest, RemoteChainHeadStorageResponse,
+    RemoteChainHeadUnpinError, RemoteChainHeadUnpinRequest, RemoteChainHeadUnpinResponse,
+    RemoteChainSpecChainNameError, RemoteChainSpecChainNameRequest,
+    RemoteChainSpecChainNameResponse, RemoteChainSpecGenesisHashError,
+    RemoteChainSpecGenesisHashRequest, RemoteChainSpecGenesisHashResponse,
+    RemoteChainSpecPropertiesError, RemoteChainSpecPropertiesRequest,
+    RemoteChainSpecPropertiesResponse, RemoteChainTransactionBroadcastError,
+    RemoteChainTransactionBroadcastRequest, RemoteChainTransactionBroadcastResponse,
+    RemoteChainTransactionStopError, RemoteChainTransactionStopRequest,
+    RemoteChainTransactionStopResponse,
+};
+use truapi::versioned::entropy::{
+    HostDeriveEntropyError, HostDeriveEntropyRequest, HostDeriveEntropyResponse,
+};
+use truapi::versioned::local_storage::{
+    HostLocalStorageClearError, HostLocalStorageClearRequest, HostLocalStorageClearResponse,
+    HostLocalStorageReadError, HostLocalStorageReadRequest, HostLocalStorageReadResponse,
+    HostLocalStorageWriteError, HostLocalStorageWriteRequest, HostLocalStorageWriteResponse,
+};
+use truapi::versioned::notifications::{
+    HostPushNotificationCancelError, HostPushNotificationCancelRequest,
+    HostPushNotificationCancelResponse, HostPushNotificationError, HostPushNotificationRequest,
+    HostPushNotificationResponse,
+};
+use truapi::versioned::payment::{
+    HostPaymentBalanceSubscribeError, HostPaymentBalanceSubscribeItem,
+    HostPaymentBalanceSubscribeRequest, HostPaymentError, HostPaymentRequest, HostPaymentResponse,
+    HostPaymentStatusSubscribeError, HostPaymentStatusSubscribeItem,
+    HostPaymentStatusSubscribeRequest, HostPaymentTopUpError, HostPaymentTopUpRequest,
+    HostPaymentTopUpResponse,
+};
+use truapi::versioned::permissions::{
+    HostDevicePermissionError, HostDevicePermissionRequest, HostDevicePermissionResponse,
+    RemotePermissionError, RemotePermissionRequest, RemotePermissionResponse,
+};
+use truapi::versioned::preimage::{
+    RemotePreimageLookupSubscribeItem, RemotePreimageLookupSubscribeRequest,
+    RemotePreimageSubmitError, RemotePreimageSubmitRequest, RemotePreimageSubmitResponse,
+};
+use truapi::versioned::resource_allocation::{
+    HostRequestResourceAllocationError, HostRequestResourceAllocationRequest,
+    HostRequestResourceAllocationResponse,
+};
+use truapi::versioned::signing::{
+    HostCreateTransactionError, HostCreateTransactionRequest, HostCreateTransactionResponse,
+    HostCreateTransactionWithLegacyAccountError, HostCreateTransactionWithLegacyAccountRequest,
+    HostCreateTransactionWithLegacyAccountResponse, HostSignPayloadError, HostSignPayloadRequest,
+    HostSignPayloadResponse, HostSignPayloadWithLegacyAccountError,
+    HostSignPayloadWithLegacyAccountRequest, HostSignPayloadWithLegacyAccountResponse,
+    HostSignRawError, HostSignRawRequest, HostSignRawResponse, HostSignRawWithLegacyAccountError,
+    HostSignRawWithLegacyAccountRequest, HostSignRawWithLegacyAccountResponse,
+};
+use truapi::versioned::system::{
+    HostFeatureSupportedError, HostFeatureSupportedRequest, HostFeatureSupportedResponse,
+    HostNavigateToError, HostNavigateToRequest, HostNavigateToResponse,
+};
+use truapi::versioned::theme::HostThemeSubscribeItem;
+use truapi::{CallContext, CallError, Subscription};
+use truapi_platform::{
+    ChainProvider as PlatformChainProvider, JsonRpcConnection, Navigation as PlatformNavigation,
+    Notifications as PlatformNotifications, Platform, PreimageHost as PlatformPreimageHost,
+    RuntimeConfig, SessionStore as PlatformSessionStore, SessionUiInfo, Storage as PlatformStorage,
+    ThemeHost as PlatformThemeHost, UserConfirmation as PlatformUserConfirmation,
+};
+
+/// Adapter that exposes a [`truapi_platform::Platform`] through the
+/// `truapi::api::*` trait set the generated dispatcher routes to.
+pub struct PlatformRuntimeHost<P> {
+    platform: Arc<P>,
+    runtime_config: RuntimeConfig,
+    /// chainHead-v1 state machine. The provider adapter forwards
+    /// [`PlatformChainProvider::connect`] into the json-rpc layer.
+    chain: ChainRuntime,
+    /// Currently-paired session, pushed by the host through a side channel.
+    /// Account-management subscriptions read from this in lieu of round-tripping
+    /// a callback on every connection-status query.
+    session_state: Arc<SessionState>,
+    session_disconnects: Arc<SessionDisconnects>,
+    /// Auth UI state machine; the single funnel for `auth_state_changed`.
+    auth_state: AuthStateMachine<P>,
+}
+
+impl<P> PlatformRuntimeHost<P> {
+    /// Wrap a platform implementation. The runtime takes ownership via `Arc`.
+    /// `spawner` is used by the embedded chain runtime to drive json-rpc
+    /// response loops and follow-setup futures.
+    pub fn new(platform: Arc<P>, runtime_config: RuntimeConfig, spawner: Spawner) -> Self
+    where
+        P: Platform + 'static,
+    {
+        let chain_provider = Self::chain_provider(platform.clone());
+        Self {
+            auth_state: AuthStateMachine::new(platform.clone()),
+            platform,
+            runtime_config,
+            chain: ChainRuntime::new(chain_provider, spawner),
+            session_state: SessionState::new(),
+            session_disconnects: Arc::new(SessionDisconnects::default()),
+        }
+    }
+
+    /// Compatibility constructor used only by tests that do not exercise
+    /// product-scoped behavior.
+    #[cfg(test)]
+    fn new_compat(platform: Arc<P>, spawner: Spawner) -> Self
+    where
+        P: Platform + 'static,
+    {
+        Self::new(
+            platform,
+            RuntimeConfig {
+                product_label: "unknown".to_string(),
+                product_id: "unknown.dot".to_string(),
+                site_id: "test".to_string(),
+                host_name: "Polkadot Web".to_string(),
+                host_icon: Some("https://example.invalid/dotli.png".to_string()),
+                host_version: None,
+                platform_type: None,
+                platform_version: None,
+                people_chain_genesis_hash: [0; 32],
+                pairing_deeplink_scheme: truapi_platform::PairingDeeplinkScheme::PolkadotApp,
+            },
+            spawner,
+        )
+    }
+
+    /// Chain provider backing the chainHead-v1 runtime. Without the `smoldot`
+    /// feature, chain access routes through the platform's `ChainProvider`.
+    #[cfg(not(feature = "smoldot"))]
+    fn chain_provider(platform: Arc<P>) -> Arc<dyn RuntimeChainProvider>
+    where
+        P: Platform + 'static,
+    {
+        Arc::new(PlatformChainRuntimeProvider { platform })
+    }
+
+    /// With the `smoldot` feature, the embedded light client owns chain
+    /// access, falling back to the platform's `ChainProvider` only if the
+    /// client fails to start.
+    #[cfg(feature = "smoldot")]
+    fn chain_provider(platform: Arc<P>) -> Arc<dyn RuntimeChainProvider>
+    where
+        P: Platform + 'static,
+    {
+        match crate::smoldot_provider::SmoldotChainProvider::with_bundled_specs() {
+            Ok(provider) => Arc::new(provider),
+            Err(_err) => Arc::new(PlatformChainRuntimeProvider { platform }),
+        }
+    }
+
+    /// Clone of the shared session-state holder used by core subscriptions
+    /// and tests. Real host lifecycle flows through `SessionStore` and
+    /// `disconnect`.
+    pub fn session_state(&self) -> Arc<SessionState> {
+        self.session_state.clone()
+    }
+
+    /// Start syncing the in-memory session from the host-global session store.
+    /// The store emits coarse ticks; each tick triggers a fresh read so same-
+    /// runtime writes and cross-runtime logout/re-pair take the same path.
+    #[instrument(skip_all, fields(runtime.method = "session_store.sync"))]
+    pub(crate) fn start_session_store_sync(&self, spawner: Spawner)
+    where
+        P: Platform + 'static,
+    {
+        let platform = self.platform.clone();
+        let chain = self.chain.clone();
+        let runtime_config = self.runtime_config.clone();
+        let session_state = self.session_state.clone();
+        let auth_state = self.auth_state.clone();
+        spawner(Box::pin(async move {
+            let mut ticks = PlatformSessionStore::subscribe_session_store(platform.as_ref());
+            // Clearing the store can itself notify this subscription; clear at
+            // most once per read-error streak so a persistently failing read
+            // cannot spin the loop through its own clear notifications.
+            let mut cleared_after_read_error = false;
+            while let Some(tick) = ticks.next().await {
+                if tick.is_err() {
+                    continue;
+                }
+                match PlatformSessionStore::read_session(platform.as_ref()).await {
+                    Ok(Some(blob)) => {
+                        cleared_after_read_error = false;
+                        match decode_persisted_session(&blob) {
+                            Ok(session) => {
+                                let resolved = resolve_session_identity_with_chain(
+                                    &chain,
+                                    runtime_config.people_chain_genesis_hash,
+                                    session,
+                                )
+                                .await;
+                                if encode_persisted_session(&resolved) != blob {
+                                    let _ = PlatformSessionStore::write_session(
+                                        platform.as_ref(),
+                                        encode_persisted_session(&resolved),
+                                    )
+                                    .await;
+                                }
+                                auth_state.connected(&connected_session_ui_info(&resolved));
+                                session_state.set_session(resolved);
+                            }
+                            Err(_) => {
+                                session_state.clear_session();
+                                let _ =
+                                    PlatformSessionStore::clear_session(platform.as_ref()).await;
+                                auth_state.store_disconnected();
+                            }
+                        }
+                    }
+                    Ok(None) => {
+                        cleared_after_read_error = false;
+                        session_state.clear_session();
+                        auth_state.store_disconnected();
+                    }
+                    Err(_) => {
+                        session_state.clear_session();
+                        auth_state.store_disconnected();
+                        if !cleared_after_read_error {
+                            cleared_after_read_error = true;
+                            let _ = PlatformSessionStore::clear_session(platform.as_ref()).await;
+                        }
+                    }
+                }
+            }
+        }));
+    }
+
+    /// Core-owned logout/disconnect path. It best-effort notifies the SSO
+    /// peer, then clears in-memory and persisted session state regardless of
+    /// any transport failure.
+    #[instrument(skip_all, fields(runtime.method = "account.disconnect"))]
+    pub(crate) async fn disconnect(&self)
+    where
+        P: Platform + 'static,
+    {
+        self.cancel_login();
+        self.session_disconnects.notify(SSO_LOCAL_DISCONNECT_REASON);
+        let session = self.session_state.current();
+        self.clear_disconnected_session().await;
+        if let Some(session) = session.as_ref() {
+            let _ = self.submit_sso_disconnected(session).await;
+        }
+    }
+
+    /// Cancel any in-flight `request_login` pairing: the host UI gets a
+    /// `Disconnected` state immediately and the login flow resolves to
+    /// `Rejected`. A no-op when no login is in progress.
+    #[instrument(skip_all, fields(runtime.method = "account.cancel_login"))]
+    pub(crate) fn cancel_login(&self)
+    where
+        P: Platform + 'static,
+    {
+        self.auth_state.login_cancelled();
+    }
+
+    /// Static product/host configuration for this runtime instance.
+    pub fn runtime_config(&self) -> &RuntimeConfig {
+        &self.runtime_config
+    }
+
+    fn is_product_account_valid_for_caller(&self, dot_ns_identifier: &str) -> bool {
+        let dot_ns_identifier = normalize_product_identifier(dot_ns_identifier);
+        let product_id = normalize_product_identifier(&self.runtime_config.product_id);
+        if self.runtime_config.product_label.starts_with("localhost:") {
+            is_product_identifier(&dot_ns_identifier)
+        } else {
+            dot_ns_identifier == product_id
+        }
+    }
+
+    fn normalize_product_account_id(
+        product_account_id: v01::ProductAccountId,
+    ) -> v01::ProductAccountId {
+        v01::ProductAccountId {
+            dot_ns_identifier: normalize_product_identifier(&product_account_id.dot_ns_identifier),
+            derivation_index: product_account_id.derivation_index,
+        }
+    }
+
+    fn product_id(&self) -> String {
+        normalize_product_identifier(&self.runtime_config.product_id)
+    }
+
+    fn legacy_slot_zero_public_key(&self, session: &SessionInfo) -> Result<[u8; 32], String> {
+        derive_product_public_key(session.public_key, &self.product_id(), 0)
+            .map_err(|err| err.to_string())
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "session_store.clear_disconnected"))]
+    async fn clear_disconnected_session(&self)
+    where
+        P: Platform + 'static,
+    {
+        debug!("clearing disconnected SSO session state");
+        self.session_state.clear_session();
+        let _ = PlatformSessionStore::clear_session(self.platform.as_ref()).await;
+        self.auth_state.store_disconnected();
+        let _ = PlatformStorage::clear(
+            self.platform.as_ref(),
+            PAIRING_DEVICE_IDENTITY_STORAGE_KEY.to_string(),
+        )
+        .await;
+    }
+}
+
+impl<P> PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "permissions.chain_submit_decision"))]
+    async fn chain_submit_decision(&self) -> Result<Decision, String> {
+        let service = PermissionsService::new(self.platform.as_ref(), self.platform.as_ref());
+        service
+            .check_or_prompt_remote(v01::RemotePermissionRequest {
+                permission: v01::RemotePermission::ChainSubmit,
+            })
+            .await
+            .map_err(|err| format!("permission storage failed: {err:?}"))
+    }
+
+    async fn require_chain_submit<E>(&self, denied_error: E) -> Result<(), CallError<E>> {
+        match self.chain_submit_decision().await {
+            Ok(Decision::Granted) => Ok(()),
+            Ok(Decision::Denied) => Err(CallError::Domain(denied_error)),
+            Err(reason) => Err(CallError::HostFailure { reason }),
+        }
+    }
+
+    fn validate_legacy_address_signer(
+        &self,
+        session: &SessionInfo,
+        signer: &str,
+    ) -> Result<(), v01::HostSignPayloadError> {
+        let public_key = self
+            .legacy_slot_zero_public_key(session)
+            .map_err(|reason| v01::HostSignPayloadError::Unknown { reason })?;
+        let expected = product_public_key_to_address(public_key);
+        if expected == signer {
+            Ok(())
+        } else {
+            Err(v01::HostSignPayloadError::Unknown {
+                reason: "Account can't be derived from product account id".to_string(),
+            })
+        }
+    }
+
+    fn validate_legacy_public_key_signer(
+        &self,
+        session: &SessionInfo,
+        signer: [u8; 32],
+    ) -> Result<(), v01::HostCreateTransactionError> {
+        let public_key = self
+            .legacy_slot_zero_public_key(session)
+            .map_err(|reason| v01::HostCreateTransactionError::Unknown { reason })?;
+        if public_key == signer {
+            Ok(())
+        } else {
+            Err(v01::HostCreateTransactionError::Unknown {
+                reason: "Account can't be derived from product account id".to_string(),
+            })
+        }
+    }
+}
+
+/// Adapter from `truapi_platform::ChainProvider` into the
+/// [`RuntimeChainProvider`] surface the chain runtime expects.
+/// Reuses the platform-supplied json-rpc connection and converts the
+/// platform `GenericError` into a `RuntimeFailure::Unavailable`.
+struct PlatformChainRuntimeProvider<P> {
+    platform: Arc<P>,
+}
+
+#[async_trait::async_trait]
+impl<P> RuntimeChainProvider for PlatformChainRuntimeProvider<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "chain.provider.connect"))]
+    async fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure> {
+        PlatformChainProvider::connect(self.platform.as_ref(), genesis_hash)
+            .await
+            .map(Arc::from)
+            .map_err(|_| RuntimeFailure::unavailable("remote_chain_connect"))
+    }
+}
+
+fn runtime_failure_to_call_error<E>(failure: RuntimeFailure) -> CallError<E> {
+    match failure.kind() {
+        RuntimeFailureKind::Unavailable => CallError::HostFailure {
+            reason: failure.reason(),
+        },
+        RuntimeFailureKind::HostFailure => CallError::HostFailure {
+            reason: failure.reason(),
+        },
+    }
+}
+
+// ---------------------------------------------------------------------------
+// System
+// ---------------------------------------------------------------------------
+
+impl<P> System for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "system.feature_supported"))]
+    async fn feature_supported(
+        &self,
+        _cx: &CallContext,
+        request: HostFeatureSupportedRequest,
+    ) -> Result<HostFeatureSupportedResponse, CallError<HostFeatureSupportedError>> {
+        feature_supported(self.platform.as_ref(), request)
+            .await
+            .map_err(|err| CallError::Domain(HostFeatureSupportedError::V1(err)))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "system.navigate_to"))]
+    async fn navigate_to(
+        &self,
+        _cx: &CallContext,
+        request: HostNavigateToRequest,
+    ) -> Result<HostNavigateToResponse, CallError<HostNavigateToError>> {
+        let HostNavigateToRequest::V1(v01::HostNavigateToRequest { url }) = request;
+        let resolved = match parse_navigate(&url) {
+            NavigateDecision::Reject { reason } => {
+                return Err(CallError::Domain(HostNavigateToError::V1(
+                    v01::HostNavigateToError::Unknown { reason },
+                )));
+            }
+            decision => match decision.canonical_url() {
+                Some(url) => url,
+                None => {
+                    return Err(CallError::HostFailure {
+                        reason: "navigate decision produced no canonical URL".to_string(),
+                    });
+                }
+            },
+        };
+        PlatformNavigation::navigate_to(self.platform.as_ref(), resolved)
+            .await
+            .map(|()| HostNavigateToResponse::V1)
+            .map_err(|err| CallError::Domain(HostNavigateToError::V1(err)))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+
+impl<P> Permissions for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "permissions.request_device_permission"))]
+    async fn request_device_permission(
+        &self,
+        _cx: &CallContext,
+        request: HostDevicePermissionRequest,
+    ) -> Result<HostDevicePermissionResponse, CallError<HostDevicePermissionError>> {
+        let HostDevicePermissionRequest::V1(inner) = request;
+        let service = PermissionsService::new(self.platform.as_ref(), self.platform.as_ref());
+        match service.check_or_prompt_device(inner).await {
+            Ok(decision) => Ok(HostDevicePermissionResponse::V1(
+                v01::HostDevicePermissionResponse {
+                    granted: decision == Decision::Granted,
+                },
+            )),
+            Err(err) => Err(CallError::HostFailure {
+                reason: format!("permission storage failed: {err:?}"),
+            }),
+        }
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "permissions.request_remote_permission"))]
+    async fn request_remote_permission(
+        &self,
+        _cx: &CallContext,
+        request: RemotePermissionRequest,
+    ) -> Result<RemotePermissionResponse, CallError<RemotePermissionError>> {
+        let RemotePermissionRequest::V1(inner) = request;
+        let service = PermissionsService::new(self.platform.as_ref(), self.platform.as_ref());
+        match service.check_or_prompt_remote(inner).await {
+            Ok(decision) => Ok(RemotePermissionResponse::V1(
+                v01::RemotePermissionResponse {
+                    granted: decision == Decision::Granted,
+                },
+            )),
+            Err(err) => Err(CallError::HostFailure {
+                reason: format!("permission storage failed: {err:?}"),
+            }),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// LocalStorage
+// ---------------------------------------------------------------------------
+
+impl<P> LocalStorage for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "local_storage.read"))]
+    async fn read(
+        &self,
+        _cx: &CallContext,
+        request: HostLocalStorageReadRequest,
+    ) -> Result<HostLocalStorageReadResponse, CallError<HostLocalStorageReadError>> {
+        let HostLocalStorageReadRequest::V1(v01::HostLocalStorageReadRequest { key }) = request;
+        PlatformStorage::read(self.platform.as_ref(), key)
+            .await
+            .map(|value| {
+                HostLocalStorageReadResponse::V1(v01::HostLocalStorageReadResponse { value })
+            })
+            .map_err(|err| CallError::Domain(HostLocalStorageReadError::V1(err)))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "local_storage.write"))]
+    async fn write(
+        &self,
+        _cx: &CallContext,
+        request: HostLocalStorageWriteRequest,
+    ) -> Result<HostLocalStorageWriteResponse, CallError<HostLocalStorageWriteError>> {
+        let HostLocalStorageWriteRequest::V1(v01::HostLocalStorageWriteRequest { key, value }) =
+            request;
+        PlatformStorage::write(self.platform.as_ref(), key, value)
+            .await
+            .map(|()| HostLocalStorageWriteResponse::V1)
+            .map_err(|err| CallError::Domain(HostLocalStorageWriteError::V1(err)))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "local_storage.clear"))]
+    async fn clear(
+        &self,
+        _cx: &CallContext,
+        request: HostLocalStorageClearRequest,
+    ) -> Result<HostLocalStorageClearResponse, CallError<HostLocalStorageClearError>> {
+        let HostLocalStorageClearRequest::V1(v01::HostLocalStorageClearRequest { key }) = request;
+        PlatformStorage::clear(self.platform.as_ref(), key)
+            .await
+            .map(|()| HostLocalStorageClearResponse::V1)
+            .map_err(|err| CallError::Domain(HostLocalStorageClearError::V1(err)))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Account
+// ---------------------------------------------------------------------------
+//
+// Account-management flows live in the Rust core itself, backed by the shared
+// session state and, for alias/proof/login success paths, the SSO service.
+
+impl<P> Account for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "account.get_account"))]
+    async fn get_account(
+        &self,
+        _cx: &CallContext,
+        request: HostAccountGetRequest,
+    ) -> Result<HostAccountGetResponse, CallError<HostAccountGetError>> {
+        let HostAccountGetRequest::V1(v01::HostAccountGetRequest { product_account_id }) = request;
+        let product_account_id = Self::normalize_product_account_id(product_account_id);
+
+        if !is_product_identifier(&product_account_id.dot_ns_identifier) {
+            return Err(CallError::Domain(HostAccountGetError::V1(
+                v01::HostAccountGetError::DomainNotValid,
+            )));
+        }
+
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostAccountGetError::V1(
+                v01::HostAccountGetError::NotConnected,
+            )));
+        };
+
+        let public_key = derive_product_public_key(
+            session.public_key,
+            &product_account_id.dot_ns_identifier,
+            product_account_id.derivation_index,
+        )
+        .map_err(|err| {
+            CallError::Domain(HostAccountGetError::V1(v01::HostAccountGetError::Unknown {
+                reason: err.to_string(),
+            }))
+        })?;
+
+        Ok(HostAccountGetResponse::V1(v01::HostAccountGetResponse {
+            account: v01::ProductAccount {
+                public_key: public_key.to_vec(),
+            },
+        }))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.get_account_alias"))]
+    async fn get_account_alias(
+        &self,
+        cx: &CallContext,
+        request: HostAccountGetAliasRequest,
+    ) -> Result<HostAccountGetAliasResponse, CallError<HostAccountGetAliasError>> {
+        let HostAccountGetAliasRequest::V1(v01::HostAccountGetAliasRequest { product_account_id }) =
+            request;
+        let product_account_id = Self::normalize_product_account_id(product_account_id);
+
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::NotConnected,
+            )));
+        };
+
+        if !is_product_identifier(&product_account_id.dot_ns_identifier) {
+            return Err(CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::DomainNotValid,
+            )));
+        }
+
+        let product_id = self.product_id();
+        if product_account_id.dot_ns_identifier != product_id {
+            let confirmed = PlatformUserConfirmation::confirm_account_alias(
+                self.platform.as_ref(),
+                (
+                    product_id.clone(),
+                    product_account_id.dot_ns_identifier.clone(),
+                )
+                    .encode(),
+            )
+            .await
+            .map_err(|err| CallError::HostFailure {
+                reason: format!("account alias confirmation failed: {err:?}"),
+            })?;
+            if !confirmed {
+                return Err(CallError::Domain(HostAccountGetAliasError::V1(
+                    v01::HostAccountGetError::Rejected,
+                )));
+            }
+        }
+
+        let message_id = sso_message_id(cx, "account-alias");
+        let message = alias_request_message(message_id.clone(), product_account_id, product_id);
+        let response = self
+            .submit_sso_remote_message_without_timeout(cx, &session, "account-alias", message)
+            .await
+            .map_err(|reason| {
+                CallError::Domain(HostAccountGetAliasError::V1(
+                    v01::HostAccountGetError::Unknown { reason },
+                ))
+            })?;
+        let SsoRemoteResponse::RingVrfAlias(response) = response else {
+            return Err(CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::Unknown {
+                    reason: "Unexpected SSO response for account alias request".to_string(),
+                },
+            )));
+        };
+        response
+            .payload
+            .map(HostAccountGetAliasResponse::V1)
+            .map_err(|reason| {
+                CallError::Domain(HostAccountGetAliasError::V1(
+                    v01::HostAccountGetError::Unknown { reason },
+                ))
+            })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.create_account_proof"))]
+    async fn create_account_proof(
+        &self,
+        _cx: &CallContext,
+        _request: HostAccountCreateProofRequest,
+    ) -> Result<HostAccountCreateProofResponse, CallError<HostAccountCreateProofError>> {
+        Err(CallError::Unsupported)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.get_legacy_accounts"))]
+    async fn get_legacy_accounts(
+        &self,
+        _cx: &CallContext,
+        _request: HostGetLegacyAccountsRequest,
+    ) -> Result<HostGetLegacyAccountsResponse, CallError<HostGetLegacyAccountsError>> {
+        let Some(session) = self.session_state.current() else {
+            return Ok(HostGetLegacyAccountsResponse::V1(
+                v01::HostGetLegacyAccountsResponse { accounts: vec![] },
+            ));
+        };
+
+        let product_id = self.product_id();
+        if !is_product_identifier(&product_id) {
+            return Err(CallError::Domain(HostGetLegacyAccountsError::V1(
+                v01::HostAccountGetError::DomainNotValid,
+            )));
+        }
+
+        let public_key =
+            derive_product_public_key(session.public_key, &product_id, 0).map_err(|err| {
+                CallError::Domain(HostGetLegacyAccountsError::V1(
+                    v01::HostAccountGetError::Unknown {
+                        reason: err.to_string(),
+                    },
+                ))
+            })?;
+
+        Ok(HostGetLegacyAccountsResponse::V1(
+            v01::HostGetLegacyAccountsResponse {
+                accounts: vec![v01::LegacyAccount {
+                    public_key: public_key.to_vec(),
+                    name: session.lite_username,
+                }],
+            },
+        ))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.get_user_id"))]
+    async fn get_user_id(
+        &self,
+        _cx: &CallContext,
+        _request: HostGetUserIdRequest,
+    ) -> Result<HostGetUserIdResponse, CallError<HostGetUserIdError>> {
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostGetUserIdError::V1(
+                v01::HostGetUserIdError::NotConnected,
+            )));
+        };
+
+        let primary_username = session
+            .full_username
+            .filter(|value| !value.is_empty())
+            .or_else(|| session.lite_username.filter(|value| !value.is_empty()))
+            .ok_or_else(|| {
+                CallError::Domain(HostGetUserIdError::V1(v01::HostGetUserIdError::Unknown {
+                    reason: "No primary username for this session".to_string(),
+                }))
+            })?;
+
+        let service = PermissionsService::new(self.platform.as_ref(), self.platform.as_ref());
+        let permission = v01::RemotePermissionRequest {
+            permission: v01::RemotePermission::UserId,
+        };
+        match service.check_or_prompt_remote(permission).await {
+            Ok(Decision::Granted) => Ok(HostGetUserIdResponse::V1(v01::HostGetUserIdResponse {
+                primary_username,
+            })),
+            Ok(Decision::Denied) => Err(CallError::Domain(HostGetUserIdError::V1(
+                v01::HostGetUserIdError::PermissionDenied,
+            ))),
+            Err(err) => Err(CallError::HostFailure {
+                reason: format!("permission storage failed: {err:?}"),
+            }),
+        }
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.connection_status_subscribe"))]
+    async fn connection_status_subscribe(
+        &self,
+        _cx: &CallContext,
+    ) -> Subscription<HostAccountConnectionStatusSubscribeItem> {
+        Subscription::new(self.session_state.subscribe())
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "account.request_login", product = %self.runtime_config.product_id))]
+    async fn request_login(
+        &self,
+        _cx: &CallContext,
+        _request: HostRequestLoginRequest,
+    ) -> Result<HostRequestLoginResponse, CallError<HostRequestLoginError>> {
+        self.request_login_flow().await
+    }
+}
+
+/// Host-UI projection of an active session for `AuthState::Connected`.
+fn connected_session_ui_info(session: &SessionInfo) -> SessionUiInfo {
+    SessionUiInfo {
+        connected: true,
+        public_key: Some(session.public_key),
+        identity_account_id: session.identity_account_id,
+        lite_username: session.lite_username.clone(),
+        full_username: session.full_username.clone(),
+    }
+}
+
+const UNEXPECTED_SSO_SIGNING_RESPONSE: &str = "Unexpected SSO response for signing request";
+const UNEXPECTED_SSO_TRANSACTION_RESPONSE: &str = "Unexpected SSO response for transaction request";
+
+fn signing_unknown_call_error<E>(
+    wrap: fn(v01::HostSignPayloadError) -> E,
+    reason: impl Into<String>,
+) -> CallError<E> {
+    CallError::Domain(wrap(v01::HostSignPayloadError::Unknown {
+        reason: reason.into(),
+    }))
+}
+
+fn transaction_unknown_call_error<E>(
+    wrap: fn(v01::HostCreateTransactionError) -> E,
+    reason: impl Into<String>,
+) -> CallError<E> {
+    CallError::Domain(wrap(v01::HostCreateTransactionError::Unknown {
+        reason: reason.into(),
+    }))
+}
+
+impl<P> Signing for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "signing.sign_payload"))]
+    async fn sign_payload(
+        &self,
+        cx: &CallContext,
+        request: HostSignPayloadRequest,
+    ) -> Result<HostSignPayloadResponse, CallError<HostSignPayloadError>> {
+        info!("sign_payload: requesting wallet signature");
+        let HostSignPayloadRequest::V1(mut inner) = request;
+        inner.account = Self::normalize_product_account_id(inner.account);
+        if !self.is_product_account_valid_for_caller(&inner.account.dot_ns_identifier) {
+            return Err(CallError::Domain(HostSignPayloadError::V1(
+                v01::HostSignPayloadError::PermissionDenied,
+            )));
+        }
+        self.require_chain_submit(HostSignPayloadError::V1(
+            v01::HostSignPayloadError::PermissionDenied,
+        ))
+        .await?;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostSignPayloadError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        };
+        let confirmed = PlatformUserConfirmation::confirm_sign_payload(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("sign payload confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(HostSignPayloadError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        }
+        let message_id = sso_message_id(cx, "sign-payload");
+        let message = sign_payload_message(message_id, inner);
+        let response = self
+            .submit_sso_remote_message(cx, &session, "sign-payload", message)
+            .await
+            .map_err(|reason| signing_unknown_call_error(HostSignPayloadError::V1, reason))?;
+        let SsoRemoteResponse::Sign(response) = response else {
+            return Err(signing_unknown_call_error(
+                HostSignPayloadError::V1,
+                UNEXPECTED_SSO_SIGNING_RESPONSE,
+            ));
+        };
+        response
+            .payload
+            .map(|payload| {
+                HostSignPayloadResponse::V1(v01::HostSignPayloadResponse {
+                    signature: payload.signature,
+                    signed_transaction: payload.signed_transaction,
+                })
+            })
+            .map_err(|reason| signing_unknown_call_error(HostSignPayloadError::V1, reason))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "signing.sign_raw"))]
+    async fn sign_raw(
+        &self,
+        cx: &CallContext,
+        request: HostSignRawRequest,
+    ) -> Result<HostSignRawResponse, CallError<HostSignRawError>> {
+        info!("sign_raw: requesting wallet signature");
+        let HostSignRawRequest::V1(mut inner) = request;
+        inner.account = Self::normalize_product_account_id(inner.account);
+        if !self.is_product_account_valid_for_caller(&inner.account.dot_ns_identifier) {
+            return Err(CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::PermissionDenied,
+            )));
+        }
+        self.require_chain_submit(HostSignRawError::V1(
+            v01::HostSignPayloadError::PermissionDenied,
+        ))
+        .await?;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        };
+        let confirmed = PlatformUserConfirmation::confirm_sign_raw(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("sign raw confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        }
+        let message_id = sso_message_id(cx, "sign-raw");
+        let message = sign_raw_message(message_id, inner);
+        let response = self
+            .submit_sso_remote_message(cx, &session, "sign-raw", message)
+            .await
+            .map_err(|reason| signing_unknown_call_error(HostSignRawError::V1, reason))?;
+        let SsoRemoteResponse::Sign(response) = response else {
+            return Err(signing_unknown_call_error(
+                HostSignRawError::V1,
+                UNEXPECTED_SSO_SIGNING_RESPONSE,
+            ));
+        };
+        response
+            .payload
+            .map(|payload| {
+                HostSignRawResponse::V1(v01::HostSignPayloadResponse {
+                    signature: payload.signature,
+                    signed_transaction: payload.signed_transaction,
+                })
+            })
+            .map_err(|reason| signing_unknown_call_error(HostSignRawError::V1, reason))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "signing.create_transaction"))]
+    async fn create_transaction(
+        &self,
+        cx: &CallContext,
+        request: HostCreateTransactionRequest,
+    ) -> Result<HostCreateTransactionResponse, CallError<HostCreateTransactionError>> {
+        info!("create_transaction: requesting wallet signature");
+        let HostCreateTransactionRequest::V1(mut inner) = request;
+        inner.signer = Self::normalize_product_account_id(inner.signer);
+        if !self.is_product_account_valid_for_caller(&inner.signer.dot_ns_identifier) {
+            return Err(CallError::Domain(HostCreateTransactionError::V1(
+                v01::HostCreateTransactionError::PermissionDenied,
+            )));
+        }
+        self.require_chain_submit(HostCreateTransactionError::V1(
+            v01::HostCreateTransactionError::PermissionDenied,
+        ))
+        .await?;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostCreateTransactionError::V1(
+                v01::HostCreateTransactionError::Rejected,
+            )));
+        };
+        let confirmed = PlatformUserConfirmation::confirm_create_transaction(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("create transaction confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(HostCreateTransactionError::V1(
+                v01::HostCreateTransactionError::Rejected,
+            )));
+        }
+        let message_id = sso_message_id(cx, "create-transaction");
+        let message = create_transaction_message(message_id, inner);
+        let response = self
+            .submit_sso_remote_message(cx, &session, "create-transaction", message)
+            .await
+            .map_err(|reason| {
+                transaction_unknown_call_error(HostCreateTransactionError::V1, reason)
+            })?;
+        let SsoRemoteResponse::CreateTransaction(response) = response else {
+            return Err(transaction_unknown_call_error(
+                HostCreateTransactionError::V1,
+                UNEXPECTED_SSO_TRANSACTION_RESPONSE,
+            ));
+        };
+        response
+            .signed_transaction
+            .map(|transaction| {
+                HostCreateTransactionResponse::V1(v01::HostCreateTransactionResponse {
+                    transaction,
+                })
+            })
+            .map_err(|reason| {
+                transaction_unknown_call_error(HostCreateTransactionError::V1, reason)
+            })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "signing.sign_payload_with_legacy_account"))]
+    async fn sign_payload_with_legacy_account(
+        &self,
+        cx: &CallContext,
+        request: HostSignPayloadWithLegacyAccountRequest,
+    ) -> Result<
+        HostSignPayloadWithLegacyAccountResponse,
+        CallError<HostSignPayloadWithLegacyAccountError>,
+    > {
+        let HostSignPayloadWithLegacyAccountRequest::V1(inner) = request;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(
+                HostSignPayloadWithLegacyAccountError::V1(v01::HostSignPayloadError::Rejected),
+            ));
+        };
+        self.validate_legacy_address_signer(&session, &inner.signer)
+            .map_err(|err| CallError::Domain(HostSignPayloadWithLegacyAccountError::V1(err)))?;
+        self.require_chain_submit(HostSignPayloadWithLegacyAccountError::V1(
+            v01::HostSignPayloadError::PermissionDenied,
+        ))
+        .await?;
+        let confirmed = PlatformUserConfirmation::confirm_sign_payload(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("sign payload confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(
+                HostSignPayloadWithLegacyAccountError::V1(v01::HostSignPayloadError::Rejected),
+            ));
+        }
+        let message_id = sso_message_id(cx, "legacy-sign-payload");
+        let message = sign_payload_message(
+            message_id,
+            v01::HostSignPayloadRequest {
+                account: v01::ProductAccountId {
+                    dot_ns_identifier: self.product_id(),
+                    derivation_index: 0,
+                },
+                payload: inner.payload,
+            },
+        );
+        let response = self
+            .submit_sso_remote_message(cx, &session, "legacy-sign-payload", message)
+            .await
+            .map_err(|reason| {
+                signing_unknown_call_error(HostSignPayloadWithLegacyAccountError::V1, reason)
+            })?;
+        let SsoRemoteResponse::Sign(response) = response else {
+            return Err(signing_unknown_call_error(
+                HostSignPayloadWithLegacyAccountError::V1,
+                UNEXPECTED_SSO_SIGNING_RESPONSE,
+            ));
+        };
+        response
+            .payload
+            .map(|payload| {
+                HostSignPayloadWithLegacyAccountResponse::V1(v01::HostSignPayloadResponse {
+                    signature: payload.signature,
+                    signed_transaction: payload.signed_transaction,
+                })
+            })
+            .map_err(|reason| {
+                signing_unknown_call_error(HostSignPayloadWithLegacyAccountError::V1, reason)
+            })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "signing.sign_raw_with_legacy_account"))]
+    async fn sign_raw_with_legacy_account(
+        &self,
+        cx: &CallContext,
+        request: HostSignRawWithLegacyAccountRequest,
+    ) -> Result<HostSignRawWithLegacyAccountResponse, CallError<HostSignRawWithLegacyAccountError>>
+    {
+        let HostSignRawWithLegacyAccountRequest::V1(inner) = request;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostSignRawWithLegacyAccountError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        };
+        self.validate_legacy_address_signer(&session, &inner.signer)
+            .map_err(|err| CallError::Domain(HostSignRawWithLegacyAccountError::V1(err)))?;
+        self.require_chain_submit(HostSignRawWithLegacyAccountError::V1(
+            v01::HostSignPayloadError::PermissionDenied,
+        ))
+        .await?;
+        let confirmed = PlatformUserConfirmation::confirm_sign_raw(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("sign raw confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(HostSignRawWithLegacyAccountError::V1(
+                v01::HostSignPayloadError::Rejected,
+            )));
+        }
+        let message_id = sso_message_id(cx, "legacy-sign-raw");
+        let message = sign_raw_message(
+            message_id,
+            v01::HostSignRawRequest {
+                account: v01::ProductAccountId {
+                    dot_ns_identifier: self.product_id(),
+                    derivation_index: 0,
+                },
+                payload: inner.payload,
+            },
+        );
+        let response = self
+            .submit_sso_remote_message(cx, &session, "legacy-sign-raw", message)
+            .await
+            .map_err(|reason| {
+                signing_unknown_call_error(HostSignRawWithLegacyAccountError::V1, reason)
+            })?;
+        let SsoRemoteResponse::Sign(response) = response else {
+            return Err(signing_unknown_call_error(
+                HostSignRawWithLegacyAccountError::V1,
+                UNEXPECTED_SSO_SIGNING_RESPONSE,
+            ));
+        };
+        response
+            .payload
+            .map(|payload| {
+                HostSignRawWithLegacyAccountResponse::V1(v01::HostSignPayloadResponse {
+                    signature: payload.signature,
+                    signed_transaction: payload.signed_transaction,
+                })
+            })
+            .map_err(|reason| {
+                signing_unknown_call_error(HostSignRawWithLegacyAccountError::V1, reason)
+            })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "signing.create_transaction_with_legacy_account"))]
+    async fn create_transaction_with_legacy_account(
+        &self,
+        cx: &CallContext,
+        request: HostCreateTransactionWithLegacyAccountRequest,
+    ) -> Result<
+        HostCreateTransactionWithLegacyAccountResponse,
+        CallError<HostCreateTransactionWithLegacyAccountError>,
+    > {
+        let HostCreateTransactionWithLegacyAccountRequest::V1(inner) = request;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(
+                HostCreateTransactionWithLegacyAccountError::V1(
+                    v01::HostCreateTransactionError::Rejected,
+                ),
+            ));
+        };
+        self.validate_legacy_public_key_signer(&session, inner.signer)
+            .map_err(|err| {
+                CallError::Domain(HostCreateTransactionWithLegacyAccountError::V1(err))
+            })?;
+        self.require_chain_submit(HostCreateTransactionWithLegacyAccountError::V1(
+            v01::HostCreateTransactionError::PermissionDenied,
+        ))
+        .await?;
+        let confirmed = PlatformUserConfirmation::confirm_create_transaction(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("create transaction confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(
+                HostCreateTransactionWithLegacyAccountError::V1(
+                    v01::HostCreateTransactionError::Rejected,
+                ),
+            ));
+        }
+        let message_id = sso_message_id(cx, "legacy-create-transaction");
+        let message = create_transaction_message(
+            message_id,
+            v01::ProductAccountTxPayload {
+                signer: v01::ProductAccountId {
+                    dot_ns_identifier: self.product_id(),
+                    derivation_index: 0,
+                },
+                genesis_hash: inner.genesis_hash,
+                call_data: inner.call_data,
+                extensions: inner.extensions,
+                tx_ext_version: inner.tx_ext_version,
+            },
+        );
+        let response = self
+            .submit_sso_remote_message(cx, &session, "legacy-create-transaction", message)
+            .await
+            .map_err(|reason| {
+                transaction_unknown_call_error(
+                    HostCreateTransactionWithLegacyAccountError::V1,
+                    reason,
+                )
+            })?;
+        let SsoRemoteResponse::CreateTransaction(response) = response else {
+            return Err(transaction_unknown_call_error(
+                HostCreateTransactionWithLegacyAccountError::V1,
+                UNEXPECTED_SSO_TRANSACTION_RESPONSE,
+            ));
+        };
+        response
+            .signed_transaction
+            .map(|transaction| {
+                HostCreateTransactionWithLegacyAccountResponse::V1(
+                    v01::HostCreateTransactionWithLegacyAccountResponse { transaction },
+                )
+            })
+            .map_err(|reason| {
+                transaction_unknown_call_error(
+                    HostCreateTransactionWithLegacyAccountError::V1,
+                    reason,
+                )
+            })
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Chain
+// ---------------------------------------------------------------------------
+//
+// The chain surface is backed by `ChainRuntime`, which keeps one
+// `chainHead_v1` connection per genesis hash on top of the platform-supplied
+// `ChainProvider::connect`. Requests go through `request_value` and parse
+// json-rpc responses into typed v01 results; follow notifications are
+// translated into `RemoteChainHeadFollowItem` items on the subscription
+// stream.
+
+impl<P> Chain for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "chain.follow_head_subscribe"))]
+    async fn follow_head_subscribe(
+        &self,
+        cx: &CallContext,
+        request: RemoteChainHeadFollowRequest,
+    ) -> Subscription<RemoteChainHeadFollowItem> {
+        let RemoteChainHeadFollowRequest::V1(inner) = request;
+        let follow_subscription_id = cx.request_id().to_string();
+        let stream = self
+            .chain
+            .remote_chain_head_follow(follow_subscription_id, inner)
+            .map(RemoteChainHeadFollowItem::V1);
+        Subscription::new(Box::pin(stream))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_head_header"))]
+    async fn get_head_header(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadHeaderRequest,
+    ) -> Result<RemoteChainHeadHeaderResponse, CallError<RemoteChainHeadHeaderError>> {
+        let RemoteChainHeadHeaderRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_header(inner)
+            .await
+            .map(RemoteChainHeadHeaderResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_head_body"))]
+    async fn get_head_body(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadBodyRequest,
+    ) -> Result<RemoteChainHeadBodyResponse, CallError<RemoteChainHeadBodyError>> {
+        let RemoteChainHeadBodyRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_body(inner)
+            .await
+            .map(RemoteChainHeadBodyResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_head_storage"))]
+    async fn get_head_storage(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadStorageRequest,
+    ) -> Result<RemoteChainHeadStorageResponse, CallError<RemoteChainHeadStorageError>> {
+        let RemoteChainHeadStorageRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_storage(inner)
+            .await
+            .map(RemoteChainHeadStorageResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.call_head"))]
+    async fn call_head(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadCallRequest,
+    ) -> Result<RemoteChainHeadCallResponse, CallError<RemoteChainHeadCallError>> {
+        let RemoteChainHeadCallRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_call(inner)
+            .await
+            .map(RemoteChainHeadCallResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.unpin_head"))]
+    async fn unpin_head(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadUnpinRequest,
+    ) -> Result<RemoteChainHeadUnpinResponse, CallError<RemoteChainHeadUnpinError>> {
+        let RemoteChainHeadUnpinRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_unpin(inner)
+            .await
+            .map(|()| RemoteChainHeadUnpinResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.continue_head"))]
+    async fn continue_head(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadContinueRequest,
+    ) -> Result<RemoteChainHeadContinueResponse, CallError<RemoteChainHeadContinueError>> {
+        let RemoteChainHeadContinueRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_continue(inner)
+            .await
+            .map(|()| RemoteChainHeadContinueResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.stop_head_operation"))]
+    async fn stop_head_operation(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainHeadStopOperationRequest,
+    ) -> Result<RemoteChainHeadStopOperationResponse, CallError<RemoteChainHeadStopOperationError>>
+    {
+        let RemoteChainHeadStopOperationRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_head_stop_operation(inner)
+            .await
+            .map(|()| RemoteChainHeadStopOperationResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_spec_genesis_hash"))]
+    async fn get_spec_genesis_hash(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainSpecGenesisHashRequest,
+    ) -> Result<RemoteChainSpecGenesisHashResponse, CallError<RemoteChainSpecGenesisHashError>>
+    {
+        let RemoteChainSpecGenesisHashRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_spec_genesis_hash(inner.genesis_hash)
+            .await
+            .map(RemoteChainSpecGenesisHashResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_spec_chain_name"))]
+    async fn get_spec_chain_name(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainSpecChainNameRequest,
+    ) -> Result<RemoteChainSpecChainNameResponse, CallError<RemoteChainSpecChainNameError>> {
+        let RemoteChainSpecChainNameRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_spec_chain_name(inner.genesis_hash)
+            .await
+            .map(RemoteChainSpecChainNameResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.get_spec_properties"))]
+    async fn get_spec_properties(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainSpecPropertiesRequest,
+    ) -> Result<RemoteChainSpecPropertiesResponse, CallError<RemoteChainSpecPropertiesError>> {
+        let RemoteChainSpecPropertiesRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_spec_properties(inner.genesis_hash)
+            .await
+            .map(RemoteChainSpecPropertiesResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.broadcast_transaction"))]
+    async fn broadcast_transaction(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainTransactionBroadcastRequest,
+    ) -> Result<
+        RemoteChainTransactionBroadcastResponse,
+        CallError<RemoteChainTransactionBroadcastError>,
+    > {
+        let RemoteChainTransactionBroadcastRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_transaction_broadcast(inner)
+            .await
+            .map(RemoteChainTransactionBroadcastResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "chain.stop_transaction"))]
+    async fn stop_transaction(
+        &self,
+        _cx: &CallContext,
+        request: RemoteChainTransactionStopRequest,
+    ) -> Result<RemoteChainTransactionStopResponse, CallError<RemoteChainTransactionStopError>>
+    {
+        let RemoteChainTransactionStopRequest::V1(inner) = request;
+        self.chain
+            .remote_chain_transaction_stop(inner)
+            .await
+            .map(|()| RemoteChainTransactionStopResponse::V1)
+            .map_err(runtime_failure_to_call_error)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Deferred product surfaces.
+//
+// Payment and full account proof are explicitly out of current dotli parity,
+// but products should still observe dotli's typed "not implemented" errors
+// rather than a generic transport failure.
+// Chat and CoinPayment remain outside this milestone and keep their generated
+// trait defaults until another host/product needs real implementations.
+
+const PAYMENTS_NOT_IMPLEMENTED: &str = "Payments are not supported in dot.li";
+
+impl<P> Chat for PlatformRuntimeHost<P> where P: Platform + 'static {}
+impl<P> CoinPayment for PlatformRuntimeHost<P> where P: Platform + 'static {}
+impl<P> Payment for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "payment.balance_subscribe"))]
+    async fn balance_subscribe(
+        &self,
+        _cx: &CallContext,
+        _request: HostPaymentBalanceSubscribeRequest,
+    ) -> Result<
+        Subscription<HostPaymentBalanceSubscribeItem>,
+        CallError<HostPaymentBalanceSubscribeError>,
+    > {
+        Err(CallError::Domain(HostPaymentBalanceSubscribeError::V1(
+            v01::HostPaymentBalanceSubscribeError::PermissionDenied,
+        )))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "payment.request"))]
+    async fn request(
+        &self,
+        _cx: &CallContext,
+        _request: HostPaymentRequest,
+    ) -> Result<HostPaymentResponse, CallError<HostPaymentError>> {
+        Err(CallError::Domain(HostPaymentError::V1(
+            v01::HostPaymentError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "payment.status_subscribe"))]
+    async fn status_subscribe(
+        &self,
+        _cx: &CallContext,
+        _request: HostPaymentStatusSubscribeRequest,
+    ) -> Result<
+        Subscription<HostPaymentStatusSubscribeItem>,
+        CallError<HostPaymentStatusSubscribeError>,
+    > {
+        Err(CallError::Domain(HostPaymentStatusSubscribeError::V1(
+            v01::HostPaymentStatusSubscribeError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "payment.top_up"))]
+    async fn top_up(
+        &self,
+        _cx: &CallContext,
+        _request: HostPaymentTopUpRequest,
+    ) -> Result<HostPaymentTopUpResponse, CallError<HostPaymentTopUpError>> {
+        Err(CallError::Domain(HostPaymentTopUpError::V1(
+            v01::HostPaymentTopUpError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )))
+    }
+}
+
+impl<P> ResourceAllocation for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "resource_allocation.request"))]
+    async fn request(
+        &self,
+        cx: &CallContext,
+        request: HostRequestResourceAllocationRequest,
+    ) -> Result<HostRequestResourceAllocationResponse, CallError<HostRequestResourceAllocationError>>
+    {
+        let HostRequestResourceAllocationRequest::V1(inner) = request;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostRequestResourceAllocationError::V1(
+                v01::ResourceAllocationError::Unknown {
+                    reason: "No active session".to_string(),
+                },
+            )));
+        };
+
+        let confirmed = PlatformUserConfirmation::confirm_resource_allocation(
+            self.platform.as_ref(),
+            inner.clone().encode(),
+        )
+        .await
+        .map_err(|err| CallError::HostFailure {
+            reason: format!("resource allocation confirmation failed: {err:?}"),
+        })?;
+        if !confirmed {
+            return Err(CallError::Domain(HostRequestResourceAllocationError::V1(
+                v01::ResourceAllocationError::Unknown {
+                    reason: "User rejected resource allocation".to_string(),
+                },
+            )));
+        }
+        let message_id = sso_message_id(cx, "resource-allocation");
+        let message = resource_allocation_message(
+            message_id,
+            self.product_id(),
+            inner.resources,
+            OnExistingAllowancePolicy::Increase,
+        );
+        let response = self
+            .submit_sso_remote_message(cx, &session, "resource-allocation", message)
+            .await
+            .map_err(|reason| {
+                CallError::Domain(HostRequestResourceAllocationError::V1(
+                    v01::ResourceAllocationError::Unknown { reason },
+                ))
+            })?;
+        let SsoRemoteResponse::ResourceAllocation(response) = response else {
+            return Err(CallError::Domain(HostRequestResourceAllocationError::V1(
+                v01::ResourceAllocationError::Unknown {
+                    reason: "Unexpected SSO response for resource allocation request".to_string(),
+                },
+            )));
+        };
+        response
+            .payload
+            .map(|outcomes| {
+                HostRequestResourceAllocationResponse::V1(
+                    v01::HostRequestResourceAllocationResponse {
+                        outcomes: outcomes
+                            .into_iter()
+                            .map(resource_allocation_outcome)
+                            .collect(),
+                    },
+                )
+            })
+            .map_err(|reason| {
+                CallError::Domain(HostRequestResourceAllocationError::V1(
+                    v01::ResourceAllocationError::Unknown { reason },
+                ))
+            })
+    }
+}
+
+fn resource_allocation_outcome(outcome: SsoAllocationOutcome) -> v01::AllocationOutcome {
+    match outcome {
+        SsoAllocationOutcome::Allocated(_) => v01::AllocationOutcome::Allocated,
+        SsoAllocationOutcome::Rejected => v01::AllocationOutcome::Rejected,
+        SsoAllocationOutcome::NotAvailable => v01::AllocationOutcome::NotAvailable,
+    }
+}
+// ---------------------------------------------------------------------------
+// Entropy
+// ---------------------------------------------------------------------------
+
+impl<P> Entropy for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "entropy.derive"))]
+    async fn derive(
+        &self,
+        _cx: &CallContext,
+        request: HostDeriveEntropyRequest,
+    ) -> Result<HostDeriveEntropyResponse, CallError<HostDeriveEntropyError>> {
+        let HostDeriveEntropyRequest::V1(v01::HostDeriveEntropyRequest { context }) = request;
+        let Some(session) = self.session_state.current() else {
+            return Err(CallError::Domain(HostDeriveEntropyError::V1(
+                v01::HostDeriveEntropyError::Unknown {
+                    reason: "Not connected".to_string(),
+                },
+            )));
+        };
+        let Some(root_entropy_source) = session.root_entropy_source else {
+            return Err(CallError::Domain(HostDeriveEntropyError::V1(
+                v01::HostDeriveEntropyError::Unknown {
+                    reason: "Session secret missing".to_string(),
+                },
+            )));
+        };
+
+        let entropy =
+            derive_product_entropy_from_source(&root_entropy_source, &self.product_id(), &context)
+                .map_err(|err| {
+                    CallError::Domain(HostDeriveEntropyError::V1(
+                        v01::HostDeriveEntropyError::Unknown {
+                            reason: err.to_string(),
+                        },
+                    ))
+                })?;
+
+        Ok(HostDeriveEntropyResponse::V1(
+            v01::HostDeriveEntropyResponse { entropy },
+        ))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Preimage
+// ---------------------------------------------------------------------------
+
+impl<P> Preimage for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "preimage.lookup_subscribe"))]
+    async fn lookup_subscribe(
+        &self,
+        _cx: &CallContext,
+        request: RemotePreimageLookupSubscribeRequest,
+    ) -> Subscription<RemotePreimageLookupSubscribeItem> {
+        let RemotePreimageLookupSubscribeRequest::V1(v01::RemotePreimageLookupSubscribeRequest {
+            key,
+        }) = request;
+        let stream = PlatformPreimageHost::lookup_preimage(self.platform.as_ref(), key).filter_map(
+            |item| async move {
+                item.ok().map(|value| {
+                    RemotePreimageLookupSubscribeItem::V1(v01::RemotePreimageLookupSubscribeItem {
+                        value,
+                    })
+                })
+            },
+        );
+        Subscription::new(Box::pin(stream))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "preimage.submit"))]
+    async fn submit(
+        &self,
+        _cx: &CallContext,
+        request: RemotePreimageSubmitRequest,
+    ) -> Result<RemotePreimageSubmitResponse, CallError<RemotePreimageSubmitError>> {
+        let RemotePreimageSubmitRequest::V1(value) = request;
+        PlatformPreimageHost::confirm_preimage_submit(self.platform.as_ref(), value.len() as u64)
+            .await
+            .map_err(|err| CallError::Domain(RemotePreimageSubmitError::V1(err)))?;
+        PlatformPreimageHost::submit_preimage(self.platform.as_ref(), value)
+            .await
+            .map(RemotePreimageSubmitResponse::V1)
+            .map_err(|err| CallError::Domain(RemotePreimageSubmitError::V1(err)))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Theme
+// ---------------------------------------------------------------------------
+
+impl<P> Theme for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "theme.subscribe"))]
+    async fn subscribe(&self, _cx: &CallContext) -> Subscription<HostThemeSubscribeItem> {
+        let stream =
+            PlatformThemeHost::subscribe_theme(self.platform.as_ref()).filter_map(|item| async {
+                item.ok().map(|variant| {
+                    HostThemeSubscribeItem::V1(v01::HostThemeSubscribeItem {
+                        name: v01::ThemeName::Default,
+                        variant,
+                    })
+                })
+            });
+        Subscription::new(Box::pin(stream))
+    }
+}
+
+// `Notifications` delegates to the platform so hosts can own scheduling and
+// cancellation while the core preserves the typed TrUAPI wire shape.
+impl<P> Notifications for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "notifications.send_push_notification"))]
+    async fn send_push_notification(
+        &self,
+        _cx: &CallContext,
+        request: HostPushNotificationRequest,
+    ) -> Result<HostPushNotificationResponse, CallError<HostPushNotificationError>> {
+        let HostPushNotificationRequest::V1(inner) = request;
+        PlatformNotifications::push_notification(self.platform.as_ref(), inner)
+            .await
+            .map(HostPushNotificationResponse::V1)
+            .map_err(|err| {
+                CallError::Domain(HostPushNotificationError::V1(
+                    v01::HostPushNotificationError::Unknown { reason: err.reason },
+                ))
+            })
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "notifications.cancel_push_notification"))]
+    async fn cancel_push_notification(
+        &self,
+        _cx: &CallContext,
+        request: HostPushNotificationCancelRequest,
+    ) -> Result<HostPushNotificationCancelResponse, CallError<HostPushNotificationCancelError>>
+    {
+        let HostPushNotificationCancelRequest::V1(v01::HostPushNotificationCancelRequest { id }) =
+            request;
+        PlatformNotifications::cancel_notification(self.platform.as_ref(), id)
+            .await
+            .map(|()| HostPushNotificationCancelResponse::V1)
+            .map_err(|err| {
+                CallError::Domain(HostPushNotificationCancelError::V1(v01::GenericError {
+                    reason: err.reason,
+                }))
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::host_logic::sso_messages::{RemoteMessageData, RemoteMessageV1};
+    use crate::test_support::*;
+    use std::sync::Mutex;
+    use truapi_platform::AuthState;
+
+    use super::sso_remote::SSO_PEER_DISCONNECT_REASON;
+
+    #[test]
+    fn feature_supported_round_trips_through_runtime() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+            genesis_hash: vec![0u8; 32],
+        });
+        let response = futures::executor::block_on(host.feature_supported(&cx, request)).unwrap();
+        let HostFeatureSupportedResponse::V1(inner) = response;
+        assert!(inner.supported);
+    }
+
+    #[test]
+    fn navigate_to_uses_dotns_decision_and_then_platform() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostNavigateToRequest::V1(v01::HostNavigateToRequest {
+            url: "mytestapp.dot".to_string(),
+        });
+        let response = futures::executor::block_on(host.navigate_to(&cx, request)).unwrap();
+        assert_eq!(response, HostNavigateToResponse::V1);
+    }
+
+    #[test]
+    fn navigate_to_rejects_empty_input_without_calling_platform() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostNavigateToRequest::V1(v01::HostNavigateToRequest {
+            url: "".to_string(),
+        });
+        let err = futures::executor::block_on(host.navigate_to(&cx, request)).unwrap_err();
+        match err {
+            CallError::Domain(HostNavigateToError::V1(v01::HostNavigateToError::Unknown {
+                ..
+            })) => {}
+            other => panic!("expected Unknown navigate error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn push_notification_delegates_payload_and_returns_host_id() {
+        let pushed_notifications = Arc::new(Mutex::new(Vec::new()));
+        let platform = Arc::new(StubPlatform {
+            notification_id: 42,
+            pushed_notifications: pushed_notifications.clone(),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform, test_spawner());
+        let cx = CallContext::new();
+        let request = HostPushNotificationRequest::V1(v01::HostPushNotificationRequest {
+            text: "Hello".to_string(),
+            deeplink: Some("https://example.invalid/launch".to_string()),
+            scheduled_at: Some(1_776_144_000_000),
+        });
+
+        let response =
+            futures::executor::block_on(host.send_push_notification(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostPushNotificationResponse::V1(v01::HostPushNotificationResponse { id: 42 })
+        );
+        assert_eq!(
+            pushed_notifications
+                .lock()
+                .expect("notification list mutex poisoned")
+                .as_slice(),
+            &[v01::HostPushNotificationRequest {
+                text: "Hello".to_string(),
+                deeplink: Some("https://example.invalid/launch".to_string()),
+                scheduled_at: Some(1_776_144_000_000),
+            }]
+        );
+    }
+
+    #[test]
+    fn cancel_notification_delegates_host_id() {
+        let cancelled_notifications = Arc::new(Mutex::new(Vec::new()));
+        let platform = Arc::new(StubPlatform {
+            cancelled_notifications: cancelled_notifications.clone(),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform, test_spawner());
+        let cx = CallContext::new();
+        let request =
+            HostPushNotificationCancelRequest::V1(v01::HostPushNotificationCancelRequest {
+                id: 42,
+            });
+
+        let response =
+            futures::executor::block_on(host.cancel_push_notification(&cx, request)).unwrap();
+
+        assert_eq!(response, HostPushNotificationCancelResponse::V1);
+        assert_eq!(
+            cancelled_notifications
+                .lock()
+                .expect("notification cancellation list mutex poisoned")
+                .as_slice(),
+            &[42]
+        );
+    }
+
+    #[test]
+    fn get_account_requires_session() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostAccountGetRequest::V1(v01::HostAccountGetRequest {
+            product_account_id: v01::ProductAccountId {
+                dot_ns_identifier: "myapp.dot".to_string(),
+                derivation_index: 0,
+            },
+        });
+        let err = futures::executor::block_on(host.get_account(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostAccountGetError::V1(
+                v01::HostAccountGetError::NotConnected
+            ))
+        ));
+    }
+
+    #[test]
+    fn get_account_rejects_invalid_product_identifier() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostAccountGetRequest::V1(v01::HostAccountGetRequest {
+            product_account_id: v01::ProductAccountId {
+                dot_ns_identifier: "example.com".to_string(),
+                derivation_index: 0,
+            },
+        });
+        let err = futures::executor::block_on(host.get_account(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostAccountGetError::V1(
+                v01::HostAccountGetError::DomainNotValid
+            ))
+        ));
+    }
+
+    #[test]
+    fn get_account_derives_dotli_product_key() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostAccountGetRequest::V1(v01::HostAccountGetRequest {
+            product_account_id: v01::ProductAccountId {
+                dot_ns_identifier: "myapp.dot".to_string(),
+                derivation_index: 0,
+            },
+        });
+        let response = futures::executor::block_on(host.get_account(&cx, request)).unwrap();
+        let HostAccountGetResponse::V1(inner) = response;
+        assert_eq!(
+            hex::encode(inner.account.public_key),
+            "281489e3dd1c4dbe88cd670a59edcc9c44d64f510d302bd527ec306f10292f08"
+        );
+    }
+
+    #[test]
+    fn get_account_normalizes_product_identifier_before_deriving() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostAccountGetRequest::V1(v01::HostAccountGetRequest {
+            product_account_id: v01::ProductAccountId {
+                dot_ns_identifier: "MyApp.DOT".to_string(),
+                derivation_index: 0,
+            },
+        });
+        let response = futures::executor::block_on(host.get_account(&cx, request)).unwrap();
+        let HostAccountGetResponse::V1(inner) = response;
+        assert_eq!(
+            hex::encode(inner.account.public_key),
+            "281489e3dd1c4dbe88cd670a59edcc9c44d64f510d302bd527ec306f10292f08"
+        );
+    }
+
+    #[test]
+    fn get_account_alias_requires_session() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("myapp.dot")),
+        )
+        .unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::NotConnected
+            ))
+        ));
+    }
+
+    #[test]
+    fn get_account_alias_rejects_invalid_product_identifier() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("example.com")),
+        )
+        .unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::DomainNotValid
+            ))
+        ));
+    }
+
+    #[test]
+    fn get_account_alias_same_domain_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: sso_success_responses(
+                &session,
+                "alias-1",
+                crate::host_logic::sso_messages::RemoteMessage {
+                    message_id: "wallet-alias-1".to_string(),
+                    data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                        crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasResponse(
+                            crate::host_logic::sso_messages::RingVrfAliasResponse {
+                                responding_to: "alias-1".to_string(),
+                                payload: Ok(v01::HostAccountGetAliasResponse {
+                                    context: [9; 32],
+                                    alias: vec![1, 2, 3],
+                                }),
+                            },
+                        ),
+                    ),
+                },
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("alias-1".to_string());
+        let response = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("myapp.dot")),
+        )
+        .unwrap();
+        let HostAccountGetAliasResponse::V1(inner) = response;
+        assert_eq!(inner.context, [9; 32]);
+        assert_eq!(inner.alias, vec![1, 2, 3]);
+        let message = submitted_remote_message(&platform, &session);
+        let crate::host_logic::sso_messages::RemoteMessageData::V1(
+            crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasRequest(request),
+        ) = message.data
+        else {
+            panic!("expected ring VRF alias request");
+        };
+        assert_eq!(request.product_account_id.dot_ns_identifier, "myapp.dot");
+        assert_eq!(request.product_id, "myapp.dot");
+    }
+
+    #[test]
+    fn get_account_alias_normalizes_remote_request_identifier() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: sso_success_responses(
+                &session,
+                "alias-1",
+                crate::host_logic::sso_messages::RemoteMessage {
+                    message_id: "wallet-alias-1".to_string(),
+                    data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                        crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasResponse(
+                            crate::host_logic::sso_messages::RingVrfAliasResponse {
+                                responding_to: "alias-1".to_string(),
+                                payload: Ok(v01::HostAccountGetAliasResponse {
+                                    context: [9; 32],
+                                    alias: vec![1, 2, 3],
+                                }),
+                            },
+                        ),
+                    ),
+                },
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("MyApp.DOT"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("alias-1".to_string());
+        futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("MyApp.DOT")),
+        )
+        .unwrap();
+        let message = submitted_remote_message(&platform, &session);
+        let crate::host_logic::sso_messages::RemoteMessageData::V1(
+            crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasRequest(request),
+        ) = message.data
+        else {
+            panic!("expected ring VRF alias request");
+        };
+        assert_eq!(request.product_account_id.dot_ns_identifier, "myapp.dot");
+        assert_eq!(request.product_id, "myapp.dot");
+    }
+
+    #[test]
+    fn get_account_alias_cross_domain_rejects_when_user_declines() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("other.dot")),
+        )
+        .unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostAccountGetAliasError::V1(
+                v01::HostAccountGetError::Rejected
+            ))
+        ));
+    }
+
+    #[test]
+    fn get_account_alias_cross_domain_maps_confirmation_failure_to_host_failure() {
+        let host = PlatformRuntimeHost::new(
+            Arc::new(StubPlatform {
+                account_alias_error: Some("modal failed"),
+                ..Default::default()
+            }),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("other.dot")),
+        )
+        .unwrap_err();
+        assert!(
+            matches!(err, CallError::HostFailure { reason } if reason.contains("modal failed"))
+        );
+    }
+
+    #[test]
+    fn get_account_alias_cross_domain_accepts_confirmation_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            account_alias_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "alias-2",
+                crate::host_logic::sso_messages::RemoteMessage {
+                    message_id: "wallet-alias-2".to_string(),
+                    data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                        crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasResponse(
+                            crate::host_logic::sso_messages::RingVrfAliasResponse {
+                                responding_to: "alias-2".to_string(),
+                                payload: Ok(v01::HostAccountGetAliasResponse {
+                                    context: [8; 32],
+                                    alias: vec![4, 5, 6],
+                                }),
+                            },
+                        ),
+                    ),
+                },
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("alias-2".to_string());
+        let response = futures::executor::block_on(
+            host.get_account_alias(&cx, account_alias_request("other.dot")),
+        )
+        .unwrap();
+        let HostAccountGetAliasResponse::V1(inner) = response;
+        assert_eq!(inner.context, [8; 32]);
+        assert_eq!(inner.alias, vec![4, 5, 6]);
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::RingVrfAliasRequest(_)
+            )
+        ));
+    }
+
+    #[test]
+    fn get_legacy_accounts_returns_derived_slot_zero_when_connected() {
+        let host = PlatformRuntimeHost::new(
+            stub_platform(),
+            runtime_config("localhost:3000"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let response = futures::executor::block_on(
+            host.get_legacy_accounts(&cx, HostGetLegacyAccountsRequest::V1),
+        )
+        .unwrap();
+        let HostGetLegacyAccountsResponse::V1(inner) = response;
+        assert_eq!(inner.accounts.len(), 1);
+        assert_eq!(inner.accounts[0].name.as_deref(), Some("alice"));
+        assert_eq!(
+            hex::encode(&inner.accounts[0].public_key),
+            "1c822b488297fde8c60d9cbc5585839f70a69fb2c5c69daa66b6043c75184467"
+        );
+    }
+
+    #[test]
+    fn get_legacy_accounts_returns_empty_when_disconnected() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let response = futures::executor::block_on(
+            host.get_legacy_accounts(&cx, HostGetLegacyAccountsRequest::V1),
+        )
+        .unwrap();
+        let HostGetLegacyAccountsResponse::V1(inner) = response;
+        assert!(inner.accounts.is_empty());
+    }
+
+    #[test]
+    fn get_user_id_returns_primary_username_after_permission() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let response =
+            futures::executor::block_on(host.get_user_id(&cx, HostGetUserIdRequest::V1)).unwrap();
+        let HostGetUserIdResponse::V1(inner) = response;
+        assert_eq!(inner.primary_username, "Alice Smith");
+    }
+
+    #[test]
+    fn get_user_id_denies_when_permission_denied() {
+        let host = PlatformRuntimeHost::new_compat(
+            Arc::new(StubPlatform {
+                remote_permission_granted: false,
+                ..Default::default()
+            }),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(host.get_user_id(&cx, HostGetUserIdRequest::V1))
+            .unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostGetUserIdError::V1(
+                v01::HostGetUserIdError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn derive_entropy_matches_dotli_vector() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostDeriveEntropyRequest::V1(v01::HostDeriveEntropyRequest {
+            context: b"product-key".to_vec(),
+        });
+        let response = futures::executor::block_on(host.derive(&cx, request)).unwrap();
+        let HostDeriveEntropyResponse::V1(inner) = response;
+        assert_eq!(
+            hex::encode(inner.entropy),
+            "ab1887248c9de3cf4b8c5a255782796d3d35a98c8eb2d7df61a410db8b14da36"
+        );
+    }
+
+    #[test]
+    fn derive_entropy_requires_session() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostDeriveEntropyRequest::V1(v01::HostDeriveEntropyRequest {
+            context: b"product-key".to_vec(),
+        });
+        let err = futures::executor::block_on(host.derive(&cx, request)).unwrap_err();
+        match err {
+            CallError::Domain(HostDeriveEntropyError::V1(
+                v01::HostDeriveEntropyError::Unknown { reason },
+            )) => assert_eq!(reason, "Not connected"),
+            other => panic!("expected Unknown entropy error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn derive_entropy_requires_secret() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let mut session = session_info();
+        session.root_entropy_source = None;
+        host.session_state().set_session(session);
+        let cx = CallContext::new();
+        let request = HostDeriveEntropyRequest::V1(v01::HostDeriveEntropyRequest {
+            context: b"product-key".to_vec(),
+        });
+        let err = futures::executor::block_on(host.derive(&cx, request)).unwrap_err();
+        match err {
+            CallError::Domain(HostDeriveEntropyError::V1(
+                v01::HostDeriveEntropyError::Unknown { reason },
+            )) => assert_eq!(reason, "Session secret missing"),
+            other => panic!("expected Unknown entropy error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn derive_entropy_rejects_empty_context_like_dotli_key() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request =
+            HostDeriveEntropyRequest::V1(v01::HostDeriveEntropyRequest { context: vec![] });
+        let err = futures::executor::block_on(host.derive(&cx, request)).unwrap_err();
+        match err {
+            CallError::Domain(HostDeriveEntropyError::V1(
+                v01::HostDeriveEntropyError::Unknown { reason },
+            )) => assert_eq!(reason, "\"key\" must be between 1 and 32 bytes, got 0"),
+            other => panic!("expected Unknown entropy error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn preimage_submit_confirms_and_delegates_to_platform() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = RemotePreimageSubmitRequest::V1(vec![1, 2, 3]);
+        let response = futures::executor::block_on(Preimage::submit(&host, &cx, request)).unwrap();
+        assert_eq!(response, RemotePreimageSubmitResponse::V1(vec![1, 2, 3]));
+    }
+
+    #[test]
+    fn preimage_lookup_subscribe_maps_platform_values() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request =
+            RemotePreimageLookupSubscribeRequest::V1(v01::RemotePreimageLookupSubscribeRequest {
+                key: vec![0; 32],
+            });
+        let mut subscription = futures::executor::block_on(host.lookup_subscribe(&cx, request));
+        let item = futures::executor::block_on(subscription.next()).expect("preimage item");
+        assert_eq!(
+            item,
+            RemotePreimageLookupSubscribeItem::V1(v01::RemotePreimageLookupSubscribeItem {
+                value: Some(vec![9, 8, 7])
+            })
+        );
+    }
+
+    #[test]
+    fn theme_subscribe_maps_platform_values() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let mut subscription = futures::executor::block_on(Theme::subscribe(&host, &cx));
+        let item = futures::executor::block_on(subscription.next()).expect("theme item");
+        assert_eq!(
+            item,
+            HostThemeSubscribeItem::V1(v01::HostThemeSubscribeItem {
+                name: v01::ThemeName::Default,
+                variant: v01::ThemeVariant::Dark,
+            })
+        );
+    }
+
+    #[test]
+    fn sign_raw_rejects_invalid_product_account() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("other.dot", 0),
+            payload: raw_payload(),
+        });
+        let err = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn sign_raw_rejects_without_session_after_valid_account() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        let cx = CallContext::new();
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("myapp.dot", 0),
+            payload: raw_payload(),
+        });
+        let err = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawError::V1(v01::HostSignPayloadError::Rejected))
+        ));
+    }
+
+    #[test]
+    fn sign_raw_denies_when_chain_submit_denied() {
+        let host = PlatformRuntimeHost::new(
+            Arc::new(StubPlatform {
+                remote_permission_granted: false,
+                ..Default::default()
+            }),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("myapp.dot", 0),
+            payload: raw_payload(),
+        });
+        let err = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn sign_raw_rejects_when_user_declines_confirmation() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("myapp.dot", 0),
+            payload: raw_payload(),
+        });
+        let err = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawError::V1(v01::HostSignPayloadError::Rejected))
+        ));
+    }
+
+    #[test]
+    fn sign_raw_accepts_confirmation_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            sign_raw_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "sign-raw-1",
+                sign_response_message("sign-raw-1", vec![7, 7], None),
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("sign-raw-1".to_string());
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("myapp.dot", 0),
+            payload: raw_payload(),
+        });
+        let response = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap();
+        let HostSignRawResponse::V1(inner) = response;
+        assert_eq!(inner.signature, vec![7, 7]);
+        assert_eq!(inner.signed_transaction, None);
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            &message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::SignRequest(request)
+            ) if matches!(
+                request.as_ref(),
+                crate::host_logic::sso_messages::SigningRequest::Raw(_)
+            )
+        ));
+        let sent = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        let methods = sent
+            .iter()
+            .map(|request| {
+                serde_json::from_str::<serde_json::Value>(request).unwrap()["method"]
+                    .as_str()
+                    .unwrap()
+                    .to_string()
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(
+            methods,
+            vec![
+                "statement_subscribeStatement",
+                "statement_subscribeStatement",
+                "statement_submit",
+                "statement_unsubscribeStatement",
+                "statement_unsubscribeStatement",
+            ]
+        );
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&sent[3]).unwrap()["params"][0],
+            "own-sub-sign-raw-1"
+        );
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&sent[4]).unwrap()["params"][0],
+            "peer-sub-sign-raw-1"
+        );
+    }
+
+    #[test]
+    fn sign_raw_peer_disconnect_clears_session_store_and_broadcasts() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            sign_raw_confirmed: true,
+            rpc_responses: sso_peer_disconnect_responses(&session, "sign-raw-disconnect"),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session);
+        let mut statuses = host.session_state().subscribe();
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Connected
+            )
+        );
+
+        let cx = CallContext::with_request_id("sign-raw-disconnect".to_string());
+        let request = HostSignRawRequest::V1(v01::HostSignRawRequest {
+            account: account_id("myapp.dot", 0),
+            payload: raw_payload(),
+        });
+        let err = futures::executor::block_on(host.sign_raw(&cx, request)).unwrap_err();
+
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawError::V1(
+                v01::HostSignPayloadError::Unknown { reason }
+            )) if reason == SSO_PEER_DISCONNECT_REASON
+        ));
+        assert!(host.session_state().current().is_none());
+        assert_eq!(
+            *platform
+                .session_clears
+                .lock()
+                .expect("session clear counter mutex poisoned"),
+            1
+        );
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Disconnected
+            )
+        );
+    }
+
+    #[test]
+    fn sign_payload_denies_when_chain_submit_denied() {
+        let host = PlatformRuntimeHost::new(
+            Arc::new(StubPlatform {
+                remote_permission_granted: false,
+                ..Default::default()
+            }),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostSignPayloadRequest::V1(v01::HostSignPayloadRequest {
+            account: account_id("myapp.dot", 0),
+            payload: sign_payload_data(),
+        });
+        let err = futures::executor::block_on(host.sign_payload(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignPayloadError::V1(
+                v01::HostSignPayloadError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn sign_payload_maps_confirmation_failure_to_host_failure() {
+        let host = PlatformRuntimeHost::new(
+            Arc::new(StubPlatform {
+                sign_payload_error: Some("modal failed"),
+                ..Default::default()
+            }),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostSignPayloadRequest::V1(v01::HostSignPayloadRequest {
+            account: account_id("myapp.dot", 0),
+            payload: sign_payload_data(),
+        });
+        let err = futures::executor::block_on(host.sign_payload(&cx, request)).unwrap_err();
+        assert!(
+            matches!(err, CallError::HostFailure { reason } if reason.contains("modal failed"))
+        );
+    }
+
+    #[test]
+    fn sign_payload_accepts_confirmation_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            sign_payload_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "sign-payload-1",
+                sign_response_message("sign-payload-1", vec![8, 8], Some(vec![0xab, 0xcd])),
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("sign-payload-1".to_string());
+        let request = HostSignPayloadRequest::V1(v01::HostSignPayloadRequest {
+            account: account_id("myapp.dot", 0),
+            payload: sign_payload_data(),
+        });
+
+        let response = futures::executor::block_on(host.sign_payload(&cx, request)).unwrap();
+
+        let HostSignPayloadResponse::V1(inner) = response;
+        assert_eq!(inner.signature, vec![8, 8]);
+        assert_eq!(inner.signed_transaction, Some(vec![0xab, 0xcd]));
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            &message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::SignRequest(request)
+            ) if matches!(
+                request.as_ref(),
+                crate::host_logic::sso_messages::SigningRequest::Payload(_)
+            )
+        ));
+    }
+
+    #[test]
+    fn create_transaction_accepts_confirmation_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            create_transaction_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "create-tx-1",
+                crate::host_logic::sso_messages::RemoteMessage {
+                    message_id: "wallet-create-tx-1".to_string(),
+                    data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                        crate::host_logic::sso_messages::RemoteMessageV1::CreateTransactionResponse(
+                            crate::host_logic::sso_messages::CreateTransactionResponse {
+                                responding_to: "create-tx-1".to_string(),
+                                signed_transaction: Ok(vec![0xca, 0xfe]),
+                            },
+                        ),
+                    ),
+                },
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("create-tx-1".to_string());
+        let request = HostCreateTransactionRequest::V1(product_tx_payload("myapp.dot"));
+        let response = futures::executor::block_on(host.create_transaction(&cx, request)).unwrap();
+        let HostCreateTransactionResponse::V1(inner) = response;
+        assert_eq!(inner.transaction, vec![0xca, 0xfe]);
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::CreateTransactionRequest(_)
+            )
+        ));
+    }
+
+    #[test]
+    fn legacy_sign_raw_rejects_signer_mismatch() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request =
+            HostSignRawWithLegacyAccountRequest::V1(v01::HostSignRawWithLegacyAccountRequest {
+                signer: "5Ci5sCERp3MFEDpF2jVkQDJoBevpRosB7toYRqKWShewhdhq".to_string(),
+                payload: raw_payload(),
+            });
+        let err = futures::executor::block_on(host.sign_raw_with_legacy_account(&cx, request))
+            .unwrap_err();
+        match err {
+            CallError::Domain(HostSignRawWithLegacyAccountError::V1(
+                v01::HostSignPayloadError::Unknown { reason },
+            )) => assert_eq!(reason, "Account can't be derived from product account id"),
+            other => panic!("expected legacy signer mismatch, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn legacy_sign_raw_denies_when_chain_submit_denied() {
+        let host = PlatformRuntimeHost::new(
+            Arc::new(StubPlatform {
+                remote_permission_granted: false,
+                ..Default::default()
+            }),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(sso_session_info());
+        let cx = CallContext::new();
+        let request =
+            HostSignRawWithLegacyAccountRequest::V1(v01::HostSignRawWithLegacyAccountRequest {
+                signer: "5CyFsdhwjXy7wWpDEM6isungQ3LfGnu9UXkt7paBQ6DYRxk1".to_string(),
+                payload: raw_payload(),
+            });
+        let err = futures::executor::block_on(host.sign_raw_with_legacy_account(&cx, request))
+            .unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostSignRawWithLegacyAccountError::V1(
+                v01::HostSignPayloadError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn legacy_sign_raw_accepts_derived_ss58_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            sign_raw_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "legacy-sign-raw-1",
+                sign_response_message("legacy-sign-raw-1", vec![9, 9], None),
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("legacy-sign-raw-1".to_string());
+        let request =
+            HostSignRawWithLegacyAccountRequest::V1(v01::HostSignRawWithLegacyAccountRequest {
+                signer: "5CyFsdhwjXy7wWpDEM6isungQ3LfGnu9UXkt7paBQ6DYRxk1".to_string(),
+                payload: raw_payload(),
+            });
+        let response =
+            futures::executor::block_on(host.sign_raw_with_legacy_account(&cx, request)).unwrap();
+        let HostSignRawWithLegacyAccountResponse::V1(inner) = response;
+        assert_eq!(inner.signature, vec![9, 9]);
+        assert_eq!(inner.signed_transaction, None);
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            &message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::SignRequest(request)
+            ) if matches!(
+                request.as_ref(),
+                crate::host_logic::sso_messages::SigningRequest::Raw(_)
+            )
+        ));
+    }
+
+    #[test]
+    fn legacy_create_transaction_rejects_raw_key_mismatch() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request =
+            HostCreateTransactionWithLegacyAccountRequest::V1(v01::LegacyAccountTxPayload {
+                signer: [0; 32],
+                genesis_hash: [1; 32],
+                call_data: vec![0],
+                extensions: vec![],
+                tx_ext_version: 0,
+            });
+        let err =
+            futures::executor::block_on(host.create_transaction_with_legacy_account(&cx, request))
+                .unwrap_err();
+        match err {
+            CallError::Domain(HostCreateTransactionWithLegacyAccountError::V1(
+                v01::HostCreateTransactionError::Unknown { reason },
+            )) => assert_eq!(reason, "Account can't be derived from product account id"),
+            other => panic!("expected legacy signer mismatch, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn create_transaction_rejects_invalid_product_account() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostCreateTransactionRequest::V1(product_tx_payload("other.dot"));
+        let err = futures::executor::block_on(host.create_transaction(&cx, request)).unwrap_err();
+        assert!(matches!(
+            err,
+            CallError::Domain(HostCreateTransactionError::V1(
+                v01::HostCreateTransactionError::PermissionDenied
+            ))
+        ));
+    }
+
+    #[test]
+    fn resource_allocation_rejects_without_session() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(ResourceAllocation::request(
+            &host,
+            &cx,
+            resource_allocation_request(),
+        ))
+        .unwrap_err();
+        match err {
+            CallError::Domain(HostRequestResourceAllocationError::V1(
+                v01::ResourceAllocationError::Unknown { reason },
+            )) => assert_eq!(reason, "No active session"),
+            other => panic!("expected no-session resource allocation error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn resource_allocation_rejects_when_user_declines() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(ResourceAllocation::request(
+            &host,
+            &cx,
+            resource_allocation_request(),
+        ))
+        .unwrap_err();
+        match err {
+            CallError::Domain(HostRequestResourceAllocationError::V1(
+                v01::ResourceAllocationError::Unknown { reason },
+            )) => assert_eq!(reason, "User rejected resource allocation"),
+            other => panic!("expected user-rejected resource allocation error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn resource_allocation_maps_confirmation_failure_to_host_failure() {
+        let host = PlatformRuntimeHost::new_compat(
+            Arc::new(StubPlatform {
+                resource_allocation_error: Some("modal failed"),
+                ..Default::default()
+            }),
+            test_spawner(),
+        );
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let err = futures::executor::block_on(ResourceAllocation::request(
+            &host,
+            &cx,
+            resource_allocation_request(),
+        ))
+        .unwrap_err();
+        assert!(
+            matches!(err, CallError::HostFailure { reason } if reason.contains("modal failed"))
+        );
+    }
+
+    #[test]
+    fn resource_allocation_accepts_confirmation_then_returns_sso_response() {
+        let session = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            resource_allocation_confirmed: true,
+            rpc_responses: sso_success_responses(
+                &session,
+                "alloc-1",
+                crate::host_logic::sso_messages::RemoteMessage {
+                    message_id: "wallet-alloc-1".to_string(),
+                    data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                        crate::host_logic::sso_messages::RemoteMessageV1::ResourceAllocationResponse(
+                            crate::host_logic::sso_messages::ResourceAllocationResponse {
+                                responding_to: "alloc-1".to_string(),
+                                payload: Ok(vec![
+                                    crate::host_logic::sso_messages::SsoAllocationOutcome::Allocated(
+                                        crate::host_logic::sso_messages::SsoAllocatedResource::StatementStoreAllowance {
+                                            slot_account_key: vec![1],
+                                        },
+                                    ),
+                                    crate::host_logic::sso_messages::SsoAllocationOutcome::Rejected,
+                                    crate::host_logic::sso_messages::SsoAllocationOutcome::NotAvailable,
+                                ]),
+                            },
+                        ),
+                    ),
+                },
+            ),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        host.session_state().set_session(session.clone());
+        let cx = CallContext::with_request_id("alloc-1".to_string());
+        let response = futures::executor::block_on(ResourceAllocation::request(
+            &host,
+            &cx,
+            resource_allocation_request(),
+        ))
+        .unwrap();
+        let HostRequestResourceAllocationResponse::V1(inner) = response;
+        assert_eq!(
+            inner.outcomes,
+            vec![
+                v01::AllocationOutcome::Allocated,
+                v01::AllocationOutcome::Rejected,
+                v01::AllocationOutcome::NotAvailable,
+            ]
+        );
+        let message = submitted_remote_message(&platform, &session);
+        assert!(matches!(
+            message.data,
+            crate::host_logic::sso_messages::RemoteMessageData::V1(
+                crate::host_logic::sso_messages::RemoteMessageV1::ResourceAllocationRequest(_)
+            )
+        ));
+    }
+
+    #[test]
+    fn session_store_sync_restores_valid_blob_from_tick() {
+        let stored = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            session_blob: Some(crate::host_logic::session::encode_persisted_session(
+                &stored,
+            )),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+
+        host.start_session_store_sync(immediate_spawner());
+
+        assert_eq!(host.session_state().current(), Some(stored.clone()));
+        assert_eq!(
+            *platform
+                .auth_states
+                .lock()
+                .expect("auth state list mutex poisoned"),
+            vec![AuthState::Connected(connected_session_ui_info(&stored))]
+        );
+    }
+
+    #[test]
+    fn session_store_sync_replaces_valid_blob_and_broadcasts_connected() {
+        let mut replacement = sso_session_info();
+        replacement.public_key = [0x44; 32];
+        let host = PlatformRuntimeHost::new_compat(
+            Arc::new(StubPlatform {
+                session_blob: Some(crate::host_logic::session::encode_persisted_session(
+                    &replacement,
+                )),
+                ..Default::default()
+            }),
+            test_spawner(),
+        );
+        host.session_state().set_session(sso_session_info());
+        let mut statuses = host.session_state().subscribe();
+        let _ = futures::executor::block_on(statuses.next());
+
+        host.start_session_store_sync(immediate_spawner());
+
+        assert_eq!(host.session_state().current(), Some(replacement));
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Connected
+            )
+        );
+    }
+
+    #[test]
+    fn session_store_sync_clears_invalid_blob() {
+        let platform = Arc::new(StubPlatform {
+            session_blob: Some(vec![0xff]),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        host.session_state().set_session(sso_session_info());
+
+        host.start_session_store_sync(immediate_spawner());
+
+        assert!(host.session_state().current().is_none());
+        // `set_session` bypasses the auth state cell, so the cell never left
+        // `Disconnected` and clearing the invalid blob emits nothing.
+        assert!(
+            platform
+                .auth_states
+                .lock()
+                .expect("auth state list mutex poisoned")
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn session_store_sync_clears_unreadable_blob() {
+        let session_clears = Arc::new(Mutex::new(0));
+        let host = PlatformRuntimeHost::new_compat(
+            Arc::new(StubPlatform {
+                session_error: Some("storage unavailable"),
+                session_clears: session_clears.clone(),
+                ..Default::default()
+            }),
+            test_spawner(),
+        );
+        host.session_state().set_session(sso_session_info());
+
+        host.start_session_store_sync(immediate_spawner());
+
+        assert!(host.session_state().current().is_none());
+        assert_eq!(*session_clears.lock().unwrap(), 1);
+    }
+
+    /// A persistently failing read must not spin the sync loop through its
+    /// own clear notifications: the store is cleared at most once per error
+    /// streak.
+    #[test]
+    fn session_store_sync_clears_at_most_once_on_persistent_read_error() {
+        let session_clears = Arc::new(Mutex::new(0));
+        let (tick_tx, tick_rx) = futures::channel::mpsc::unbounded();
+        tick_tx.unbounded_send(Ok(())).unwrap();
+        let host = PlatformRuntimeHost::new_compat(
+            Arc::new(StubPlatform {
+                session_error: Some("storage unavailable"),
+                session_clears: session_clears.clone(),
+                session_store_tick_tx: Some(tick_tx),
+                session_store_ticks: Arc::new(Mutex::new(Some(tick_rx))),
+                ..Default::default()
+            }),
+            test_spawner(),
+        );
+        host.session_state().set_session(sso_session_info());
+
+        host.start_session_store_sync(test_spawner());
+
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
+        while *session_clears.lock().unwrap() == 0 {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "clear_session was never called"
+            );
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+        // Give the loop time to mis-fire if the clear notification were to
+        // re-trigger another clear.
+        std::thread::sleep(std::time::Duration::from_millis(100));
+        assert_eq!(*session_clears.lock().unwrap(), 1);
+        assert!(host.session_state().current().is_none());
+    }
+
+    #[test]
+    fn disconnect_submits_disconnected_message_best_effort() {
+        let platform = Arc::new(StubPlatform::default());
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        let session = sso_session_info();
+        host.session_state().set_session(session.clone());
+
+        futures::executor::block_on(host.disconnect());
+
+        assert!(host.session_state().current().is_none());
+        assert_eq!(
+            *platform
+                .session_clears
+                .lock()
+                .expect("session clear counter mutex poisoned"),
+            1
+        );
+        let message = submitted_remote_message(&platform, &session);
+        assert_eq!(message.message_id, "truapi:sso:disconnect");
+        assert!(matches!(
+            message.data,
+            RemoteMessageData::V1(RemoteMessageV1::Disconnected)
+        ));
+    }
+
+    #[test]
+    fn disconnect_clears_session_store_and_broadcasts_disconnected() {
+        let platform = Arc::new(StubPlatform::default());
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        host.session_state().set_session(sso_session_info());
+        platform
+            .local_storage
+            .lock()
+            .expect("local storage mutex poisoned")
+            .insert(
+                PAIRING_DEVICE_IDENTITY_STORAGE_KEY.to_string(),
+                vec![1, 2, 3],
+            );
+        let mut statuses = host.session_state().subscribe();
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Connected
+            )
+        );
+
+        futures::executor::block_on(host.disconnect());
+
+        assert!(host.session_state().current().is_none());
+        assert_eq!(
+            *platform
+                .session_clears
+                .lock()
+                .expect("session clear counter mutex poisoned"),
+            1
+        );
+        assert!(
+            !platform
+                .local_storage
+                .lock()
+                .expect("local storage mutex poisoned")
+                .contains_key(PAIRING_DEVICE_IDENTITY_STORAGE_KEY),
+            "logout must rotate the pairing device identity so stale statement-store responses cannot be replayed on the next login"
+        );
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Disconnected
+            )
+        );
+        // `set_session` bypasses the auth state cell, so the cell never left
+        // `Disconnected` and the logout emits nothing new.
+        assert!(
+            platform
+                .auth_states
+                .lock()
+                .expect("auth state list mutex poisoned")
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn disconnect_emits_disconnected_auth_state_after_store_sync_connected() {
+        let stored = sso_session_info();
+        let platform = Arc::new(StubPlatform {
+            session_blob: Some(crate::host_logic::session::encode_persisted_session(
+                &stored,
+            )),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        host.start_session_store_sync(immediate_spawner());
+
+        futures::executor::block_on(host.disconnect());
+
+        assert_eq!(
+            *platform
+                .auth_states
+                .lock()
+                .expect("auth state list mutex poisoned"),
+            vec![
+                AuthState::Connected(connected_session_ui_info(&stored)),
+                AuthState::Disconnected,
+            ]
+        );
+    }
+
+    #[test]
+    fn disconnect_tolerates_repeated_logout_when_already_disconnected() {
+        let platform = Arc::new(StubPlatform::default());
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+
+        futures::executor::block_on(host.disconnect());
+        futures::executor::block_on(host.disconnect());
+
+        assert!(host.session_state().current().is_none());
+        assert_eq!(
+            *platform
+                .session_clears
+                .lock()
+                .expect("session clear counter mutex poisoned"),
+            2
+        );
+        assert!(platform.sent_rpc.lock().unwrap().is_empty());
+    }
+
+    #[test]
+    fn disconnect_notifies_pending_sso_waiters() {
+        let platform = Arc::new(StubPlatform::default());
+        let host = PlatformRuntimeHost::new_compat(platform, test_spawner());
+        let (_waiter_id, disconnect) = host.session_disconnects.subscribe();
+
+        futures::executor::block_on(host.disconnect());
+
+        assert_eq!(
+            futures::executor::block_on(disconnect).unwrap(),
+            SSO_LOCAL_DISCONNECT_REASON
+        );
+    }
+
+    #[test]
+    fn permissions_grants_and_caches() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostDevicePermissionRequest::V1(v01::HostDevicePermissionRequest::Camera);
+        let response =
+            futures::executor::block_on(host.request_device_permission(&cx, request)).unwrap();
+        let HostDevicePermissionResponse::V1(inner) = response;
+        assert!(inner.granted);
+    }
+
+    #[test]
+    fn feature_supported_encodes_response_to_known_bytes() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+            genesis_hash: vec![0u8; 32],
+        });
+        let response = futures::executor::block_on(host.feature_supported(&cx, request)).unwrap();
+        // [V1 variant=0][supported=1]
+        assert_eq!(response.encode(), vec![0x00, 0x01]);
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime/auth_state.rs b/rust/crates/truapi-server/src/runtime/auth_state.rs
new file mode 100644
index 00000000..8bdfb7a8
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime/auth_state.rs
@@ -0,0 +1,170 @@
+//! Core-owned auth/session UI state machine. Every [`AuthState`] emission to
+//! the host funnels through [`AuthStateMachine`], so transitions stay ordered
+//! and a stale session-store tick can never tear down an in-flight pairing.
+
+use std::sync::{Arc, Mutex};
+
+use futures::channel::oneshot;
+use truapi_platform::{AuthPresenter, AuthState, Platform, SessionUiInfo};
+
+/// Serialized auth-state machine bound to the platform's `auth_state_changed`
+/// sink. Each transition mutates under the lock, releases it, then emits the
+/// new state (when it actually changed), so `auth_state_changed` handlers may
+/// safely re-enter the runtime (e.g. a host cancelling the login it just
+/// observed). The cancel channel for an in-flight login lives inside the
+/// `Pairing` state, making its registration atomic with the transition.
+pub(crate) struct AuthStateMachine<P> {
+    platform: Arc<P>,
+    inner: Arc<Mutex<AuthStateInner>>,
+}
+
+impl<P> Clone for AuthStateMachine<P> {
+    fn clone(&self) -> Self {
+        Self {
+            platform: self.platform.clone(),
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct AuthStateInner {
+    state: AuthState,
+    /// Increments on every `pairing_started`; lets an abandoned flow's reset
+    /// guard distinguish its own `Pairing` from a newer flow's.
+    pairing_epoch: u64,
+    /// Resolves the in-flight login's cancel receiver. Present exactly while
+    /// the state is `Pairing`.
+    cancel_tx: Option<oneshot::Sender<()>>,
+}
+
+impl<P> AuthStateMachine<P>
+where
+    P: Platform,
+{
+    pub(super) fn new(platform: Arc<P>) -> Self {
+        Self {
+            platform,
+            inner: Arc::new(Mutex::new(AuthStateInner::default())),
+        }
+    }
+
+    /// Enter `Pairing`. Returns the cancel receiver and the pairing epoch, or
+    /// `None` when a pairing is already in flight (single-flight guard).
+    pub(super) fn pairing_started(&self, deeplink: String) -> Option<(oneshot::Receiver<()>, u64)> {
+        let (cancel_tx, cancel_rx) = oneshot::channel();
+        let epoch = self.transition(|inner| {
+            if matches!(inner.state, AuthState::Pairing { .. }) {
+                return None;
+            }
+            inner.state = AuthState::Pairing { deeplink };
+            inner.pairing_epoch = inner.pairing_epoch.wrapping_add(1);
+            inner.cancel_tx = Some(cancel_tx);
+            Some(inner.pairing_epoch)
+        })?;
+        Some((cancel_rx, epoch))
+    }
+
+    /// `Pairing` -> `LoginFailed`: the in-flight login reported a failure.
+    pub(super) fn login_failed(&self, reason: String) {
+        self.transition(|inner| {
+            if !matches!(inner.state, AuthState::Pairing { .. }) {
+                return None;
+            }
+            inner.cancel_tx = None;
+            inner.state = AuthState::LoginFailed { reason };
+            Some(())
+        });
+    }
+
+    /// `Disconnected`/`LoginFailed` -> `LoginFailed`: a login failed before
+    /// it reached `Pairing` (device identity or bootstrap errors). A no-op
+    /// while `Pairing`, so a concurrent second login attempt failing early
+    /// cannot tear down the first one's presentation.
+    pub(super) fn login_failed_before_pairing(&self, reason: String) {
+        self.transition(|inner| {
+            if matches!(
+                inner.state,
+                AuthState::Pairing { .. } | AuthState::Connected(_)
+            ) {
+                return None;
+            }
+            inner.state = AuthState::LoginFailed { reason };
+            Some(())
+        });
+    }
+
+    /// `Pairing`/`LoginFailed` -> `Disconnected` (host cancelled or
+    /// dismissed). Wakes the in-flight login, which resolves as `Rejected`.
+    pub(super) fn login_cancelled(&self) {
+        self.transition(|inner| {
+            if !matches!(
+                inner.state,
+                AuthState::Pairing { .. } | AuthState::LoginFailed { .. }
+            ) {
+                return None;
+            }
+            if let Some(cancel_tx) = inner.cancel_tx.take() {
+                let _ = cancel_tx.send(());
+            }
+            inner.state = AuthState::Disconnected;
+            Some(())
+        });
+    }
+
+    /// Any state -> `Connected`. A login in flight is cancelled: another
+    /// runtime won the race, and the waking flow resolves as
+    /// `AlreadyConnected`. Emits only when the connected info changed.
+    pub(super) fn connected(&self, info: &SessionUiInfo) {
+        self.transition(|inner| {
+            if let Some(cancel_tx) = inner.cancel_tx.take() {
+                let _ = cancel_tx.send(());
+            }
+            if matches!(&inner.state, AuthState::Connected(current) if current == info) {
+                return None;
+            }
+            inner.state = AuthState::Connected(info.clone());
+            Some(())
+        });
+    }
+
+    /// Session store reports no session. A no-op while `Pairing`: the login
+    /// flow owns its own terminal transition, and a boot-time store tick must
+    /// not tear down the pairing UI.
+    pub(super) fn store_disconnected(&self) {
+        self.transition(|inner| {
+            if matches!(
+                inner.state,
+                AuthState::Pairing { .. } | AuthState::Disconnected
+            ) {
+                return None;
+            }
+            inner.state = AuthState::Disconnected;
+            Some(())
+        });
+    }
+
+    /// Reset a `Pairing` left behind by a dropped login future, but only when
+    /// it still belongs to `epoch` (a newer flow's pairing is left alone).
+    pub(super) fn reset_abandoned_pairing(&self, epoch: u64) {
+        self.transition(|inner| {
+            if !matches!(inner.state, AuthState::Pairing { .. }) || inner.pairing_epoch != epoch {
+                return None;
+            }
+            inner.cancel_tx = None;
+            inner.state = AuthState::Disconnected;
+            Some(())
+        });
+    }
+
+    /// Run `apply` under the lock; when it changed the state (returned
+    /// `Some`), emit the new state to the host after releasing the lock.
+    fn transition<T>(&self, apply: impl FnOnce(&mut AuthStateInner) -> Option<T>) -> Option<T> {
+        let mut inner = self.inner.lock().expect("auth state mutex poisoned");
+        let applied = apply(&mut inner)?;
+        let state = inner.state.clone();
+        drop(inner);
+        AuthPresenter::auth_state_changed(self.platform.as_ref(), state);
+        Some(applied)
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime/identity.rs b/rust/crates/truapi-server/src/runtime/identity.rs
new file mode 100644
index 00000000..5c528950
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime/identity.rs
@@ -0,0 +1,340 @@
+//! People-chain identity lookup used to resolve usernames for a paired
+//! session.
+
+use std::sync::atomic::{AtomicU64, Ordering};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
+#[cfg(target_arch = "wasm32")]
+use web_time::Duration;
+
+use super::PlatformRuntimeHost;
+use crate::chain_runtime::ChainRuntime;
+use crate::host_logic::identity::{
+    PeopleIdentity, decode_people_identity, resources_consumers_storage_key,
+};
+use crate::host_logic::session::SessionInfo;
+
+use futures::stream::BoxStream;
+use futures::{FutureExt, StreamExt, pin_mut};
+use tracing::{debug, instrument, warn};
+use truapi::v01;
+use truapi::v01::{
+    OperationStartedResult, RemoteChainHeadFollowItem as V01RemoteChainHeadFollowItem,
+    StorageQueryType,
+};
+use truapi_platform::Platform;
+
+impl<P> PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    /// Resolve usernames for `session` against this runtime's people chain.
+    #[instrument(skip_all, fields(runtime.method = "session.identity.resolve"))]
+    pub(super) async fn resolve_session_identity(&self, session: SessionInfo) -> SessionInfo {
+        resolve_session_identity_with_chain(
+            &self.chain,
+            self.runtime_config.people_chain_genesis_hash,
+            session,
+        )
+        .await
+    }
+}
+
+static IDENTITY_LOOKUP_COUNTER: AtomicU64 = AtomicU64::new(1);
+
+/// Fill in missing usernames by querying the people chain; returns the
+/// session unchanged when it already carries a username or no people chain
+/// is configured.
+#[instrument(skip_all, fields(runtime.method = "session.identity.resolve_with_chain"))]
+pub(super) async fn resolve_session_identity_with_chain(
+    chain: &ChainRuntime,
+    people_chain_genesis_hash: [u8; 32],
+    mut session: SessionInfo,
+) -> SessionInfo {
+    if session_has_username(&session) || people_chain_genesis_hash == [0; 32] {
+        return session;
+    }
+
+    let preferred_account = session.identity_account_id.unwrap_or(session.public_key);
+    match lookup_people_identity(chain, people_chain_genesis_hash, preferred_account).await {
+        Ok(Some(identity)) => {
+            debug!(
+                account = %hex::encode(preferred_account),
+                lite_username = identity.lite_username.as_deref().unwrap_or(""),
+                full_username = identity.full_username.as_deref().unwrap_or(""),
+                "People-chain identity lookup found username"
+            );
+            apply_people_identity(&mut session, identity);
+            return session;
+        }
+        Ok(None) => debug!(
+            account = %hex::encode(preferred_account),
+            "People-chain identity lookup found no consumer record"
+        ),
+        Err(reason) => warn!(
+            account = %hex::encode(preferred_account),
+            %reason,
+            "People-chain identity lookup failed"
+        ),
+    }
+
+    if preferred_account != session.public_key {
+        match lookup_people_identity(chain, people_chain_genesis_hash, session.public_key).await {
+            Ok(Some(identity)) => {
+                debug!(
+                    account = %hex::encode(session.public_key),
+                    lite_username = identity.lite_username.as_deref().unwrap_or(""),
+                    full_username = identity.full_username.as_deref().unwrap_or(""),
+                    "People-chain root identity lookup found username"
+                );
+                apply_people_identity(&mut session, identity);
+            }
+            Ok(None) => debug!(
+                account = %hex::encode(session.public_key),
+                "People-chain root identity lookup found no consumer record"
+            ),
+            Err(reason) => warn!(
+                account = %hex::encode(session.public_key),
+                %reason,
+                "People-chain root identity lookup failed"
+            ),
+        }
+    }
+
+    session
+}
+
+fn session_has_username(session: &SessionInfo) -> bool {
+    session
+        .full_username
+        .as_ref()
+        .is_some_and(|value| !value.is_empty())
+        || session
+            .lite_username
+            .as_ref()
+            .is_some_and(|value| !value.is_empty())
+}
+
+fn apply_people_identity(session: &mut SessionInfo, identity: PeopleIdentity) {
+    if identity
+        .full_username
+        .as_ref()
+        .is_some_and(|value| !value.is_empty())
+    {
+        session.full_username = identity.full_username;
+    }
+    if identity
+        .lite_username
+        .as_ref()
+        .is_some_and(|value| !value.is_empty())
+    {
+        session.lite_username = identity.lite_username;
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "session.identity.lookup"))]
+async fn lookup_people_identity(
+    chain: &ChainRuntime,
+    people_chain_genesis_hash: [u8; 32],
+    account_id: [u8; 32],
+) -> Result<Option<PeopleIdentity>, String> {
+    let genesis_hash = people_chain_genesis_hash.to_vec();
+    let key = resources_consumers_storage_key(&account_id);
+    let follow_id = format!(
+        "truapi:identity:{}:{}",
+        IDENTITY_LOOKUP_COUNTER.fetch_add(1, Ordering::Relaxed),
+        hex::encode(account_id),
+    );
+    let mut follow = chain.remote_chain_head_follow(
+        follow_id.clone(),
+        v01::RemoteChainHeadFollowRequest {
+            genesis_hash: genesis_hash.clone(),
+            with_runtime: false,
+        },
+    );
+
+    let hash = wait_for_identity_follow_hash(&mut follow).await?;
+    let response = chain
+        .remote_chain_head_storage(v01::RemoteChainHeadStorageRequest {
+            genesis_hash,
+            follow_subscription_id: follow_id,
+            hash,
+            items: vec![v01::StorageQueryItem {
+                key: key.clone(),
+                query_type: StorageQueryType::Value,
+            }],
+            child_trie: None,
+        })
+        .await
+        .map_err(|failure| failure.reason())?;
+
+    let operation_id = match response.operation {
+        OperationStartedResult::Started { operation_id } => operation_id,
+        OperationStartedResult::LimitReached => {
+            return Err("People-chain storage lookup limit reached".to_string());
+        }
+    };
+    let Some(value) = wait_for_identity_storage_value(&mut follow, &operation_id, &key).await?
+    else {
+        return Ok(None);
+    };
+    decode_people_identity(&value).map(Some)
+}
+
+#[instrument(skip_all, fields(runtime.method = "session.identity.wait_follow_hash"))]
+async fn wait_for_identity_follow_hash(
+    follow: &mut BoxStream<'static, V01RemoteChainHeadFollowItem>,
+) -> Result<Vec<u8>, String> {
+    let timeout = futures_timer::Delay::new(Duration::from_secs(10)).fuse();
+    pin_mut!(timeout);
+    loop {
+        let next = follow.next().fuse();
+        pin_mut!(next);
+        futures::select! {
+            item = next => match item {
+                Some(V01RemoteChainHeadFollowItem::Initialized { finalized_block_hashes, .. }) => {
+                    let fallback = finalized_block_hashes.last().cloned();
+                    return wait_for_identity_best_hash(follow, fallback).await;
+                }
+                Some(V01RemoteChainHeadFollowItem::BestBlockChanged { best_block_hash }) => {
+                    return Ok(best_block_hash);
+                }
+                Some(V01RemoteChainHeadFollowItem::Stop) | None => {
+                    return Err("People-chain follow stopped before initialization".to_string());
+                }
+                _ => {}
+            },
+            () = timeout => return Err("People-chain follow initialization timed out".to_string()),
+        }
+    }
+}
+
+async fn wait_for_identity_best_hash(
+    follow: &mut BoxStream<'static, V01RemoteChainHeadFollowItem>,
+    fallback: Option<Vec<u8>>,
+) -> Result<Vec<u8>, String> {
+    let timeout = futures_timer::Delay::new(Duration::from_secs(2)).fuse();
+    pin_mut!(timeout);
+    let mut candidate = fallback;
+    loop {
+        let next = follow.next().fuse();
+        pin_mut!(next);
+        futures::select! {
+            item = next => match item {
+                Some(V01RemoteChainHeadFollowItem::BestBlockChanged { best_block_hash }) => {
+                    return Ok(best_block_hash);
+                }
+                Some(V01RemoteChainHeadFollowItem::NewBlock { block_hash, .. }) => {
+                    candidate = Some(block_hash);
+                }
+                Some(V01RemoteChainHeadFollowItem::Stop) | None => {
+                    return candidate.ok_or_else(|| {
+                        "People-chain follow stopped before best block".to_string()
+                    });
+                }
+                _ => {}
+            },
+            () = timeout => {
+                return candidate.ok_or_else(|| {
+                    "People-chain follow best block timed out".to_string()
+                });
+            },
+        }
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "session.identity.wait_storage_value"))]
+async fn wait_for_identity_storage_value(
+    follow: &mut BoxStream<'static, V01RemoteChainHeadFollowItem>,
+    operation_id: &str,
+    key: &[u8],
+) -> Result<Option<Vec<u8>>, String> {
+    let timeout = futures_timer::Delay::new(Duration::from_secs(10)).fuse();
+    pin_mut!(timeout);
+    let mut value = None;
+    loop {
+        let next = follow.next().fuse();
+        pin_mut!(next);
+        futures::select! {
+            item = next => match item {
+                Some(V01RemoteChainHeadFollowItem::OperationStorageItems { operation_id: item_operation_id, items })
+                    if item_operation_id == operation_id =>
+                {
+                    for item in items {
+                        if item.key == key {
+                            value = item.value;
+                        }
+                    }
+                }
+                Some(V01RemoteChainHeadFollowItem::OperationStorageDone { operation_id: item_operation_id })
+                    if item_operation_id == operation_id =>
+                {
+                    return Ok(value);
+                }
+                Some(V01RemoteChainHeadFollowItem::OperationInaccessible { operation_id: item_operation_id })
+                    if item_operation_id == operation_id =>
+                {
+                    return Ok(None);
+                }
+                Some(V01RemoteChainHeadFollowItem::OperationError { operation_id: item_operation_id, error })
+                    if item_operation_id == operation_id =>
+                {
+                    return Err(error);
+                }
+                Some(V01RemoteChainHeadFollowItem::Stop) | None => {
+                    return Err("People-chain follow stopped during storage lookup".to_string());
+                }
+                _ => {}
+            },
+            () = timeout => return Err("People-chain storage lookup timed out".to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::stream;
+
+    #[test]
+    fn identity_follow_prefers_best_block_after_initialization() {
+        let mut follow = stream::iter(vec![
+            V01RemoteChainHeadFollowItem::Initialized {
+                finalized_block_hashes: vec![vec![0x01]],
+                finalized_block_runtime: None,
+            },
+            V01RemoteChainHeadFollowItem::BestBlockChanged {
+                best_block_hash: vec![0x02],
+            },
+        ])
+        .boxed();
+
+        let hash = futures::executor::block_on(wait_for_identity_follow_hash(&mut follow))
+            .expect("best hash should resolve");
+
+        assert_eq!(hash, vec![0x02]);
+    }
+
+    #[test]
+    fn identity_follow_uses_new_block_before_stale_finalized_fallback() {
+        let mut follow = stream::iter(vec![
+            V01RemoteChainHeadFollowItem::Initialized {
+                finalized_block_hashes: vec![vec![0x01]],
+                finalized_block_runtime: None,
+            },
+            V01RemoteChainHeadFollowItem::NewBlock {
+                block_hash: vec![0x03],
+                parent_block_hash: vec![0x01],
+                new_runtime: None,
+            },
+            V01RemoteChainHeadFollowItem::Stop,
+        ])
+        .boxed();
+
+        let hash = futures::executor::block_on(wait_for_identity_follow_hash(&mut follow))
+            .expect("new block hash should resolve");
+
+        assert_eq!(hash, vec![0x03]);
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime/sso_pairing.rs b/rust/crates/truapi-server/src/runtime/sso_pairing.rs
new file mode 100644
index 00000000..ee748b8e
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime/sso_pairing.rs
@@ -0,0 +1,996 @@
+//! SSO pairing (login): presents the pairing deeplink, watches the bootstrap
+//! topic on the statement store (live subscription plus periodic snapshot
+//! queries), and decrypts the wallet's V2 handshake response into a session.
+
+use std::sync::{Arc, Mutex};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
+#[cfg(target_arch = "wasm32")]
+use web_time::Duration;
+
+use super::auth_state::AuthStateMachine;
+use super::sso_remote::SharedRemoteSubscriptionId;
+use super::{PlatformRuntimeHost, connected_session_ui_info};
+use crate::host_logic::session::{SessionInfo, encode_persisted_session};
+use crate::host_logic::sso_pairing::{
+    EncryptedHandshakeResponseV2, PairingBootstrap, PairingDeviceIdentity,
+    VersionedHandshakeResponse, create_pairing_bootstrap_from_identity, decode_app_handshake_data,
+    decrypt_v2_handshake_response, establish_sso_session_info, generate_pairing_device_identity,
+};
+use crate::host_logic::statement_store::{
+    decode_verified_statement_data, parse_new_statements, parse_subscribe_ack,
+    subscribe_match_all_request, unsubscribe_request,
+};
+
+use futures::channel::oneshot;
+use futures::stream::BoxStream;
+use futures::{FutureExt, StreamExt, pin_mut};
+use parity_scale_codec::{Decode, Encode};
+use tracing::{debug, info, instrument, warn};
+use truapi::CallError;
+use truapi::v01;
+use truapi::versioned::account::{HostRequestLoginError, HostRequestLoginResponse};
+use truapi_platform::{
+    ChainProvider as PlatformChainProvider, JsonRpcConnection, Platform,
+    SessionStore as PlatformSessionStore, Storage as PlatformStorage,
+};
+
+/// Request id for the long-lived pairing topic subscription.
+pub(crate) const PAIRING_SUBSCRIBE_REQUEST_ID: &str = "truapi:sso-pairing:1";
+/// Local-storage key persisting the pairing device identity between logins.
+pub(super) const PAIRING_DEVICE_IDENTITY_STORAGE_KEY: &str = "truapi:sso-device-identity:v1";
+#[cfg(not(test))]
+const PAIRING_QUERY_INTERVAL: Duration = Duration::from_secs(2);
+#[cfg(test)]
+const PAIRING_QUERY_INTERVAL: Duration = Duration::from_millis(1);
+#[cfg(not(test))]
+const PAIRING_QUERY_TIMEOUT_TICKS: u8 = 15;
+#[cfg(test)]
+const PAIRING_QUERY_TIMEOUT_TICKS: u8 = 10;
+
+struct PairingSubscriptionGuard {
+    connection: Box<dyn JsonRpcConnection>,
+    unsubscribe_request_id: String,
+    remote_subscription_id: SharedRemoteSubscriptionId,
+}
+
+impl PairingSubscriptionGuard {
+    fn new(connection: Box<dyn JsonRpcConnection>) -> Self {
+        Self {
+            connection,
+            unsubscribe_request_id: format!("{PAIRING_SUBSCRIBE_REQUEST_ID}:unsubscribe"),
+            remote_subscription_id: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    fn remote_subscription_id(&self) -> SharedRemoteSubscriptionId {
+        self.remote_subscription_id.clone()
+    }
+}
+
+impl Drop for PairingSubscriptionGuard {
+    fn drop(&mut self) {
+        if let Some(remote_subscription_id) = self
+            .remote_subscription_id
+            .lock()
+            .expect("pairing subscription id mutex poisoned")
+            .as_ref()
+        {
+            self.connection.send(unsubscribe_request(
+                &self.unsubscribe_request_id,
+                remote_subscription_id,
+            ));
+        }
+    }
+}
+
+/// Terminal outcome of [`PlatformRuntimeHost::run_pairing_flow`].
+enum PairingFlowOutcome {
+    /// The login was cancelled (host `cancel_login`, `disconnect`, or a
+    /// cross-tab session win).
+    Cancelled,
+    /// Wallet handshake completed; the session is resolved and persisted.
+    Success(Box<SessionInfo>),
+}
+
+/// Resets a `Pairing` state left behind by a dropped login future (e.g. the
+/// ws-bridge dropping in-flight calls on connection close). A no-op once the
+/// flow reached any terminal transition or a newer pairing took over.
+struct AbandonedPairingGuard<P: Platform> {
+    auth_state: AuthStateMachine<P>,
+    epoch: u64,
+}
+
+impl<P: Platform> Drop for AbandonedPairingGuard<P> {
+    fn drop(&mut self) {
+        self.auth_state.reset_abandoned_pairing(self.epoch);
+    }
+}
+
+impl<P> PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    /// `request_login` pairing flow: emits `AuthState::Pairing` for the host
+    /// to present, then races host cancellation against the wallet handshake
+    /// arriving on the statement store; on success resolves identity and
+    /// persists the new session.
+    pub(super) async fn request_login_flow(
+        &self,
+    ) -> Result<HostRequestLoginResponse, CallError<HostRequestLoginError>> {
+        if let Some(session) = self.session_state.current() {
+            debug!("request_login: already connected, returning early");
+            self.auth_state
+                .connected(&connected_session_ui_info(&session));
+            return Ok(HostRequestLoginResponse::V1(
+                v01::HostRequestLoginResponse::AlreadyConnected,
+            ));
+        }
+
+        let pairing_identity = load_or_create_pairing_device_identity(self.platform.as_ref())
+            .await
+            .map_err(|reason| self.fail_before_pairing(reason))?;
+        let bootstrap =
+            create_pairing_bootstrap_from_identity(&self.runtime_config, pairing_identity)
+                .map_err(|err| self.fail_before_pairing(err.to_string()))?;
+
+        let Some((cancel_rx, pairing_epoch)) =
+            self.auth_state.pairing_started(bootstrap.deeplink.clone())
+        else {
+            return Err(CallError::Domain(HostRequestLoginError::V1(
+                v01::HostRequestLoginError::Unknown {
+                    reason: "login already in progress".to_string(),
+                },
+            )));
+        };
+        info!("presenting pairing QR, waiting for wallet handshake");
+        let _reset_guard = AbandonedPairingGuard {
+            auth_state: self.auth_state.clone(),
+            epoch: pairing_epoch,
+        };
+
+        match self.run_pairing_flow(&bootstrap, cancel_rx).await {
+            Ok(PairingFlowOutcome::Cancelled) => {
+                // `cancel_login` (or the cross-tab `connected` transition)
+                // already moved the auth state; only the call result is left
+                // to map. A session appearing mid-flow means another runtime
+                // won the login.
+                if self.session_state.current().is_some() {
+                    info!("login cancelled by a cross-runtime session win");
+                    Ok(HostRequestLoginResponse::V1(
+                        v01::HostRequestLoginResponse::AlreadyConnected,
+                    ))
+                } else {
+                    info!("login cancelled before handshake, login rejected");
+                    Ok(HostRequestLoginResponse::V1(
+                        v01::HostRequestLoginResponse::Rejected,
+                    ))
+                }
+            }
+            Ok(PairingFlowOutcome::Success(session)) => {
+                self.auth_state
+                    .connected(&connected_session_ui_info(&session));
+                self.session_state.set_session(*session);
+                info!("login succeeded, SSO session established");
+                Ok(HostRequestLoginResponse::V1(
+                    v01::HostRequestLoginResponse::Success,
+                ))
+            }
+            Err(reason) => {
+                self.auth_state.login_failed(reason.clone());
+                Err(CallError::HostFailure { reason })
+            }
+        }
+    }
+
+    /// Emit `LoginFailed` for an error raised before the pairing was entered
+    /// and map it onto the `request_login` error shape.
+    fn fail_before_pairing(&self, reason: String) -> CallError<HostRequestLoginError> {
+        self.auth_state.login_failed_before_pairing(reason.clone());
+        CallError::Domain(HostRequestLoginError::V1(
+            v01::HostRequestLoginError::Unknown { reason },
+        ))
+    }
+
+    /// Everything between the `Pairing` emission and a terminal outcome.
+    /// Every error returned here maps to `AuthState::LoginFailed` at the
+    /// single exit in [`Self::request_login_flow`].
+    async fn run_pairing_flow(
+        &self,
+        bootstrap: &PairingBootstrap,
+        cancel_rx: oneshot::Receiver<()>,
+    ) -> Result<PairingFlowOutcome, String> {
+        let mut cancel = cancel_rx.fuse();
+        let statement_store_connect = PlatformChainProvider::connect(
+            self.platform.as_ref(),
+            self.runtime_config.people_chain_genesis_hash.to_vec(),
+        )
+        .fuse();
+        pin_mut!(statement_store_connect);
+
+        let statement_store = futures::select! {
+            _ = cancel => return Ok(PairingFlowOutcome::Cancelled),
+            connect_result = statement_store_connect => connect_result.map_err(|err| {
+                format!("pairing statement-store connect failed: {err:?}")
+            })?,
+        };
+        statement_store.send(subscribe_match_all_request(
+            PAIRING_SUBSCRIBE_REQUEST_ID,
+            &[bootstrap.topic],
+        ));
+        debug!("subscribed to pairing topic, polling statement store");
+        let responses = statement_store.responses();
+        let subscription_guard = PairingSubscriptionGuard::new(statement_store);
+        let pairing_response = wait_for_v2_pairing_success(
+            subscription_guard.connection.as_ref(),
+            responses,
+            subscription_guard.remote_subscription_id(),
+            bootstrap.topic,
+            bootstrap.encryption_secret_key,
+        )
+        .fuse();
+        pin_mut!(pairing_response);
+
+        let response = futures::select! {
+            _ = cancel => return Ok(PairingFlowOutcome::Cancelled),
+            response_result = pairing_response => response_result?,
+        };
+        let sso = establish_sso_session_info(
+            bootstrap,
+            response.peer_statement_account_id,
+            response.success.sso_enc_pub_key,
+        )?;
+        let session = SessionInfo {
+            public_key: response.success.root_account_id,
+            sso: Some(sso),
+            root_entropy_source: Some(response.success.root_entropy_source),
+            identity_account_id: Some(response.success.identity_account_id),
+            lite_username: None,
+            full_username: None,
+        };
+        let session = self.resolve_session_identity(session).await;
+        PlatformSessionStore::write_session(
+            self.platform.as_ref(),
+            encode_persisted_session(&session),
+        )
+        .await
+        .map_err(|err| format!("session persist failed: {err:?}"))?;
+        Ok(PairingFlowOutcome::Success(Box::new(session)))
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.pairing_device.load_or_create"))]
+async fn load_or_create_pairing_device_identity(
+    storage: &(impl PlatformStorage + ?Sized),
+) -> Result<PairingDeviceIdentity, String> {
+    if let Some(raw) =
+        PlatformStorage::read(storage, PAIRING_DEVICE_IDENTITY_STORAGE_KEY.to_string())
+            .await
+            .map_err(|err| format!("pairing device identity read failed: {err:?}"))?
+    {
+        match PairingDeviceIdentity::decode(&mut raw.as_slice()) {
+            Ok(identity) => return Ok(identity),
+            Err(err) => {
+                warn!("stored pairing device identity is invalid, regenerating: {err}");
+                let _ = PlatformStorage::clear(
+                    storage,
+                    PAIRING_DEVICE_IDENTITY_STORAGE_KEY.to_string(),
+                )
+                .await;
+            }
+        }
+    }
+
+    let identity = generate_pairing_device_identity()
+        .map_err(|err| format!("pairing identity failed: {err}"))?;
+    PlatformStorage::write(
+        storage,
+        PAIRING_DEVICE_IDENTITY_STORAGE_KEY.to_string(),
+        identity.encode(),
+    )
+    .await
+    .map_err(|err| format!("pairing device identity write failed: {err:?}"))?;
+    Ok(identity)
+}
+
+struct PairingSuccess {
+    peer_statement_account_id: [u8; 32],
+    success: crate::host_logic::sso_pairing::HandshakeSuccessV2,
+}
+
+#[derive(Default)]
+struct PairingFrameState {
+    remote_subscription_id: Option<String>,
+    query: PairingQueryState,
+}
+
+#[derive(Default)]
+enum PairingQueryState {
+    #[default]
+    Idle,
+    AwaitingAck {
+        request_id: String,
+        elapsed_ticks: u8,
+    },
+    Active {
+        request_id: String,
+        remote_id: String,
+        elapsed_ticks: u8,
+    },
+}
+
+impl PairingQueryState {
+    fn request_id(&self) -> Option<&str> {
+        match self {
+            Self::Idle => None,
+            Self::AwaitingAck { request_id, .. } | Self::Active { request_id, .. } => {
+                Some(request_id)
+            }
+        }
+    }
+
+    fn remote_id(&self) -> Option<&str> {
+        match self {
+            Self::Active { remote_id, .. } => Some(remote_id),
+            Self::Idle | Self::AwaitingAck { .. } => None,
+        }
+    }
+
+    fn is_idle(&self) -> bool {
+        matches!(self, Self::Idle)
+    }
+
+    fn start(&mut self, request_id: String) {
+        *self = Self::AwaitingAck {
+            request_id,
+            elapsed_ticks: 0,
+        };
+    }
+
+    fn activate(&mut self, request_id: String, remote_id: String) {
+        *self = Self::Active {
+            request_id,
+            remote_id,
+            elapsed_ticks: 0,
+        };
+    }
+
+    fn finish(&mut self) {
+        *self = Self::Idle;
+    }
+
+    fn tick_timeout(&mut self) -> Option<(String, String)> {
+        match self {
+            Self::Idle => None,
+            Self::AwaitingAck { elapsed_ticks, .. } => {
+                *elapsed_ticks = elapsed_ticks.saturating_add(1);
+                if *elapsed_ticks >= PAIRING_QUERY_TIMEOUT_TICKS {
+                    *self = Self::Idle;
+                }
+                None
+            }
+            Self::Active {
+                request_id,
+                remote_id,
+                elapsed_ticks,
+            } => {
+                *elapsed_ticks = elapsed_ticks.saturating_add(1);
+                if *elapsed_ticks < PAIRING_QUERY_TIMEOUT_TICKS {
+                    return None;
+                }
+                let timeout = Some((request_id.clone(), remote_id.clone()));
+                *self = Self::Idle;
+                timeout
+            }
+        }
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.pairing.wait_success"))]
+async fn wait_for_v2_pairing_success(
+    connection: &dyn JsonRpcConnection,
+    mut responses: BoxStream<'static, String>,
+    remote_subscription_slot: SharedRemoteSubscriptionId,
+    topic: [u8; 32],
+    core_encryption_secret_key: [u8; 32],
+) -> Result<PairingSuccess, String> {
+    let mut state = PairingFrameState::default();
+    let mut query_counter = 0usize;
+    let poll = futures_timer::Delay::new(PAIRING_QUERY_INTERVAL).fuse();
+    pin_mut!(poll);
+    loop {
+        futures::select! {
+            frame = responses.next().fuse() => {
+                let Some(frame) = frame else {
+                    return Err("pairing statement-store response stream ended".to_string());
+                };
+                if let Some(success) = handle_v2_pairing_frame(
+                    connection,
+                    &frame,
+                    &mut state,
+                    &remote_subscription_slot,
+                    core_encryption_secret_key,
+                )? {
+                    return Ok(success);
+                }
+            }
+            _ = poll => {
+                if let Some((request_id, remote_id)) = state.query.tick_timeout() {
+                    connection.send(unsubscribe_request(
+                        &format!("{request_id}:timeout-unsubscribe"),
+                        &remote_id,
+                    ));
+                }
+                if state.query.is_idle() {
+                    query_counter += 1;
+                    let query_request_id =
+                        format!("{PAIRING_SUBSCRIBE_REQUEST_ID}:query:{query_counter}");
+                    connection.send(subscribe_match_all_request(&query_request_id, &[topic]));
+                    state.query.start(query_request_id);
+                }
+                poll.set(futures_timer::Delay::new(PAIRING_QUERY_INTERVAL).fuse());
+            }
+        }
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.pairing.handle_frame"))]
+fn handle_v2_pairing_frame(
+    connection: &dyn JsonRpcConnection,
+    frame: &str,
+    state: &mut PairingFrameState,
+    remote_subscription_slot: &SharedRemoteSubscriptionId,
+    core_encryption_secret_key: [u8; 32],
+) -> Result<Option<PairingSuccess>, String> {
+    if state.remote_subscription_id.is_none()
+        && let Some(id) = parse_subscribe_ack(frame, PAIRING_SUBSCRIBE_REQUEST_ID)
+            .map_err(|err| err.to_string())?
+    {
+        *remote_subscription_slot
+            .lock()
+            .expect("pairing subscription id mutex poisoned") = Some(id.clone());
+        state.remote_subscription_id = Some(id);
+        return Ok(None);
+    }
+    if let Some((query_request_id, id)) =
+        parse_pairing_query_subscribe_ack(frame, state.query.request_id())?
+    {
+        state.query.activate(query_request_id, id);
+        return Ok(None);
+    }
+
+    let Some(page) = parse_new_statements(frame).map_err(|err| err.to_string())? else {
+        return Ok(None);
+    };
+    let is_live_subscription =
+        Some(page.remote_subscription_id.as_str()) == state.remote_subscription_id.as_deref();
+    let is_query_subscription =
+        Some(page.remote_subscription_id.as_str()) == state.query.remote_id();
+    if !is_live_subscription && !is_query_subscription {
+        return Ok(None);
+    }
+
+    if is_query_subscription && page.remaining.unwrap_or(0) == 0 {
+        if let Some(request_id) = state.query.request_id() {
+            connection.send(unsubscribe_request(
+                &format!("{request_id}:unsubscribe"),
+                &page.remote_subscription_id,
+            ));
+        }
+        state.query.finish();
+    }
+    for statement in page.statements {
+        if let Some(success) = decode_v2_pairing_statement(&statement, core_encryption_secret_key)?
+        {
+            return Ok(Some(success));
+        }
+    }
+
+    Ok(None)
+}
+
+fn parse_pairing_query_subscribe_ack(
+    frame: &str,
+    pending_query_request_id: Option<&str>,
+) -> Result<Option<(String, String)>, String> {
+    let value: serde_json::Value = serde_json::from_str(frame).map_err(|err| err.to_string())?;
+    let Some(request_id) = value.get("id").and_then(serde_json::Value::as_str) else {
+        return Ok(None);
+    };
+    let is_pending_query = pending_query_request_id == Some(request_id);
+    let is_pairing_query = request_id
+        .strip_prefix(PAIRING_SUBSCRIBE_REQUEST_ID)
+        .is_some_and(|suffix| suffix.starts_with(":query:"));
+    if !is_pending_query && !is_pairing_query {
+        return Ok(None);
+    }
+    if value
+        .get("method")
+        .and_then(serde_json::Value::as_str)
+        .is_some()
+        && value.get("params").is_some()
+        && value.get("result").is_none()
+        && value.get("error").is_none()
+    {
+        return Ok(None);
+    }
+    if let Some(error) = value.get("error") {
+        return Err(error
+            .get("message")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or("statement-store query subscribe failed")
+            .to_string());
+    }
+    let Some(remote_id) = value.get("result").and_then(serde_json::Value::as_str) else {
+        return Ok(None);
+    };
+    Ok(Some((request_id.to_string(), remote_id.to_string())))
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.pairing.decode_statement"))]
+fn decode_v2_pairing_statement(
+    statement: &[u8],
+    core_encryption_secret_key: [u8; 32],
+) -> Result<Option<PairingSuccess>, String> {
+    let verified =
+        decode_verified_statement_data(statement, None).map_err(|err| err.to_string())?;
+    let handshake = decode_app_handshake_data(&verified.data)?;
+    let VersionedHandshakeResponse::V2 {
+        encrypted_message,
+        public_key,
+    } = handshake
+    else {
+        return Err("pairing response is not SSO V2".to_string());
+    };
+    match decrypt_v2_handshake_response(core_encryption_secret_key, public_key, &encrypted_message)?
+    {
+        EncryptedHandshakeResponseV2::Pending(_) => Ok(None),
+        EncryptedHandshakeResponseV2::Failed(reason) => Err(reason),
+        EncryptedHandshakeResponseV2::Success(success) => Ok(Some(PairingSuccess {
+            peer_statement_account_id: verified.signer,
+            success: *success,
+        })),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::{
+        StubPlatform, pairing_device_from_deeplink, peer_statement_keypair, runtime_config,
+        session_info, signed_test_statement, stub_platform, test_spawner,
+    };
+    use p256::elliptic_curve::sec1::ToEncodedPoint;
+    use truapi::CallContext;
+    use truapi::api::Account;
+    use truapi::versioned::account::{
+        HostAccountConnectionStatusSubscribeItem, HostRequestLoginRequest,
+    };
+    use truapi_platform::AuthState;
+
+    /// Cancel the login as soon as the host observes the `Pairing` state,
+    /// mimicking a user dismissing the pairing UI immediately.
+    fn cancel_on_pairing(platform: &StubPlatform, host: &Arc<PlatformRuntimeHost<StubPlatform>>) {
+        let host = host.clone();
+        *platform
+            .on_auth_state
+            .lock()
+            .expect("auth state hook mutex poisoned") = Some(Arc::new(move |state| {
+            if matches!(state, AuthState::Pairing { .. }) {
+                host.cancel_login();
+            }
+        }));
+    }
+
+    #[test]
+    fn request_login_presents_pairing_and_rejects_when_cancelled() {
+        let platform = stub_platform();
+        let host = Arc::new(PlatformRuntimeHost::new_compat(
+            platform.clone(),
+            test_spawner(),
+        ));
+        cancel_on_pairing(&platform, &host);
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        let auth_states = platform
+            .auth_states
+            .lock()
+            .expect("auth state list mutex poisoned");
+        assert_eq!(auth_states.len(), 2, "states: {auth_states:?}");
+        match &auth_states[0] {
+            AuthState::Pairing { deeplink } => {
+                assert!(deeplink.starts_with("polkadotapp://pair?handshake="));
+            }
+            other => panic!("expected pairing state first, got {other:?}"),
+        }
+        assert_eq!(auth_states[1], AuthState::Disconnected);
+
+        let sent_rpc = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        if let Some(sent) = sent_rpc.first() {
+            let request: serde_json::Value = serde_json::from_str(sent).unwrap();
+            assert_eq!(request["method"], "statement_subscribeStatement");
+            assert_eq!(
+                request["params"][0]["matchAll"][0].as_str().unwrap().len(),
+                66
+            );
+        }
+    }
+
+    #[test]
+    fn request_login_reuses_persisted_pairing_device_identity() {
+        let platform = stub_platform();
+        let host = Arc::new(PlatformRuntimeHost::new_compat(
+            platform.clone(),
+            test_spawner(),
+        ));
+        cancel_on_pairing(&platform, &host);
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+
+        let first = futures::executor::block_on(host.request_login(&cx, request.clone())).unwrap();
+        let second = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            first,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        assert_eq!(
+            second,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        let deeplinks: Vec<String> = platform
+            .auth_states
+            .lock()
+            .expect("auth state list mutex poisoned")
+            .iter()
+            .filter_map(|state| match state {
+                AuthState::Pairing { deeplink } => Some(deeplink.clone()),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(deeplinks.len(), 2);
+        assert_eq!(
+            pairing_device_from_deeplink(&deeplinks[0]),
+            pairing_device_from_deeplink(&deeplinks[1])
+        );
+        assert!(
+            platform
+                .local_storage
+                .lock()
+                .expect("local storage mutex poisoned")
+                .contains_key(PAIRING_DEVICE_IDENTITY_STORAGE_KEY)
+        );
+    }
+
+    #[test]
+    fn request_login_waits_for_pairing_statement() {
+        let wallet_ephemeral_secret = p256::SecretKey::from_slice(&[2; 32]).unwrap();
+        let wallet_ephemeral_public = wallet_ephemeral_secret.public_key().to_encoded_point(false);
+        let mut wallet_ephemeral_public_bytes = [0u8; 65];
+        wallet_ephemeral_public_bytes.copy_from_slice(wallet_ephemeral_public.as_bytes());
+        let handshake = crate::host_logic::sso_pairing::VersionedHandshakeResponse::V2 {
+            encrypted_message: vec![0xde, 0xad],
+            public_key: wallet_ephemeral_public_bytes,
+        };
+        let statement = signed_test_statement(handshake.encode());
+        let notification = format!(
+            r#"{{"jsonrpc":"2.0","method":"statement_subscribeStatement","params":{{"subscription":"remote-sub","result":{{"event":"newStatements","data":{{"statements":["0x{}"],"remaining":0}}}}}}}}"#,
+            hex::encode(statement)
+        );
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![
+                r#"{"jsonrpc":"2.0","id":"truapi:sso-pairing:1","result":"remote-sub"}"#
+                    .to_string(),
+                notification,
+            ],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let err = futures::executor::block_on(host.request_login(&cx, request)).unwrap_err();
+
+        match err {
+            CallError::HostFailure { reason } => {
+                assert_eq!(reason, "encrypted SSO handshake answer is too short");
+            }
+            other => panic!("expected handshake decrypt failure, got {other:?}"),
+        }
+        let sent_rpc = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        let methods = sent_rpc
+            .iter()
+            .map(|request| serde_json::from_str::<serde_json::Value>(request).unwrap())
+            .map(|request| request["method"].as_str().unwrap().to_string())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            methods.first().map(String::as_str),
+            Some("statement_subscribeStatement")
+        );
+        assert!(
+            methods
+                .iter()
+                .any(|method| method == "statement_unsubscribeStatement"),
+            "pairing subscription should be cleaned up"
+        );
+        let unsubscribe: serde_json::Value = serde_json::from_str(&sent_rpc[1]).unwrap();
+        assert_eq!(unsubscribe["params"][0], "remote-sub");
+    }
+
+    #[test]
+    fn request_login_accepts_valid_pairing_statement_and_persists_session() {
+        let session_writes = Arc::new(Mutex::new(Vec::new()));
+        let platform = Arc::new(StubPlatform {
+            pairing_success_response: true,
+            session_writes: session_writes.clone(),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let mut statuses = host.session_state().subscribe();
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Disconnected
+            )
+        );
+
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Success)
+        );
+        assert_eq!(
+            futures::executor::block_on(statuses.next()).unwrap(),
+            HostAccountConnectionStatusSubscribeItem::V1(
+                v01::HostAccountConnectionStatusSubscribeItem::Connected
+            )
+        );
+
+        let session = host
+            .session_state()
+            .current()
+            .expect("paired session should be active");
+        assert_eq!(session.public_key, session_info().public_key);
+        assert_eq!(session.root_entropy_source, Some([0x66; 32]));
+        assert_eq!(
+            session.sso.as_ref().unwrap().identity_account_id,
+            peer_statement_keypair().1
+        );
+
+        let writes = session_writes
+            .lock()
+            .expect("session write list mutex poisoned");
+        assert_eq!(writes.len(), 1);
+        assert_eq!(
+            crate::host_logic::session::decode_persisted_session(&writes[0]).unwrap(),
+            session
+        );
+
+        let auth_states = platform
+            .auth_states
+            .lock()
+            .expect("auth state list mutex poisoned");
+        assert_eq!(auth_states.len(), 2, "states: {auth_states:?}");
+        assert!(matches!(&auth_states[0], AuthState::Pairing { .. }));
+        assert_eq!(
+            auth_states[1],
+            AuthState::Connected(connected_session_ui_info(&session))
+        );
+        drop(auth_states);
+
+        let methods = platform
+            .sent_rpc
+            .lock()
+            .expect("rpc list mutex poisoned")
+            .iter()
+            .map(|request| serde_json::from_str::<serde_json::Value>(request).unwrap())
+            .map(|request| request["method"].as_str().unwrap().to_string())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            methods.first().map(String::as_str),
+            Some("statement_subscribeStatement")
+        );
+        assert!(
+            methods
+                .iter()
+                .any(|method| method == "statement_unsubscribeStatement"),
+            "pairing subscription should be cleaned up"
+        );
+    }
+
+    /// The pairing success must also be reachable through the core's own 2s
+    /// snapshot queries: the live subscription stays silent and the wallet
+    /// statement is delivered only on a query subscription page.
+    #[test]
+    fn request_login_accepts_pairing_statement_from_snapshot_query_page() {
+        let platform = Arc::new(StubPlatform {
+            pairing_success_via_query: true,
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Success)
+        );
+        assert_eq!(
+            host.session_state()
+                .current()
+                .map(|session| session.public_key),
+            Some(session_info().public_key)
+        );
+
+        let ids = platform
+            .sent_rpc
+            .lock()
+            .expect("rpc list mutex poisoned")
+            .iter()
+            .map(|request| serde_json::from_str::<serde_json::Value>(request).unwrap())
+            .map(|request| request["id"].as_str().unwrap().to_string())
+            .collect::<Vec<_>>();
+        assert!(
+            ids.iter()
+                .any(|id| id.starts_with("truapi:sso-pairing:1:query:")),
+            "core should issue snapshot queries while pairing: {ids:?}"
+        );
+        assert!(
+            ids.iter()
+                .any(|id| id.contains(":query:") && id.ends_with(":unsubscribe")),
+            "drained query subscription should be cleaned up: {ids:?}"
+        );
+    }
+
+    #[test]
+    fn pairing_query_parser_ignores_echoed_subscribe_request() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:sso-pairing:1:query:7","method":"statement_subscribeStatement","params":[{"matchAll":["0x0707070707070707070707070707070707070707070707070707070707070707"]}]}"#;
+
+        assert_eq!(
+            parse_pairing_query_subscribe_ack(frame, Some("truapi:sso-pairing:1:query:7")).unwrap(),
+            None
+        );
+        assert_eq!(
+            parse_pairing_query_subscribe_ack(frame, None).unwrap(),
+            None
+        );
+    }
+
+    #[test]
+    fn pairing_query_parser_ignores_no_result_subscribe_response() {
+        let frame = r#"{"jsonrpc":"2.0","id":"truapi:sso-pairing:1:query:7"}"#;
+
+        assert_eq!(
+            parse_pairing_query_subscribe_ack(frame, Some("truapi:sso-pairing:1:query:7")).unwrap(),
+            None
+        );
+        assert_eq!(
+            parse_pairing_query_subscribe_ack(frame, None).unwrap(),
+            None
+        );
+    }
+
+    #[test]
+    fn request_login_emits_login_failed_for_pre_pairing_errors() {
+        let platform = Arc::new(StubPlatform {
+            local_storage_error: Some("identity storage unavailable"),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new_compat(platform.clone(), test_spawner());
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let err = futures::executor::block_on(host.request_login(&cx, request)).unwrap_err();
+
+        assert!(matches!(err, CallError::Domain(_)));
+        let auth_states = platform
+            .auth_states
+            .lock()
+            .expect("auth state list mutex poisoned");
+        assert_eq!(auth_states.len(), 1, "states: {auth_states:?}");
+        assert!(matches!(&auth_states[0], AuthState::LoginFailed { reason }
+            if reason.contains("identity storage unavailable")));
+    }
+
+    #[test]
+    fn request_login_does_not_restore_persisted_session_before_pairing() {
+        let stored = session_info();
+        let platform = Arc::new(StubPlatform {
+            session_blob: Some(crate::host_logic::session::encode_persisted_session(
+                &stored,
+            )),
+            ..Default::default()
+        });
+        let host = Arc::new(PlatformRuntimeHost::new_compat(
+            platform.clone(),
+            test_spawner(),
+        ));
+        cancel_on_pairing(&platform, &host);
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        assert!(host.session_state().current().is_none());
+    }
+
+    #[test]
+    fn request_login_ignores_corrupt_persisted_session_before_pairing() {
+        let session_clears = Arc::new(Mutex::new(0));
+        let platform = Arc::new(StubPlatform {
+            session_blob: Some(vec![0xff]),
+            session_clears: session_clears.clone(),
+            ..Default::default()
+        });
+        let host = Arc::new(PlatformRuntimeHost::new_compat(
+            platform.clone(),
+            test_spawner(),
+        ));
+        cancel_on_pairing(&platform, &host);
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        assert!(host.session_state().current().is_none());
+        assert_eq!(*session_clears.lock().unwrap(), 0);
+    }
+
+    #[test]
+    fn request_login_ignores_session_store_failure_before_pairing() {
+        let platform = Arc::new(StubPlatform {
+            session_error: Some("storage failed"),
+            ..Default::default()
+        });
+        let host = Arc::new(PlatformRuntimeHost::new_compat(
+            platform.clone(),
+            test_spawner(),
+        ));
+        cancel_on_pairing(&platform, &host);
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::Rejected)
+        );
+        assert!(host.session_state().current().is_none());
+    }
+
+    #[test]
+    fn request_login_returns_already_connected_when_session_exists() {
+        let host = PlatformRuntimeHost::new_compat(stub_platform(), test_spawner());
+        host.session_state().set_session(session_info());
+        let cx = CallContext::new();
+        let request = HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None });
+        let response = futures::executor::block_on(host.request_login(&cx, request)).unwrap();
+        assert_eq!(
+            response,
+            HostRequestLoginResponse::V1(v01::HostRequestLoginResponse::AlreadyConnected)
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime/sso_remote.rs b/rust/crates/truapi-server/src/runtime/sso_remote.rs
new file mode 100644
index 00000000..223bfaef
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime/sso_remote.rs
@@ -0,0 +1,604 @@
+//! SSO remote messaging over the people-chain statement store: submits an
+//! encrypted request statement to the paired wallet and waits for the
+//! matching response, honoring timeouts and local/peer disconnect signals.
+
+use std::sync::{Arc, Mutex};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
+#[cfg(target_arch = "wasm32")]
+use web_time::Duration;
+
+use super::PlatformRuntimeHost;
+use crate::host_logic::session::{SessionInfo, SsoSessionInfo};
+use crate::host_logic::sso_messages::{
+    RemoteMessage, RemoteMessageData, RemoteMessageV1, SsoRemoteResponse, SsoSessionStatement,
+    build_outgoing_request_statement, decode_sso_session_statement,
+};
+use crate::host_logic::statement_store::{
+    current_unix_secs, parse_new_statements, parse_submit_ack, parse_subscribe_ack,
+    submit_statement_request, subscribe_match_all_request, unsubscribe_request,
+};
+
+use futures::channel::oneshot;
+use futures::stream::BoxStream;
+use futures::{FutureExt, StreamExt, pin_mut};
+use tracing::{debug, instrument, warn};
+use truapi::CallContext;
+use truapi_platform::{ChainProvider as PlatformChainProvider, JsonRpcConnection, Platform};
+
+const DEFAULT_SSO_STATEMENT_EXPIRY_SECS: u64 = 7 * 24 * 60 * 60;
+const DEFAULT_SSO_RESPONSE_TIMEOUT: Duration = Duration::from_secs(180);
+/// Disconnect reason reported when the local session logs out mid-request.
+pub(super) const SSO_LOCAL_DISCONNECT_REASON: &str = "SSO session disconnected";
+/// Disconnect reason reported when the paired wallet announces a disconnect.
+pub(super) const SSO_PEER_DISCONNECT_REASON: &str = "SSO peer disconnected";
+
+/// Registry of oneshot waiters resolved when the SSO session disconnects.
+#[derive(Default)]
+pub(super) struct SessionDisconnects {
+    inner: Mutex<SessionDisconnectsInner>,
+}
+
+#[derive(Default)]
+struct SessionDisconnectsInner {
+    next_id: u64,
+    waiters: Vec<(u64, oneshot::Sender<String>)>,
+}
+
+impl SessionDisconnects {
+    /// Register a waiter; returns its id and the disconnect-reason receiver.
+    pub(super) fn subscribe(&self) -> (u64, oneshot::Receiver<String>) {
+        let (tx, rx) = oneshot::channel();
+        let mut inner = self
+            .inner
+            .lock()
+            .expect("session disconnect mutex poisoned");
+        inner.next_id = inner.next_id.wrapping_add(1);
+        let id = inner.next_id;
+        inner.waiters.push((id, tx));
+        (id, rx)
+    }
+
+    fn unsubscribe(&self, id: u64) {
+        self.inner
+            .lock()
+            .expect("session disconnect mutex poisoned")
+            .waiters
+            .retain(|(waiter_id, _)| *waiter_id != id);
+    }
+
+    /// Resolve every pending waiter with `reason`.
+    pub(super) fn notify(&self, reason: &'static str) {
+        let waiters = {
+            let mut inner = self
+                .inner
+                .lock()
+                .expect("session disconnect mutex poisoned");
+            std::mem::take(&mut inner.waiters)
+        };
+        for (_, waiter) in waiters {
+            let _ = waiter.send(reason.to_string());
+        }
+    }
+}
+
+impl<P> PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    /// Best-effort `Disconnected` notification to the SSO peer.
+    #[instrument(skip_all, fields(runtime.method = "sso.disconnect.submit"))]
+    pub(super) async fn submit_sso_disconnected(
+        &self,
+        session: &SessionInfo,
+    ) -> Result<(), String> {
+        let sso = session
+            .sso
+            .as_ref()
+            .ok_or_else(|| "No SSO session state".to_string())?;
+        let message_id = "truapi:sso:disconnect".to_string();
+        let message = RemoteMessage {
+            message_id: message_id.clone(),
+            data: RemoteMessageData::V1(RemoteMessageV1::Disconnected),
+        };
+        let statement = build_outgoing_request_statement(
+            sso,
+            message_id.clone(),
+            vec![message],
+            fresh_statement_expiry(),
+        )?;
+        let connection = PlatformChainProvider::connect(
+            self.platform.as_ref(),
+            self.runtime_config.people_chain_genesis_hash.to_vec(),
+        )
+        .await
+        .map_err(|err| format!("SSO statement-store connect failed: {err:?}"))?;
+        connection.send(submit_statement_request(
+            &format!("truapi:sso-submit:{message_id}"),
+            &statement,
+        ));
+        Ok(())
+    }
+
+    /// Submit an SSO remote message and wait for the wallet response with
+    /// the default timeout.
+    #[instrument(skip_all, fields(runtime.method = "sso.remote_message.submit", action = action))]
+    pub(super) async fn submit_sso_remote_message(
+        &self,
+        cx: &CallContext,
+        session: &SessionInfo,
+        action: &str,
+        message: RemoteMessage,
+    ) -> Result<SsoRemoteResponse, String> {
+        self.submit_sso_remote_message_with_timeout(
+            cx,
+            session,
+            action,
+            message,
+            Some(DEFAULT_SSO_RESPONSE_TIMEOUT),
+        )
+        .await
+    }
+
+    /// Submit an SSO remote message and wait for the wallet response without
+    /// a deadline (used for flows that block on user interaction).
+    #[instrument(skip_all, fields(runtime.method = "sso.remote_message.submit_without_timeout", action = action))]
+    pub(super) async fn submit_sso_remote_message_without_timeout(
+        &self,
+        cx: &CallContext,
+        session: &SessionInfo,
+        action: &str,
+        message: RemoteMessage,
+    ) -> Result<SsoRemoteResponse, String> {
+        self.submit_sso_remote_message_with_timeout(cx, session, action, message, None)
+            .await
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "sso.remote_message.submit_with_timeout", action = action))]
+    async fn submit_sso_remote_message_with_timeout(
+        &self,
+        cx: &CallContext,
+        session: &SessionInfo,
+        action: &str,
+        message: RemoteMessage,
+        timeout: Option<Duration>,
+    ) -> Result<SsoRemoteResponse, String> {
+        let sso = session
+            .sso
+            .as_ref()
+            .ok_or_else(|| "No SSO session state".to_string())?;
+        let message_id = sso_message_id(cx, action);
+        let statement = build_outgoing_request_statement(
+            sso,
+            message_id.clone(),
+            vec![message],
+            fresh_statement_expiry(),
+        )?;
+        let connection = PlatformChainProvider::connect(
+            self.platform.as_ref(),
+            self.runtime_config.people_chain_genesis_hash.to_vec(),
+        )
+        .await
+        .map_err(|err| format!("SSO statement-store connect failed: {err:?}"))?;
+        let own_subscription_request_id = format!("truapi:sso-sub-own:{message_id}");
+        let peer_subscription_request_id = format!("truapi:sso-sub-peer:{message_id}");
+        let submit_request_id = format!("truapi:sso-submit:{message_id}");
+        connection.send(subscribe_match_all_request(
+            &own_subscription_request_id,
+            &[sso.session_id_own],
+        ));
+        connection.send(subscribe_match_all_request(
+            &peer_subscription_request_id,
+            &[sso.session_id_peer],
+        ));
+        connection.send(submit_statement_request(&submit_request_id, &statement));
+        debug!(action, %message_id, "submitted SSO remote message, awaiting response");
+        let responses = connection.responses();
+        let subscription_guard = SsoRemoteSubscriptionGuard::new(
+            connection,
+            own_subscription_request_id.clone(),
+            peer_subscription_request_id.clone(),
+        );
+        let (disconnect_waiter_id, disconnect) = self.session_disconnects.subscribe();
+        let result = wait_for_sso_remote_response(
+            responses,
+            SsoRemoteResponseWait {
+                session: sso,
+                own_subscription_request_id: &own_subscription_request_id,
+                peer_subscription_request_id: &peer_subscription_request_id,
+                submit_request_id: &submit_request_id,
+                statement_request_id: &message_id,
+                remote_message_id: &message_id,
+                timeout,
+                disconnect: Some(disconnect),
+                own_remote_subscription_id: subscription_guard.own_remote_subscription_id(),
+                peer_remote_subscription_id: subscription_guard.peer_remote_subscription_id(),
+            },
+        )
+        .await;
+        self.session_disconnects.unsubscribe(disconnect_waiter_id);
+        match &result {
+            Ok(_) => debug!(action, %message_id, "SSO remote response received"),
+            Err(reason) => warn!(action, %message_id, %reason, "SSO remote message failed"),
+        }
+        if matches!(&result, Err(reason) if reason == SSO_PEER_DISCONNECT_REASON) {
+            self.session_disconnects.notify(SSO_PEER_DISCONNECT_REASON);
+            self.clear_disconnected_session().await;
+        }
+        result
+    }
+}
+
+struct SsoRemoteResponseWait<'a> {
+    session: &'a SsoSessionInfo,
+    own_subscription_request_id: &'a str,
+    peer_subscription_request_id: &'a str,
+    submit_request_id: &'a str,
+    statement_request_id: &'a str,
+    remote_message_id: &'a str,
+    timeout: Option<Duration>,
+    disconnect: Option<oneshot::Receiver<String>>,
+    own_remote_subscription_id: SharedRemoteSubscriptionId,
+    peer_remote_subscription_id: SharedRemoteSubscriptionId,
+}
+
+struct SsoRemoteResponseTarget<'a> {
+    session: &'a SsoSessionInfo,
+    own_subscription_request_id: &'a str,
+    peer_subscription_request_id: &'a str,
+    submit_request_id: &'a str,
+    statement_request_id: &'a str,
+    remote_message_id: &'a str,
+    own_remote_subscription_slot: SharedRemoteSubscriptionId,
+    peer_remote_subscription_slot: SharedRemoteSubscriptionId,
+}
+
+/// Shared slot a response waiter fills with the remote subscription id so
+/// the owning guard can unsubscribe on drop.
+pub(crate) type SharedRemoteSubscriptionId = Arc<Mutex<Option<String>>>;
+
+struct SsoRemoteSubscriptionGuard {
+    connection: Box<dyn JsonRpcConnection>,
+    own_unsubscribe_request_id: String,
+    peer_unsubscribe_request_id: String,
+    own_remote_subscription_id: SharedRemoteSubscriptionId,
+    peer_remote_subscription_id: SharedRemoteSubscriptionId,
+}
+
+impl SsoRemoteSubscriptionGuard {
+    fn new(
+        connection: Box<dyn JsonRpcConnection>,
+        own_subscription_request_id: String,
+        peer_subscription_request_id: String,
+    ) -> Self {
+        Self {
+            connection,
+            own_unsubscribe_request_id: format!("{own_subscription_request_id}:unsubscribe"),
+            peer_unsubscribe_request_id: format!("{peer_subscription_request_id}:unsubscribe"),
+            own_remote_subscription_id: Arc::new(Mutex::new(None)),
+            peer_remote_subscription_id: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    fn own_remote_subscription_id(&self) -> SharedRemoteSubscriptionId {
+        self.own_remote_subscription_id.clone()
+    }
+
+    fn peer_remote_subscription_id(&self) -> SharedRemoteSubscriptionId {
+        self.peer_remote_subscription_id.clone()
+    }
+}
+
+impl Drop for SsoRemoteSubscriptionGuard {
+    fn drop(&mut self) {
+        if let Some(remote_subscription_id) = self
+            .own_remote_subscription_id
+            .lock()
+            .expect("SSO own subscription id mutex poisoned")
+            .as_ref()
+        {
+            self.connection.send(unsubscribe_request(
+                &self.own_unsubscribe_request_id,
+                remote_subscription_id,
+            ));
+        }
+        if let Some(remote_subscription_id) = self
+            .peer_remote_subscription_id
+            .lock()
+            .expect("SSO peer subscription id mutex poisoned")
+            .as_ref()
+        {
+            self.connection.send(unsubscribe_request(
+                &self.peer_unsubscribe_request_id,
+                remote_subscription_id,
+            ));
+        }
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.remote_response.wait"))]
+async fn wait_for_sso_remote_response(
+    responses: BoxStream<'static, String>,
+    wait: SsoRemoteResponseWait<'_>,
+) -> Result<SsoRemoteResponse, String> {
+    let timeout_reason = wait.timeout.map(|timeout| {
+        format!(
+            "SSO response timed out after {} for {}",
+            format_timeout_duration(timeout),
+            wait.remote_message_id
+        )
+    });
+    let response = wait_for_sso_remote_response_inner(
+        responses,
+        SsoRemoteResponseTarget {
+            session: wait.session,
+            own_subscription_request_id: wait.own_subscription_request_id,
+            peer_subscription_request_id: wait.peer_subscription_request_id,
+            submit_request_id: wait.submit_request_id,
+            statement_request_id: wait.statement_request_id,
+            remote_message_id: wait.remote_message_id,
+            own_remote_subscription_slot: wait.own_remote_subscription_id.clone(),
+            peer_remote_subscription_slot: wait.peer_remote_subscription_id.clone(),
+        },
+    )
+    .fuse();
+    let timeout = async move {
+        match (wait.timeout, timeout_reason) {
+            (Some(timeout), Some(reason)) => {
+                futures_timer::Delay::new(timeout).await;
+                reason
+            }
+            _ => futures::future::pending::<String>().await,
+        }
+    }
+    .fuse();
+    let disconnect = async move {
+        match wait.disconnect {
+            Some(rx) => rx
+                .await
+                .unwrap_or_else(|_| SSO_LOCAL_DISCONNECT_REASON.to_string()),
+            None => futures::future::pending::<String>().await,
+        }
+    }
+    .fuse();
+    pin_mut!(response, timeout, disconnect);
+    futures::select! {
+        result = response => result,
+        reason = timeout => Err(reason),
+        reason = disconnect => Err(reason),
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "sso.remote_response.wait_inner"))]
+async fn wait_for_sso_remote_response_inner(
+    mut responses: BoxStream<'static, String>,
+    target: SsoRemoteResponseTarget<'_>,
+) -> Result<SsoRemoteResponse, String> {
+    let mut own_remote_subscription_id: Option<String> = None;
+    let mut peer_remote_subscription_id: Option<String> = None;
+    let mut request_accepted = false;
+    let mut pending_remote_response = None;
+
+    while let Some(frame) = responses.next().await {
+        if own_remote_subscription_id.is_none()
+            && let Some(id) = parse_subscribe_ack(&frame, target.own_subscription_request_id)
+                .map_err(|err| err.to_string())?
+        {
+            *target
+                .own_remote_subscription_slot
+                .lock()
+                .expect("SSO own subscription id mutex poisoned") = Some(id.clone());
+            own_remote_subscription_id = Some(id);
+            continue;
+        }
+        if peer_remote_subscription_id.is_none()
+            && let Some(id) = parse_subscribe_ack(&frame, target.peer_subscription_request_id)
+                .map_err(|err| err.to_string())?
+        {
+            *target
+                .peer_remote_subscription_slot
+                .lock()
+                .expect("SSO peer subscription id mutex poisoned") = Some(id.clone());
+            peer_remote_subscription_id = Some(id);
+            continue;
+        }
+
+        let submit_ack = parse_submit_ack(&frame, target.submit_request_id)
+            .map_err(|err| format!("SSO statement submit failed: {err}"))?;
+        if submit_ack.is_some() {
+            continue;
+        }
+
+        let Some(page) = parse_new_statements(&frame).map_err(|err| err.to_string())? else {
+            continue;
+        };
+        if !subscription_id_matches(
+            &page.remote_subscription_id,
+            own_remote_subscription_id.as_deref(),
+            peer_remote_subscription_id.as_deref(),
+        ) {
+            continue;
+        }
+
+        for statement in page.statements {
+            match decode_sso_session_statement(
+                target.session,
+                &statement,
+                target.statement_request_id,
+                target.remote_message_id,
+            )? {
+                Some(SsoSessionStatement::RequestAccepted) => {
+                    request_accepted = true;
+                    if let Some(response) = pending_remote_response.take() {
+                        return Ok(response);
+                    }
+                }
+                Some(SsoSessionStatement::RemoteResponse(response)) => {
+                    if request_accepted {
+                        return Ok(response);
+                    }
+                    pending_remote_response = Some(response);
+                }
+                Some(SsoSessionStatement::Disconnected) => {
+                    return Err(SSO_PEER_DISCONNECT_REASON.to_string());
+                }
+                None => {}
+            }
+        }
+    }
+
+    Err(format!(
+        "SSO response stream ended before response for {}",
+        target.remote_message_id
+    ))
+}
+
+fn format_timeout_duration(duration: Duration) -> String {
+    if duration.subsec_millis() == 0 {
+        format!("{}s", duration.as_secs())
+    } else {
+        format!("{}ms", duration.as_millis())
+    }
+}
+
+fn subscription_id_matches(
+    remote_subscription_id: &str,
+    own_remote_subscription_id: Option<&str>,
+    peer_remote_subscription_id: Option<&str>,
+) -> bool {
+    own_remote_subscription_id == Some(remote_subscription_id)
+        || peer_remote_subscription_id == Some(remote_subscription_id)
+}
+
+/// Stable message id for an SSO request: the wire request id when present,
+/// otherwise a fixed per-action fallback.
+pub(super) fn sso_message_id(cx: &CallContext, action: &str) -> String {
+    if cx.request_id().is_empty() {
+        format!("truapi:sso:{action}")
+    } else {
+        cx.request_id().to_string()
+    }
+}
+
+fn fresh_statement_expiry() -> u64 {
+    let timestamp = current_unix_secs().saturating_add(DEFAULT_SSO_STATEMENT_EXPIRY_SECS);
+    timestamp << 32
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::{remote_subscription_slot, sso_session_info};
+    use futures::stream;
+
+    #[test]
+    fn sso_remote_response_waiter_times_out() {
+        let session = sso_session_info();
+        let err = futures::executor::block_on(wait_for_sso_remote_response(
+            stream::pending().boxed(),
+            SsoRemoteResponseWait {
+                session: session.sso.as_ref().unwrap(),
+                own_subscription_request_id: "own-sub",
+                peer_subscription_request_id: "peer-sub",
+                submit_request_id: "submit",
+                statement_request_id: "request-1",
+                remote_message_id: "request-1",
+                timeout: Some(Duration::from_millis(1)),
+                disconnect: None,
+                own_remote_subscription_id: remote_subscription_slot(),
+                peer_remote_subscription_id: remote_subscription_slot(),
+            },
+        ))
+        .unwrap_err();
+
+        assert_eq!(err, "SSO response timed out after 1ms for request-1");
+    }
+
+    #[test]
+    fn sso_remote_response_waiter_reports_submit_rejections() {
+        let session = sso_session_info();
+        let err = futures::executor::block_on(wait_for_sso_remote_response(
+            stream::iter(vec![
+                serde_json::json!({
+                    "jsonrpc": "2.0",
+                    "id": "submit",
+                    "error": {
+                        "code": -32000,
+                        "message": "no allowance"
+                    },
+                })
+                .to_string(),
+            ])
+            .boxed(),
+            SsoRemoteResponseWait {
+                session: session.sso.as_ref().unwrap(),
+                own_subscription_request_id: "own-sub",
+                peer_subscription_request_id: "peer-sub",
+                submit_request_id: "submit",
+                statement_request_id: "request-1",
+                remote_message_id: "request-1",
+                timeout: Some(Duration::from_secs(60)),
+                disconnect: None,
+                own_remote_subscription_id: remote_subscription_slot(),
+                peer_remote_subscription_id: remote_subscription_slot(),
+            },
+        ))
+        .unwrap_err();
+
+        assert_eq!(
+            err,
+            "SSO statement submit failed: malformed statement-store frame: no allowance"
+        );
+    }
+
+    #[test]
+    fn sso_remote_response_waiter_stops_on_local_disconnect_signal() {
+        let session = sso_session_info();
+        let (tx, rx) = oneshot::channel();
+        tx.send(SSO_LOCAL_DISCONNECT_REASON.to_string()).unwrap();
+        let err = futures::executor::block_on(wait_for_sso_remote_response(
+            stream::pending().boxed(),
+            SsoRemoteResponseWait {
+                session: session.sso.as_ref().unwrap(),
+                own_subscription_request_id: "own-sub",
+                peer_subscription_request_id: "peer-sub",
+                submit_request_id: "submit",
+                statement_request_id: "request-1",
+                remote_message_id: "request-1",
+                timeout: Some(Duration::from_secs(60)),
+                disconnect: Some(rx),
+                own_remote_subscription_id: remote_subscription_slot(),
+                peer_remote_subscription_id: remote_subscription_slot(),
+            },
+        ))
+        .unwrap_err();
+
+        assert_eq!(err, SSO_LOCAL_DISCONNECT_REASON);
+    }
+
+    #[test]
+    fn sso_remote_response_waiter_without_timeout_stops_on_local_disconnect_signal() {
+        let session = sso_session_info();
+        let (tx, rx) = oneshot::channel();
+        tx.send(SSO_LOCAL_DISCONNECT_REASON.to_string()).unwrap();
+        let err = futures::executor::block_on(wait_for_sso_remote_response(
+            stream::pending().boxed(),
+            SsoRemoteResponseWait {
+                session: session.sso.as_ref().unwrap(),
+                own_subscription_request_id: "own-sub",
+                peer_subscription_request_id: "peer-sub",
+                submit_request_id: "submit",
+                statement_request_id: "request-1",
+                remote_message_id: "request-1",
+                timeout: None,
+                disconnect: Some(rx),
+                own_remote_subscription_id: remote_subscription_slot(),
+                peer_remote_subscription_id: remote_subscription_slot(),
+            },
+        ))
+        .unwrap_err();
+
+        assert_eq!(err, SSO_LOCAL_DISCONNECT_REASON);
+    }
+}
diff --git a/rust/crates/truapi-server/src/runtime/statement_store.rs b/rust/crates/truapi-server/src/runtime/statement_store.rs
new file mode 100644
index 00000000..b2693dc9
--- /dev/null
+++ b/rust/crates/truapi-server/src/runtime/statement_store.rs
@@ -0,0 +1,739 @@
+//! `StatementStore` surface: session-key statement proofs plus submit and
+//! subscribe flows over the people-chain statement store.
+
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::PlatformRuntimeHost;
+use crate::host_logic::statement_store::{
+    MAX_MATCH_ALL_TOPICS, MAX_MATCH_ANY_TOPICS, TopicFilterKind, decode_signed_statement,
+    parse_new_statements, parse_submit_ack, parse_subscribe_ack, sign_statement_fields,
+    signed_statement_to_scale, statement_fields_from_v01, statement_proof_to_v01,
+    submit_statement_request, subscribe_match_all_request, subscribe_match_any_request,
+    unsubscribe_request,
+};
+
+use futures::StreamExt;
+use futures::stream::BoxStream;
+use tracing::instrument;
+use truapi::api::StatementStore;
+use truapi::v01;
+use truapi::versioned::statement_store::{
+    RemoteStatementStoreCreateProofAuthorizedError,
+    RemoteStatementStoreCreateProofAuthorizedRequest,
+    RemoteStatementStoreCreateProofAuthorizedResponse, RemoteStatementStoreCreateProofError,
+    RemoteStatementStoreCreateProofRequest, RemoteStatementStoreCreateProofResponse,
+    RemoteStatementStoreSubmitError, RemoteStatementStoreSubmitRequest,
+    RemoteStatementStoreSubscribeError, RemoteStatementStoreSubscribeItem,
+    RemoteStatementStoreSubscribeRequest,
+};
+use truapi::{CallContext, CallError, Subscription};
+use truapi_platform::{ChainProvider as PlatformChainProvider, JsonRpcConnection, Platform};
+
+impl<P> StatementStore for PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    #[instrument(skip_all, fields(runtime.method = "statement_store.subscribe"))]
+    async fn subscribe(
+        &self,
+        cx: &CallContext,
+        request: RemoteStatementStoreSubscribeRequest,
+    ) -> Result<
+        Subscription<RemoteStatementStoreSubscribeItem>,
+        CallError<RemoteStatementStoreSubscribeError>,
+    > {
+        let (kind, topics) = match statement_store_topic_filter(request) {
+            Ok(value) => value,
+            Err(reason) => {
+                return Err(CallError::Domain(RemoteStatementStoreSubscribeError::V1(
+                    v01::GenericError { reason },
+                )));
+            }
+        };
+        let request_id = if cx.request_id().is_empty() {
+            "truapi:ss-subscribe".to_string()
+        } else {
+            cx.request_id().to_string()
+        };
+        let connection = match PlatformChainProvider::connect(
+            self.platform.as_ref(),
+            self.runtime_config.people_chain_genesis_hash.to_vec(),
+        )
+        .await
+        {
+            Ok(connection) => connection,
+            Err(err) => {
+                return Err(CallError::Domain(RemoteStatementStoreSubscribeError::V1(
+                    v01::GenericError {
+                        reason: format!("statement-store connect failed: {err:?}"),
+                    },
+                )));
+            }
+        };
+        connection.send(match kind {
+            TopicFilterKind::MatchAll => subscribe_match_all_request(&request_id, &topics),
+            TopicFilterKind::MatchAny => subscribe_match_any_request(&request_id, &topics),
+        });
+        let responses = connection.responses();
+        let stream = statement_store_subscription_stream(connection, responses, request_id);
+        Ok(Subscription::new(Box::pin(stream)))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "statement_store.create_proof"))]
+    async fn create_proof(
+        &self,
+        _cx: &CallContext,
+        request: RemoteStatementStoreCreateProofRequest,
+    ) -> Result<
+        RemoteStatementStoreCreateProofResponse,
+        CallError<RemoteStatementStoreCreateProofError>,
+    > {
+        let RemoteStatementStoreCreateProofRequest::V1(mut inner) = request;
+        inner.product_account_id = Self::normalize_product_account_id(inner.product_account_id);
+        if !self.is_product_account_valid_for_caller(&inner.product_account_id.dot_ns_identifier) {
+            return Err(CallError::Domain(RemoteStatementStoreCreateProofError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnknownAccount,
+            )));
+        }
+        let proof = self
+            .create_statement_proof(inner.statement)
+            .map_err(statement_proof_error)?;
+        Ok(RemoteStatementStoreCreateProofResponse::V1(
+            v01::RemoteStatementStoreCreateProofResponse { proof },
+        ))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "statement_store.create_proof_authorized"))]
+    async fn create_proof_authorized(
+        &self,
+        _cx: &CallContext,
+        request: RemoteStatementStoreCreateProofAuthorizedRequest,
+    ) -> Result<
+        RemoteStatementStoreCreateProofAuthorizedResponse,
+        CallError<RemoteStatementStoreCreateProofAuthorizedError>,
+    > {
+        let RemoteStatementStoreCreateProofAuthorizedRequest::V1(statement) = request;
+        let proof = self
+            .create_statement_proof(statement)
+            .map_err(statement_proof_authorized_error)?;
+        Ok(RemoteStatementStoreCreateProofAuthorizedResponse::V1(
+            v01::RemoteStatementStoreCreateProofResponse { proof },
+        ))
+    }
+
+    #[instrument(skip_all, fields(runtime.method = "statement_store.submit"))]
+    async fn submit(
+        &self,
+        cx: &CallContext,
+        request: RemoteStatementStoreSubmitRequest,
+    ) -> Result<(), CallError<RemoteStatementStoreSubmitError>> {
+        let RemoteStatementStoreSubmitRequest::V1(statement) = request;
+        let statement = signed_statement_to_scale(statement).map_err(|reason| {
+            CallError::Domain(RemoteStatementStoreSubmitError::V1(v01::GenericError {
+                reason,
+            }))
+        })?;
+        let request_id = if cx.request_id().is_empty() {
+            "truapi:ss-submit".to_string()
+        } else {
+            cx.request_id().to_string()
+        };
+        let connection = PlatformChainProvider::connect(
+            self.platform.as_ref(),
+            self.runtime_config.people_chain_genesis_hash.to_vec(),
+        )
+        .await
+        .map_err(|err| {
+            CallError::Domain(RemoteStatementStoreSubmitError::V1(v01::GenericError {
+                reason: format!("statement-store connect failed: {err:?}"),
+            }))
+        })?;
+        connection.send(submit_statement_request(&request_id, &statement));
+        wait_for_statement_submit_ack(connection.responses(), &request_id)
+            .await
+            .map_err(|reason| {
+                CallError::Domain(RemoteStatementStoreSubmitError::V1(v01::GenericError {
+                    reason,
+                }))
+            })
+    }
+}
+
+fn statement_store_topic_filter(
+    request: RemoteStatementStoreSubscribeRequest,
+) -> Result<(TopicFilterKind, Vec<[u8; 32]>), String> {
+    match request {
+        RemoteStatementStoreSubscribeRequest::V1(
+            v01::RemoteStatementStoreSubscribeRequest::MatchAll(topics),
+        ) => {
+            if topics.len() > MAX_MATCH_ALL_TOPICS {
+                return Err(format!(
+                    "MatchAll has {} topics, maximum is {}",
+                    topics.len(),
+                    MAX_MATCH_ALL_TOPICS
+                ));
+            }
+            Ok((TopicFilterKind::MatchAll, topics))
+        }
+        RemoteStatementStoreSubscribeRequest::V1(
+            v01::RemoteStatementStoreSubscribeRequest::MatchAny(topics),
+        ) => {
+            if topics.len() > MAX_MATCH_ANY_TOPICS {
+                return Err(format!(
+                    "MatchAny has {} topics, maximum is {}",
+                    topics.len(),
+                    MAX_MATCH_ANY_TOPICS
+                ));
+            }
+            Ok((TopicFilterKind::MatchAny, topics))
+        }
+    }
+}
+
+#[instrument(skip_all, fields(runtime.method = "statement_store.wait_submit_ack"))]
+async fn wait_for_statement_submit_ack(
+    mut responses: BoxStream<'static, String>,
+    request_id: &str,
+) -> Result<(), String> {
+    while let Some(frame) = responses.next().await {
+        if parse_submit_ack(&frame, request_id)
+            .map_err(|err| err.to_string())?
+            .is_some()
+        {
+            return Ok(());
+        }
+    }
+    Err("statement-store submit response stream ended".to_string())
+}
+
+fn statement_store_subscription_stream(
+    connection: Box<dyn JsonRpcConnection>,
+    responses: BoxStream<'static, String>,
+    request_id: String,
+) -> impl futures::Stream<Item = RemoteStatementStoreSubscribeItem> + Send {
+    StatementStoreSubscriptionStream {
+        connection,
+        responses,
+        request_id,
+        remote_subscription_id: None,
+        is_complete: false,
+    }
+}
+
+struct StatementStoreSubscriptionStream {
+    connection: Box<dyn JsonRpcConnection>,
+    responses: BoxStream<'static, String>,
+    request_id: String,
+    remote_subscription_id: Option<String>,
+    is_complete: bool,
+}
+
+impl Unpin for StatementStoreSubscriptionStream {}
+
+impl futures::Stream for StatementStoreSubscriptionStream {
+    type Item = RemoteStatementStoreSubscribeItem;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let state = self.get_mut();
+        loop {
+            let frame = match state.responses.as_mut().poll_next(cx) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Some(frame)) => frame,
+                Poll::Ready(None) => return Poll::Ready(None),
+            };
+
+            if state.remote_subscription_id.is_none() {
+                match parse_subscribe_ack(&frame, &state.request_id) {
+                    Ok(Some(id)) => {
+                        state.remote_subscription_id = Some(id);
+                        continue;
+                    }
+                    Ok(None) => {}
+                    Err(_) => return Poll::Ready(None),
+                }
+            }
+
+            let page = match parse_new_statements(&frame) {
+                Ok(Some(page)) => page,
+                Ok(None) => continue,
+                Err(_) => return Poll::Ready(None),
+            };
+            // Only accept pages for the acked subscription id; pages that
+            // arrive before the subscribe ack cannot be attributed and are
+            // dropped.
+            if state.remote_subscription_id.as_deref() != Some(page.remote_subscription_id.as_str())
+            {
+                continue;
+            }
+
+            let was_complete = state.is_complete;
+            let is_complete = was_complete || page.remaining == Some(0);
+            state.is_complete = is_complete;
+            let statements = page
+                .statements
+                .into_iter()
+                .filter_map(|statement| decode_signed_statement(&statement).ok())
+                .collect::<Vec<_>>();
+            if statements.is_empty() {
+                if is_complete && !was_complete {
+                    return Poll::Ready(Some(RemoteStatementStoreSubscribeItem::V1(
+                        v01::RemoteStatementStoreSubscribeItem {
+                            statements,
+                            is_complete,
+                        },
+                    )));
+                }
+                continue;
+            }
+
+            return Poll::Ready(Some(RemoteStatementStoreSubscribeItem::V1(
+                v01::RemoteStatementStoreSubscribeItem {
+                    statements,
+                    is_complete,
+                },
+            )));
+        }
+    }
+}
+
+impl Drop for StatementStoreSubscriptionStream {
+    fn drop(&mut self) {
+        if let Some(remote_subscription_id) = self.remote_subscription_id.as_ref() {
+            self.connection.send(unsubscribe_request(
+                &format!("{}:unsubscribe", self.request_id),
+                remote_subscription_id,
+            ));
+        }
+    }
+}
+
+impl<P> PlatformRuntimeHost<P>
+where
+    P: Platform + 'static,
+{
+    fn create_statement_proof(
+        &self,
+        statement: v01::Statement,
+    ) -> Result<v01::StatementProof, StatementProofFailure> {
+        let session = self
+            .session_state
+            .current()
+            .ok_or(StatementProofFailure::NoSession)?;
+        let sso = session
+            .sso
+            .as_ref()
+            .ok_or(StatementProofFailure::NoSession)?;
+        let fields = statement_fields_from_v01(statement)
+            .map_err(StatementProofFailure::InvalidStatement)?;
+        let signed = sign_statement_fields(sso.ss_secret, sso.ss_public_key, fields)
+            .map_err(StatementProofFailure::UnableToSign)?;
+        signed
+            .into_iter()
+            .find_map(|field| match field {
+                crate::host_logic::statement_store::StatementField::Proof(proof) => {
+                    Some(statement_proof_to_v01(proof))
+                }
+                _ => None,
+            })
+            .ok_or_else(|| StatementProofFailure::UnableToSign("missing proof".to_string()))
+    }
+}
+
+enum StatementProofFailure {
+    NoSession,
+    InvalidStatement(String),
+    UnableToSign(String),
+}
+
+fn statement_proof_error(
+    failure: StatementProofFailure,
+) -> CallError<RemoteStatementStoreCreateProofError> {
+    match failure {
+        StatementProofFailure::NoSession => {
+            CallError::Domain(RemoteStatementStoreCreateProofError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnableToSign,
+            ))
+        }
+        StatementProofFailure::UnableToSign(_reason) => {
+            CallError::Domain(RemoteStatementStoreCreateProofError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnableToSign,
+            ))
+        }
+        StatementProofFailure::InvalidStatement(reason) => {
+            CallError::Domain(RemoteStatementStoreCreateProofError::V1(
+                v01::RemoteStatementStoreCreateProofError::Unknown { reason },
+            ))
+        }
+    }
+}
+
+fn statement_proof_authorized_error(
+    failure: StatementProofFailure,
+) -> CallError<RemoteStatementStoreCreateProofAuthorizedError> {
+    match failure {
+        StatementProofFailure::NoSession => {
+            CallError::Domain(RemoteStatementStoreCreateProofAuthorizedError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnableToSign,
+            ))
+        }
+        StatementProofFailure::UnableToSign(_reason) => {
+            CallError::Domain(RemoteStatementStoreCreateProofAuthorizedError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnableToSign,
+            ))
+        }
+        StatementProofFailure::InvalidStatement(reason) => {
+            CallError::Domain(RemoteStatementStoreCreateProofAuthorizedError::V1(
+                v01::RemoteStatementStoreCreateProofError::Unknown { reason },
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::{
+        StubPlatform, account_id, new_statements_frame, runtime_config, signed_statement,
+        sso_session_info, statement, stub_platform, subscribe_ack_frame, test_spawner,
+    };
+    use parity_scale_codec::Encode;
+    use std::sync::Arc;
+
+    #[test]
+    fn statement_store_create_proof_signs_with_session_key() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        let session = sso_session_info();
+        let expected_signer = session.sso.as_ref().unwrap().ss_public_key;
+        host.session_state().set_session(session);
+        let cx = CallContext::new();
+        let request = RemoteStatementStoreCreateProofRequest::V1(
+            v01::RemoteStatementStoreCreateProofRequest {
+                product_account_id: account_id("myapp.dot", 0),
+                statement: statement(),
+            },
+        );
+
+        let response =
+            futures::executor::block_on(StatementStore::create_proof(&host, &cx, request)).unwrap();
+
+        let RemoteStatementStoreCreateProofResponse::V1(inner) = response;
+        let v01::StatementProof::Sr25519 { signer, signature } = inner.proof else {
+            panic!("expected sr25519 statement proof");
+        };
+        assert_eq!(signer, expected_signer);
+        assert_ne!(signature, [0; 64]);
+    }
+
+    #[test]
+    fn statement_store_create_proof_rejects_wrong_product_account() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        host.session_state().set_session(sso_session_info());
+        let cx = CallContext::new();
+        let request = RemoteStatementStoreCreateProofRequest::V1(
+            v01::RemoteStatementStoreCreateProofRequest {
+                product_account_id: account_id("other.dot", 0),
+                statement: statement(),
+            },
+        );
+
+        let err = futures::executor::block_on(StatementStore::create_proof(&host, &cx, request))
+            .unwrap_err();
+
+        assert!(matches!(
+            err,
+            CallError::Domain(RemoteStatementStoreCreateProofError::V1(
+                v01::RemoteStatementStoreCreateProofError::UnknownAccount
+            ))
+        ));
+    }
+
+    #[test]
+    fn statement_store_create_proof_authorized_signs_with_session_key() {
+        let host =
+            PlatformRuntimeHost::new(stub_platform(), runtime_config("myapp.dot"), test_spawner());
+        let session = sso_session_info();
+        let expected_signer = session.sso.as_ref().unwrap().ss_public_key;
+        host.session_state().set_session(session);
+        let cx = CallContext::new();
+        let request = RemoteStatementStoreCreateProofAuthorizedRequest::V1(statement());
+
+        let response = futures::executor::block_on(StatementStore::create_proof_authorized(
+            &host, &cx, request,
+        ))
+        .unwrap();
+
+        let RemoteStatementStoreCreateProofAuthorizedResponse::V1(inner) = response;
+        let v01::StatementProof::Sr25519 { signer, .. } = inner.proof else {
+            panic!("expected sr25519 statement proof");
+        };
+        assert_eq!(signer, expected_signer);
+    }
+
+    #[test]
+    fn statement_store_submit_posts_signed_statement_and_waits_for_ack() {
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![r#"{"jsonrpc":"2.0","id":"submit-1","result":"0xok"}"#.to_string()],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::with_request_id("submit-1".to_string());
+        let request = RemoteStatementStoreSubmitRequest::V1(signed_statement([7; 32]));
+
+        futures::executor::block_on(StatementStore::submit(&host, &cx, request)).unwrap();
+
+        let sent = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        assert_eq!(sent.len(), 1);
+        let request: serde_json::Value = serde_json::from_str(&sent[0]).unwrap();
+        assert_eq!(request["method"], "statement_submit");
+        let statement_hex = request["params"][0].as_str().unwrap();
+        let statement =
+            hex::decode(statement_hex.strip_prefix("0x").unwrap_or(statement_hex)).unwrap();
+        assert_eq!(
+            crate::host_logic::statement_store::decode_signed_statement(&statement).unwrap(),
+            signed_statement([7; 32])
+        );
+    }
+
+    #[test]
+    fn statement_store_subscribe_maps_signed_pages() {
+        let signed = crate::host_logic::statement_store::signed_statement_to_scale(
+            signed_statement([7; 32]),
+        )
+        .unwrap();
+        let unsigned = vec![crate::host_logic::statement_store::StatementField::Data(
+            vec![1],
+        )]
+        .encode();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![
+                subscribe_ack_frame("sub-1", "remote-sub"),
+                new_statements_frame("remote-sub", vec![unsigned, signed]),
+            ],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::with_request_id("sub-1".to_string());
+        let mut subscription = futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7; 32]]),
+            ),
+        ))
+        .unwrap();
+
+        let item = futures::executor::block_on(subscription.next()).expect("statement page");
+
+        let RemoteStatementStoreSubscribeItem::V1(inner) = item;
+        assert!(inner.is_complete);
+        assert_eq!(inner.statements, vec![signed_statement([7; 32])]);
+        let sent = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        let request: serde_json::Value = serde_json::from_str(&sent[0]).unwrap();
+        assert_eq!(request["method"], "statement_subscribeStatement");
+        assert_eq!(
+            request["params"][0]["matchAny"][0],
+            "0x0707070707070707070707070707070707070707070707070707070707070707"
+        );
+    }
+
+    /// Pages that arrive before the subscribe ack cannot be attributed to the
+    /// subscription and must be dropped, even when they carry the id the ack
+    /// will later confirm.
+    #[test]
+    fn statement_store_subscribe_drops_pages_before_subscribe_ack() {
+        let rogue = crate::host_logic::statement_store::signed_statement_to_scale(
+            signed_statement([9; 32]),
+        )
+        .unwrap();
+        let signed = crate::host_logic::statement_store::signed_statement_to_scale(
+            signed_statement([7; 32]),
+        )
+        .unwrap();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![
+                new_statements_frame("remote-sub-pre", vec![rogue]),
+                subscribe_ack_frame("sub-pre", "remote-sub-pre"),
+                new_statements_frame("remote-sub-pre", vec![signed]),
+            ],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(platform, runtime_config("myapp.dot"), test_spawner());
+        let cx = CallContext::with_request_id("sub-pre".to_string());
+        let mut subscription = futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7; 32]]),
+            ),
+        ))
+        .unwrap();
+
+        let item = futures::executor::block_on(subscription.next()).expect("statement page");
+
+        assert_eq!(
+            item,
+            RemoteStatementStoreSubscribeItem::V1(v01::RemoteStatementStoreSubscribeItem {
+                statements: vec![signed_statement([7; 32])],
+                is_complete: true,
+            })
+        );
+    }
+
+    #[test]
+    fn statement_store_subscribe_unsubscribes_remote_subscription_on_drop() {
+        let signed = crate::host_logic::statement_store::signed_statement_to_scale(
+            signed_statement([7; 32]),
+        )
+        .unwrap();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![
+                subscribe_ack_frame("sub-drop", "remote-sub-drop"),
+                new_statements_frame("remote-sub-drop", vec![signed]),
+            ],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::with_request_id("sub-drop".to_string());
+        let mut subscription = futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7; 32]]),
+            ),
+        ))
+        .unwrap();
+
+        let _ = futures::executor::block_on(subscription.next()).expect("statement page");
+        drop(subscription);
+
+        let sent = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+        assert_eq!(sent.len(), 2);
+        let unsubscribe: serde_json::Value = serde_json::from_str(&sent[1]).unwrap();
+        assert_eq!(unsubscribe["method"], "statement_unsubscribeStatement");
+        assert_eq!(unsubscribe["params"][0], "remote-sub-drop");
+    }
+
+    #[test]
+    fn statement_store_subscribe_emits_empty_completion_page_after_filtering() {
+        let unsigned = vec![crate::host_logic::statement_store::StatementField::Data(
+            vec![1],
+        )]
+        .encode();
+        let platform = Arc::new(StubPlatform {
+            rpc_responses: vec![
+                subscribe_ack_frame("sub-empty-complete", "remote-sub-empty"),
+                new_statements_frame("remote-sub-empty", vec![unsigned]),
+            ],
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(platform, runtime_config("myapp.dot"), test_spawner());
+        let cx = CallContext::with_request_id("sub-empty-complete".to_string());
+        let mut subscription = futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7; 32]]),
+            ),
+        ))
+        .unwrap();
+
+        let item = futures::executor::block_on(subscription.next()).expect("completion page");
+
+        let RemoteStatementStoreSubscribeItem::V1(inner) = item;
+        assert!(inner.is_complete);
+        assert!(inner.statements.is_empty());
+    }
+
+    #[test]
+    fn statement_store_subscribe_rejects_topic_limit_violations() {
+        let platform = stub_platform();
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::with_request_id("sub-too-many".to_string());
+        let topics = vec![[7; 32]; MAX_MATCH_ANY_TOPICS + 1];
+
+        let err = match futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(topics),
+            ),
+        )) {
+            Ok(_) => panic!("topic limit violation should fail subscription start"),
+            Err(err) => err,
+        };
+
+        let CallError::Domain(RemoteStatementStoreSubscribeError::V1(reason)) = err else {
+            panic!("expected statement-store subscribe domain error");
+        };
+        assert_eq!(
+            reason.reason,
+            format!(
+                "MatchAny has {} topics, maximum is {}",
+                MAX_MATCH_ANY_TOPICS + 1,
+                MAX_MATCH_ANY_TOPICS
+            )
+        );
+        assert!(platform.sent_rpc.lock().unwrap().is_empty());
+    }
+
+    #[test]
+    fn statement_store_subscribe_reports_chain_connect_failure() {
+        let platform = Arc::new(StubPlatform {
+            chain_connect_error: Some("chain unavailable"),
+            ..Default::default()
+        });
+        let host = PlatformRuntimeHost::new(
+            platform.clone(),
+            runtime_config("myapp.dot"),
+            test_spawner(),
+        );
+        let cx = CallContext::with_request_id("sub-connect-fail".to_string());
+
+        let err = match futures::executor::block_on(StatementStore::subscribe(
+            &host,
+            &cx,
+            RemoteStatementStoreSubscribeRequest::V1(
+                v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7; 32]]),
+            ),
+        )) {
+            Ok(_) => panic!("chain connect failure should fail subscription start"),
+            Err(err) => err,
+        };
+
+        let CallError::Domain(RemoteStatementStoreSubscribeError::V1(reason)) = err else {
+            panic!("expected statement-store subscribe domain error");
+        };
+        assert!(
+            reason
+                .reason
+                .contains("statement-store connect failed: GenericError"),
+            "unexpected reason: {}",
+            reason.reason
+        );
+        assert!(
+            reason.reason.contains("chain unavailable"),
+            "unexpected reason: {}",
+            reason.reason
+        );
+        assert!(platform.sent_rpc.lock().unwrap().is_empty());
+    }
+}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/mod.rs b/rust/crates/truapi-server/src/smoldot_provider/mod.rs
new file mode 100644
index 00000000..ece3c964
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/mod.rs
@@ -0,0 +1,310 @@
+//! Rust-owned light client backend for [`RuntimeChainProvider`].
+//!
+//! Wraps a single `smoldot_light::Client` that owns Paseo + Asset Hub Paseo.
+//! Each `connect(genesis_hash)` returns a [`JsonRpcConnection`] that forwards
+//! requests to the corresponding smoldot chain and streams responses back to
+//! the chain runtime.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use derive_more::Display;
+use futures::SinkExt;
+use futures::StreamExt;
+use futures::channel::mpsc;
+use futures::stream::BoxStream;
+use smoldot_light::{
+    AddChainConfig, AddChainConfigJsonRpc, AddChainError, ChainId, Client, JsonRpcResponses,
+};
+use truapi_platform::JsonRpcConnection;
+
+use crate::chain_runtime::{RuntimeChainProvider, RuntimeFailure};
+
+#[cfg(not(target_arch = "wasm32"))]
+mod native_platform;
+#[cfg(not(target_arch = "wasm32"))]
+use native_platform::{PlatformRefAlias, make_platform};
+
+#[cfg(target_arch = "wasm32")]
+mod wasm_helpers;
+#[cfg(target_arch = "wasm32")]
+mod wasm_platform;
+#[cfg(target_arch = "wasm32")]
+mod wasm_socket;
+#[cfg(target_arch = "wasm32")]
+use wasm_platform::{PlatformRefAlias, make_platform};
+
+// `paseo.json` embeds a `lightSyncState` warp-sync checkpoint to speed initial
+// sync. It is a point-in-time snapshot: regenerate it periodically (the older
+// it gets, the more GRANDPA catch-up smoldot must do from the checkpoint).
+// `asset-hub-paseo.json` carries no checkpoint and relies on relay finality.
+const PASEO_SPEC: &str = include_str!("specs/paseo.json");
+const ASSET_HUB_PASEO_SPEC: &str = include_str!("specs/asset-hub-paseo.json");
+
+const PASEO_RELAY_GENESIS: &str =
+    "0x77afd6190f1554ad45fd0d31aee62aacc33c6db0ea801129acb813f913e0764f";
+const ASSET_HUB_PASEO_GENESIS: &str =
+    "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2";
+
+/// Per-chain json-rpc bus ceilings. Sized well above the chainHead-v1 usage
+/// the dispatcher permits, but finite so a stalled consumer cannot grow the
+/// smoldot-side buffers without bound.
+const MAX_PENDING_RPC_REQUESTS: u32 = 256;
+const MAX_RPC_SUBSCRIPTIONS: u32 = 1024;
+
+/// Errors returned by [`SmoldotChainProvider::with_bundled_specs`].
+#[derive(Debug, Display)]
+pub enum SmoldotInitError {
+    /// Failed to add the Paseo relay chain to the client.
+    #[display("failed to add relay chain: {_0}")]
+    AddRelay(AddChainError),
+    /// Failed to add the Asset Hub parachain to the client.
+    #[display("failed to add parachain: {_0}")]
+    AddParaChain(AddChainError),
+}
+
+impl std::error::Error for SmoldotInitError {}
+
+struct ChainEntry {
+    chain_id: ChainId,
+    responses: Mutex<Option<JsonRpcResponses<PlatformRefAlias>>>,
+}
+
+type ClientRef = Arc<Mutex<Client<PlatformRefAlias>>>;
+
+/// A [`RuntimeChainProvider`] backed by `smoldot_light::Client`.
+///
+/// Built via [`SmoldotChainProvider::with_bundled_specs`] with Paseo + Asset
+/// Hub Paseo pre-loaded. Each chain supports a single [`connect`] for the
+/// client's lifetime: the json-rpc response stream is single-consumer and is
+/// handed out on first connect, so a second `connect` for the same chain
+/// reports a distinct `HostFailure` rather than masquerading as an unknown
+/// genesis hash.
+///
+/// [`connect`]: RuntimeChainProvider::connect
+pub struct SmoldotChainProvider {
+    client: ClientRef,
+    chains: HashMap<String, Arc<ChainEntry>>,
+}
+
+impl SmoldotChainProvider {
+    /// Build a provider with Paseo + Asset Hub Paseo specs already added to
+    /// the client. Each chain's json-rpc bus is held until the first
+    /// `connect` call drains it.
+    pub fn with_bundled_specs() -> Result<Self, SmoldotInitError> {
+        let platform = make_platform();
+        let mut client: Client<PlatformRefAlias> = Client::new(platform);
+
+        let relay = client
+            .add_chain(AddChainConfig {
+                specification: PASEO_SPEC,
+                json_rpc: AddChainConfigJsonRpc::Enabled {
+                    max_pending_requests: std::num::NonZeroU32::new(MAX_PENDING_RPC_REQUESTS)
+                        .unwrap(),
+                    max_subscriptions: MAX_RPC_SUBSCRIPTIONS,
+                },
+                database_content: "",
+                potential_relay_chains: std::iter::empty(),
+                user_data: (),
+                statement_protocol_config: None,
+            })
+            .map_err(SmoldotInitError::AddRelay)?;
+
+        let para = client
+            .add_chain(AddChainConfig {
+                specification: ASSET_HUB_PASEO_SPEC,
+                json_rpc: AddChainConfigJsonRpc::Enabled {
+                    max_pending_requests: std::num::NonZeroU32::new(MAX_PENDING_RPC_REQUESTS)
+                        .unwrap(),
+                    max_subscriptions: MAX_RPC_SUBSCRIPTIONS,
+                },
+                database_content: "",
+                potential_relay_chains: std::iter::once(relay.chain_id),
+                user_data: (),
+                statement_protocol_config: None,
+            })
+            .map_err(SmoldotInitError::AddParaChain)?;
+
+        let mut chains = HashMap::new();
+        chains.insert(
+            PASEO_RELAY_GENESIS.to_string(),
+            Arc::new(ChainEntry {
+                chain_id: relay.chain_id,
+                responses: Mutex::new(relay.json_rpc_responses),
+            }),
+        );
+        chains.insert(
+            ASSET_HUB_PASEO_GENESIS.to_string(),
+            Arc::new(ChainEntry {
+                chain_id: para.chain_id,
+                responses: Mutex::new(para.json_rpc_responses),
+            }),
+        );
+
+        Ok(Self {
+            client: Arc::new(Mutex::new(client)),
+            chains,
+        })
+    }
+}
+
+#[async_trait::async_trait]
+impl RuntimeChainProvider for SmoldotChainProvider {
+    async fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<Arc<dyn JsonRpcConnection>, RuntimeFailure> {
+        let key = crate::chain_runtime::encode_hex(&genesis_hash);
+        let entry = self
+            .chains
+            .get(&key)
+            .cloned()
+            .ok_or_else(|| RuntimeFailure::unavailable("remote_chain_connect"))?;
+
+        // Single-consumer stream: taken on first connect. A second connect for
+        // the same chain reports a distinct failure (rather than the
+        // `Unavailable` used for an unknown genesis) so callers can tell
+        // "no such chain" apart from "already connected".
+        let responses = entry.responses.lock().unwrap().take().ok_or_else(|| {
+            RuntimeFailure::host_failure(
+                "remote_chain_connect",
+                "smoldot chain already connected (single connection per chain)",
+            )
+        })?;
+
+        Ok(Arc::new(SmoldotJsonRpcConnection::new(
+            self.client.clone(),
+            entry.chain_id,
+            responses,
+        )))
+    }
+}
+
+struct SmoldotJsonRpcConnection {
+    client: ClientRef,
+    chain_id: ChainId,
+    responses: Mutex<Option<mpsc::UnboundedReceiver<String>>>,
+}
+
+impl SmoldotJsonRpcConnection {
+    fn new(
+        client: ClientRef,
+        chain_id: ChainId,
+        mut responses: JsonRpcResponses<PlatformRefAlias>,
+    ) -> Self {
+        let (mut tx, rx) = mpsc::unbounded::<String>();
+        spawn_pump(async move {
+            while let Some(response) = responses.next().await {
+                if tx.send(response).await.is_err() {
+                    break;
+                }
+            }
+        });
+        Self {
+            client,
+            chain_id,
+            responses: Mutex::new(Some(rx)),
+        }
+    }
+}
+
+impl JsonRpcConnection for SmoldotJsonRpcConnection {
+    fn send(&self, request: String) {
+        let mut client = self.client.lock().unwrap();
+        if let Err(err) = client.json_rpc_request(request, self.chain_id) {
+            log_send_error(err);
+        }
+    }
+
+    fn responses(&self) -> BoxStream<'static, String> {
+        let rx = self
+            .responses
+            .lock()
+            .unwrap()
+            .take()
+            .expect("SmoldotJsonRpcConnection::responses() called twice");
+        rx.boxed()
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn spawn_pump<F>(future: F)
+where
+    F: std::future::Future<Output = ()> + Send + 'static,
+{
+    std::thread::spawn(move || {
+        futures::executor::block_on(future);
+    });
+}
+
+#[cfg(target_arch = "wasm32")]
+fn spawn_pump<F>(future: F)
+where
+    F: std::future::Future<Output = ()> + 'static,
+{
+    wasm_bindgen_futures::spawn_local(future);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn log_send_error(err: smoldot_light::HandleRpcError) {
+    eprintln!("smoldot json_rpc_request failed: {err}");
+}
+
+#[cfg(target_arch = "wasm32")]
+fn log_send_error(err: smoldot_light::HandleRpcError) {
+    web_sys::console::error_1(&format!("smoldot json_rpc_request failed: {err}").into());
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use super::*;
+    use std::time::{Duration, Instant};
+
+    fn paseo_genesis_bytes() -> Vec<u8> {
+        hex::decode(PASEO_RELAY_GENESIS.trim_start_matches("0x")).expect("valid genesis hash")
+    }
+
+    /// Smoke test: building the provider with bundled specs must register
+    /// the two known chains. Verifies the smoldot module compiles and the
+    /// client accepts the bundled chainspecs without doing any network I/O.
+    #[test]
+    fn smoldot_module_compiles_and_starts_idle_runtime() {
+        let provider = SmoldotChainProvider::with_bundled_specs().expect("init");
+        assert!(provider.chains.contains_key(PASEO_RELAY_GENESIS));
+        assert!(provider.chains.contains_key(ASSET_HUB_PASEO_GENESIS));
+        drop(provider);
+    }
+
+    #[test]
+    fn connect_unknown_genesis_is_unavailable() {
+        let provider = SmoldotChainProvider::with_bundled_specs().expect("init");
+        let result = futures::executor::block_on(provider.connect(vec![0u8; 32]));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    #[ignore = "hits the live Paseo relay network; run manually with --ignored"]
+    fn streams_initialized_event_for_paseo() {
+        let provider = SmoldotChainProvider::with_bundled_specs().expect("init");
+        let connection =
+            futures::executor::block_on(provider.connect(paseo_genesis_bytes())).expect("connect");
+        connection.send(
+            r#"{"jsonrpc":"2.0","id":"1","method":"chainHead_v1_follow","params":[true]}"#
+                .to_string(),
+        );
+
+        let mut stream = connection.responses();
+        let deadline = Instant::now() + Duration::from_secs(60);
+        let mut initialized_seen = false;
+        while Instant::now() < deadline {
+            let Some(frame) = futures::executor::block_on(stream.next()) else {
+                break;
+            };
+            if frame.contains("\"event\":\"initialized\"") {
+                initialized_seen = true;
+                break;
+            }
+        }
+        assert!(initialized_seen, "did not observe initialized event");
+    }
+}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/native_platform.rs b/rust/crates/truapi-server/src/smoldot_provider/native_platform.rs
new file mode 100644
index 00000000..ad8bcc1b
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/native_platform.rs
@@ -0,0 +1,16 @@
+//! Native platform wiring for `smoldot_light`.
+//!
+//! `DefaultPlatform` ships with smoldot-light (std feature, default on) and
+//! spawns its own background threads for network I/O.
+
+use std::sync::Arc;
+
+use smoldot_light::platform::default::DefaultPlatform;
+
+/// Alias for the platform reference type smoldot-light expects.
+pub type PlatformRefAlias = Arc<DefaultPlatform>;
+
+/// Creates the native smoldot platform implementation used by the server.
+pub fn make_platform() -> PlatformRefAlias {
+    DefaultPlatform::new("truapi".into(), env!("CARGO_PKG_VERSION").into())
+}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/specs/asset-hub-paseo.json b/rust/crates/truapi-server/src/smoldot_provider/specs/asset-hub-paseo.json
new file mode 100644
index 00000000..7416f3f5
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/specs/asset-hub-paseo.json
@@ -0,0 +1 @@
+{"name":"Paseo Asset Hub","id":"asset-hub-paseo","chainType":"Live","bootNodes":["/dns/asset-hub-paseo-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWGoC9CdpY8T5bgf6PqKgry2DjCxaqQS7R9WdQ8rVMeEMg","/dns/asset-hub-paseo-boot-ng.dwellir.com/tcp/30357/p2p/12D3KooWGoC9CdpY8T5bgf6PqKgry2DjCxaqQS7R9WdQ8rVMeEMg","/dns/boot-node.helikon.io/tcp/10120/p2p/12D3KooWKrg6Qb2HhTc3onfkgsNbRU72RjNDm96Xh2E7sWso5LZT","/dns/boot.metaspan.io/tcp/36092/p2p/12D3KooWHdtFsjicVWecmiRrc8XLc3A6iLLKKfUwjZXu5mtg1k3w","/dns/boot.metaspan.io/tcp/36096/wss/p2p/12D3KooWHdtFsjicVWecmiRrc8XLc3A6iLLKKfUwjZXu5mtg1k3w","/dns/assethub-paseo-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWP8aNgAjkYzH1QuwLjYyNqfpWkJkFRgdtUuey9KzEJciq","/dns/assethub-paseo-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWP8aNgAjkYzH1QuwLjYyNqfpWkJkFRgdtUuey9KzEJciq","/dns/asset-hub-paseo.boot.rotko.net/tcp/34011/p2p/12D3KooWLzC336hvwY7Vyjdwc8VMMMyqnwph1UXMoi1LEbw8RiHj","/dns/asset-hub-paseo.boot.rotko.net/tcp/30435/wss/p2p/12D3KooWLzC336hvwY7Vyjdwc8VMMMyqnwph1UXMoi1LEbw8RiHj","/dns/asset-hub-paseo-bootnode.turboflakes.io/tcp/30330/p2p/12D3KooWJzfVkdDnKfn2hQ1c3ysrbmReTjVKrEBHkdwgZThbB1BM"],"telemetryEndpoints":null,"protocolId":null,"properties":{"ss58Format":0,"tokenDecimals":10,"tokenSymbol":"PAS"},"relay_chain":"paseo","para_id":1000,"codeSubstitutes":{},"genesis":{"stateRootHash":"0xe24abb446f9aa757610fedc53cc631536f3b456a927a1ab1b9018ea2df3c925d"}}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/specs/paseo.json b/rust/crates/truapi-server/src/smoldot_provider/specs/paseo.json
new file mode 100644
index 00000000..3299c61e
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/specs/paseo.json
@@ -0,0 +1 @@
+{"name":"Paseo Testnet","id":"paseo","chainType":"Live","bootNodes":["/dns/paseo-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWBLLFKDGBxCwq3QmU3YwWKXUx953WwprRshJQicYu4Cfr","/dns/paseo-boot-ng.dwellir.com/tcp/30354/p2p/12D3KooWBLLFKDGBxCwq3QmU3YwWKXUx953WwprRshJQicYu4Cfr","/dns/boot-node.helikon.io/tcp/10020/p2p/12D3KooWBetfzZpf6tGihKrqCo5z854Ub4ZNAUUTRT6eYHNh7FYi","/dns/boot-node.helikon.io/tcp/10022/wss/p2p/12D3KooWBetfzZpf6tGihKrqCo5z854Ub4ZNAUUTRT6eYHNh7FYi","/dns/paseo.bootnodes.polkadotters.com/tcp/30538/p2p/12D3KooWPbbFy4TefEGTRF5eTYhq8LEzc4VAHdNUVCbY4nAnhqPP","/dns/paseo.bootnodes.polkadotters.com/tcp/30540/wss/p2p/12D3KooWPbbFy4TefEGTRF5eTYhq8LEzc4VAHdNUVCbY4nAnhqPP","/dns/paseo.boot.rotko.net/tcp/34001/p2p/12D3KooWRH8eBMhw8c7bucy6pJfy94q4dKpLkF3pmeGohHmemdRu","/dns/paseo-bootnode.turboflakes.io/tcp/30630/p2p/12D3KooWMjCN2CrnN71hAdehn6M2iYKeGdGbZ1A3SKhf4hxrgG9e","/dns/paseo-bootnode.turboflakes.io/tcp/30730/wss/p2p/12D3KooWMjCN2CrnN71hAdehn6M2iYKeGdGbZ1A3SKhf4hxrgG9e"],"telemetryEndpoints":null,"protocolId":"pas","properties":{"ss58Format":0,"tokenDecimals":10,"tokenSymbol":"PAS"},"codeSubstitutes":{},"genesis":{"stateRootHash":"0x2b2a8395a8ec27c54d322d3a6602152da0e3bd0c8f4c01f17a572a44a8e36ab6"},"lightSyncState":{"babeEpochChanges":"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","babeFinalizedBlockWeight":2681601,"finalizedBlockHeader":"0x68d801d1e18ca6e3e12642c5ccc38ce1ded375d2141a5a8f3ae03f60c77bf790363f8f02c5d35ff0ddcbe5e1358b1826bca42863a0bf303c4c8cca366ab3aab6fc5aa15ed9e2b35427d7b690880d467c26e54d486743a8230d2d5d9858511c8875b88db20c0642414245b5010367000000b28f9d110000000036f77094e2f2bf00d706357848c57740575e959c3345c648da72f07f9f598e0ebc6ee44a916f97c65f9d26b8d6b6608204755548f5ef8b528569a93cacc2540ebfe1d2614499a1dc8cd5356d8099d5fe34bc7e42a82d29779bec4ed8af75fb05044245454684038f927d020ef9925ccc51918e2b2543ab59fc5dcdce343de358a8245a9770652105424142450101543e56f9498eb078963b24d14dc24b440ae06eb79438e2ef284e94bb49228a61e64cd714992a61eadbbd2b06b0e45f6bc308a477d5d4ee5d099d0b3aaa81e28b","grandpaAuthoritySet":"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"}}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/wasm_helpers.rs b/rust/crates/truapi-server/src/smoldot_provider/wasm_helpers.rs
new file mode 100644
index 00000000..07c768da
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/wasm_helpers.rs
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// Vendored from subxt-lightclient 0.50.0 (Apache-2.0 OR GPL-3.0), elected
+// under Apache-2.0. See ../../THIRD_PARTY_NOTICES.md for attribution.
+
+use super::wasm_socket::WasmSocket;
+
+use core::time::Duration;
+use futures_util::{FutureExt, future};
+
+/// Returns the current wall-clock time as a duration since the Unix epoch.
+pub fn now_from_unix_epoch() -> Duration {
+    web_time::SystemTime::now()
+        .duration_since(web_time::SystemTime::UNIX_EPOCH)
+        .unwrap_or_else(|_| {
+            panic!("Invalid systime cannot be configured earlier than `UNIX_EPOCH`")
+        })
+}
+
+/// Monotonic instant type used by the wasm smoldot platform.
+pub type Instant = web_time::Instant;
+
+/// Returns the current monotonic instant used by the wasm smoldot platform.
+pub fn now() -> Instant {
+    web_time::Instant::now()
+}
+
+/// Boxed delay future returned by `sleep`.
+pub type Delay = future::BoxFuture<'static, ()>;
+
+/// Creates a future that resolves after the provided duration.
+pub fn sleep(duration: Duration) -> Delay {
+    futures_timer::Delay::new(duration).boxed()
+}
+
+/// Smoldot expects a single concrete stream type with pinned access; the
+/// wrapper hides the buffer/socket pair behind a `pin_project` projection.
+#[pin_project::pin_project]
+pub struct Stream(
+    #[pin]
+    pub  smoldot::libp2p::with_buffers::WithBuffers<
+        future::BoxFuture<'static, Result<WasmSocket, std::io::Error>>,
+        WasmSocket,
+        Instant,
+    >,
+);
diff --git a/rust/crates/truapi-server/src/smoldot_provider/wasm_platform.rs b/rust/crates/truapi-server/src/smoldot_provider/wasm_platform.rs
new file mode 100644
index 00000000..c39c2598
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/wasm_platform.rs
@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: Apache-2.0
+// Vendored from subxt-lightclient 0.50.0 (Apache-2.0 OR GPL-3.0), elected
+// under Apache-2.0. See ../../THIRD_PARTY_NOTICES.md for attribution.
+
+use super::wasm_socket::WasmSocket;
+
+use core::{
+    fmt::{self, Write as _},
+    net::IpAddr,
+    time::Duration,
+};
+use futures::prelude::*;
+use smoldot::libp2p::with_buffers;
+use smoldot_light::platform::{
+    Address, ConnectionType, LogLevel, MultiStreamAddress, MultiStreamWebRtcConnection,
+    PlatformRef, SubstreamDirection,
+};
+use wasm_bindgen::JsValue;
+
+use std::{io, net::SocketAddr, pin::Pin};
+
+/// Alias for the platform reference type smoldot-light expects.
+pub type PlatformRefAlias = TrUApiWasmPlatform;
+
+/// Creates the wasm-backed smoldot platform implementation used by the server.
+pub fn make_platform() -> PlatformRefAlias {
+    TrUApiWasmPlatform::new()
+}
+
+/// Smoldot platform implementation backed by the browser WebSocket API and
+/// `wasm_bindgen_futures` for task spawning.
+#[derive(Clone)]
+pub struct TrUApiWasmPlatform {}
+
+impl TrUApiWasmPlatform {
+    /// Builds a fresh wasm platform handle. The handle is cheaply cloneable.
+    pub fn new() -> Self {
+        TrUApiWasmPlatform {}
+    }
+}
+
+impl Default for TrUApiWasmPlatform {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PlatformRef for TrUApiWasmPlatform {
+    type Delay = super::wasm_helpers::Delay;
+    type Instant = super::wasm_helpers::Instant;
+    type MultiStream = std::convert::Infallible;
+    type Stream = super::wasm_helpers::Stream;
+    type StreamConnectFuture = future::Ready<Self::Stream>;
+    type MultiStreamConnectFuture = future::Pending<MultiStreamWebRtcConnection<Self::MultiStream>>;
+    type ReadWriteAccess<'a> = with_buffers::ReadWriteAccess<'a, Self::Instant>;
+    type StreamUpdateFuture<'a> = future::BoxFuture<'a, ()>;
+    type StreamErrorRef<'a> = &'a std::io::Error;
+    type NextSubstreamFuture<'a> = future::Pending<Option<(Self::Stream, SubstreamDirection)>>;
+
+    fn now_from_unix_epoch(&self) -> Duration {
+        super::wasm_helpers::now_from_unix_epoch()
+    }
+
+    fn now(&self) -> Self::Instant {
+        super::wasm_helpers::now()
+    }
+
+    fn fill_random_bytes(&self, buffer: &mut [u8]) {
+        getrandom::getrandom(buffer).expect("Cannot fill random bytes");
+    }
+
+    fn sleep(&self, duration: Duration) -> Self::Delay {
+        super::wasm_helpers::sleep(duration)
+    }
+
+    fn sleep_until(&self, when: Self::Instant) -> Self::Delay {
+        self.sleep(when.saturating_duration_since(self.now()))
+    }
+
+    fn spawn_task(
+        &self,
+        _task_name: std::borrow::Cow<'_, str>,
+        task: impl future::Future<Output = ()> + Send + 'static,
+    ) {
+        wasm_bindgen_futures::spawn_local(task);
+    }
+
+    fn client_name(&self) -> std::borrow::Cow<'_, str> {
+        "truapi".into()
+    }
+
+    fn client_version(&self) -> std::borrow::Cow<'_, str> {
+        env!("CARGO_PKG_VERSION").into()
+    }
+
+    fn supports_connection_type(&self, connection_type: ConnectionType) -> bool {
+        matches!(
+            connection_type,
+            ConnectionType::WebSocketIpv4 { .. }
+                | ConnectionType::WebSocketIpv6 { .. }
+                | ConnectionType::WebSocketDns { .. }
+        )
+    }
+
+    fn connect_stream(&self, multiaddr: Address) -> Self::StreamConnectFuture {
+        let addr = match multiaddr {
+            Address::WebSocketDns {
+                hostname,
+                port,
+                secure: true,
+            } => {
+                format!("wss://{hostname}:{port}")
+            }
+            Address::WebSocketDns {
+                hostname,
+                port,
+                secure: false,
+            } => {
+                format!("ws://{hostname}:{port}")
+            }
+            Address::WebSocketIp {
+                ip: IpAddr::V4(ip),
+                port,
+            } => {
+                let addr = SocketAddr::from((ip, port));
+                format!("ws://{addr}")
+            }
+            Address::WebSocketIp {
+                ip: IpAddr::V6(ip),
+                port,
+            } => {
+                let addr = SocketAddr::from((ip, port));
+                format!("ws://{addr}")
+            }
+            _ => {
+                unreachable!("Unsupported connection type")
+            }
+        };
+
+        let socket_future = async move {
+            WasmSocket::new(addr.as_str()).map_err(|err| std::io::Error::other(err.to_string()))
+        };
+
+        future::ready(super::wasm_helpers::Stream(with_buffers::WithBuffers::new(
+            Box::pin(socket_future),
+        )))
+    }
+
+    fn connect_multistream(&self, _address: MultiStreamAddress) -> Self::MultiStreamConnectFuture {
+        panic!("Multistreams are not supported")
+    }
+
+    fn open_out_substream(&self, c: &mut Self::MultiStream) {
+        match *c {}
+    }
+
+    fn next_substream(&self, c: &'_ mut Self::MultiStream) -> Self::NextSubstreamFuture<'_> {
+        match *c {}
+    }
+
+    fn read_write_access<'a>(
+        &self,
+        stream: Pin<&'a mut Self::Stream>,
+    ) -> Result<Self::ReadWriteAccess<'a>, &'a io::Error> {
+        let stream = stream.project();
+        stream.0.read_write_access(Self::Instant::now())
+    }
+
+    fn wait_read_write_again<'a>(
+        &self,
+        stream: Pin<&'a mut Self::Stream>,
+    ) -> Self::StreamUpdateFuture<'a> {
+        let stream = stream.project();
+        Box::pin(stream.0.wait_read_write_again(|when| async move {
+            let now = super::wasm_helpers::now();
+            let duration = when.saturating_duration_since(now);
+            super::wasm_helpers::sleep(duration).await;
+        }))
+    }
+
+    fn log<'a>(
+        &self,
+        log_level: LogLevel,
+        log_target: &'a str,
+        message: &'a str,
+        key_values: impl Iterator<Item = (&'a str, &'a dyn fmt::Display)>,
+    ) {
+        // Smoldot is extremely chatty at debug/trace level (per-connection
+        // activity, gossip events, sync-service progress). Even with
+        // console.debug, which is hidden in Chrome's default verbosity,
+        // the volume costs measurable CPU on string formatting and shows
+        // up under Verbose. Suppress debug+trace entirely; warn/error/info
+        // still pass through so real problems surface.
+        if matches!(log_level, LogLevel::Debug | LogLevel::Trace) {
+            return;
+        }
+
+        let mut message_build = String::with_capacity(128);
+        message_build.push_str(message);
+        let mut first = true;
+        for (key, value) in key_values {
+            if first {
+                let _ = write!(message_build, "; ");
+                first = false;
+            } else {
+                let _ = write!(message_build, ", ");
+            }
+            let _ = write!(message_build, "{key}={value}");
+        }
+
+        let formatted = format!("[{log_target}] {message_build}");
+        let js = JsValue::from_str(&formatted);
+        match log_level {
+            LogLevel::Error => web_sys::console::error_1(&js),
+            LogLevel::Warn => web_sys::console::warn_1(&js),
+            LogLevel::Info => web_sys::console::info_1(&js),
+            LogLevel::Debug | LogLevel::Trace => unreachable!(),
+        }
+    }
+}
diff --git a/rust/crates/truapi-server/src/smoldot_provider/wasm_socket.rs b/rust/crates/truapi-server/src/smoldot_provider/wasm_socket.rs
new file mode 100644
index 00000000..ac96b881
--- /dev/null
+++ b/rust/crates/truapi-server/src/smoldot_provider/wasm_socket.rs
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: Apache-2.0
+// Vendored from subxt-lightclient 0.50.0 (Apache-2.0 OR GPL-3.0), elected
+// under Apache-2.0. See ../../THIRD_PARTY_NOTICES.md for attribution.
+
+use futures::{io, prelude::*};
+use send_wrapper::SendWrapper;
+use wasm_bindgen::{JsCast, prelude::*};
+
+use derive_more::Display;
+use std::{
+    collections::VecDeque,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::Poll,
+    task::{Context, Waker},
+};
+
+/// Errors returned by the wasm-side socket constructor.
+#[derive(Debug, Display)]
+pub enum Error {
+    /// Wraps a JS-side connection failure.
+    #[display("Failed to connect {_0}")]
+    ConnectionError(String),
+}
+
+impl std::error::Error for Error {}
+
+/// WebSocket for WASM environments. Not safe to clone because the inner
+/// `web_sys::WebSocket` is not thread-safe and the wakers borrow the same
+/// `Mutex`.
+pub struct WasmSocket {
+    inner: Arc<Mutex<InnerWasmSocket>>,
+    socket: SendWrapper<web_sys::WebSocket>,
+    _callbacks: SendWrapper<Callbacks>,
+}
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum ConnectionState {
+    Connecting,
+    Opened,
+    Closed,
+    Error,
+}
+
+struct InnerWasmSocket {
+    state: ConnectionState,
+    data: VecDeque<u8>,
+    waker: Option<Waker>,
+}
+
+type Callbacks = (
+    Closure<dyn FnMut()>,
+    Closure<dyn FnMut(web_sys::MessageEvent)>,
+    Closure<dyn FnMut(web_sys::Event)>,
+    Closure<dyn FnMut(web_sys::CloseEvent)>,
+);
+
+impl WasmSocket {
+    /// Opens a new WebSocket connection to the given URL. Returns an error
+    /// if the browser refuses to construct the underlying `WebSocket`
+    /// object.
+    pub fn new(addr: &str) -> Result<Self, Error> {
+        let socket = match web_sys::WebSocket::new(addr) {
+            Ok(socket) => socket,
+            Err(err) => return Err(Error::ConnectionError(format!("{err:?}"))),
+        };
+
+        socket.set_binary_type(web_sys::BinaryType::Arraybuffer);
+
+        let inner = Arc::new(Mutex::new(InnerWasmSocket {
+            state: ConnectionState::Connecting,
+            data: VecDeque::with_capacity(16384),
+            waker: None,
+        }));
+
+        let open_callback = Closure::<dyn FnMut()>::new({
+            let inner = inner.clone();
+            move || {
+                let mut inner = inner.lock().expect("Mutex is poised; qed");
+                inner.state = ConnectionState::Opened;
+
+                if let Some(waker) = inner.waker.take() {
+                    waker.wake();
+                }
+            }
+        });
+        socket.set_onopen(Some(open_callback.as_ref().unchecked_ref()));
+
+        let message_callback = Closure::<dyn FnMut(_)>::new({
+            let inner = inner.clone();
+            move |event: web_sys::MessageEvent| {
+                let Ok(buffer) = event.data().dyn_into::<js_sys::ArrayBuffer>() else {
+                    panic!("Unexpected data format {:?}", event.data());
+                };
+
+                let mut inner = inner.lock().expect("Mutex is poised; qed");
+                let bytes = js_sys::Uint8Array::new(&buffer).to_vec();
+                inner.data.extend(bytes);
+
+                if let Some(waker) = inner.waker.take() {
+                    waker.wake();
+                }
+            }
+        });
+        socket.set_onmessage(Some(message_callback.as_ref().unchecked_ref()));
+
+        let error_callback = Closure::<dyn FnMut(_)>::new({
+            let inner = inner.clone();
+            move |_event: web_sys::Event| {
+                let mut inner = inner.lock().expect("Mutex is poised; qed");
+                inner.state = ConnectionState::Error;
+
+                if let Some(waker) = inner.waker.take() {
+                    waker.wake();
+                }
+            }
+        });
+        socket.set_onerror(Some(error_callback.as_ref().unchecked_ref()));
+
+        let close_callback = Closure::<dyn FnMut(_)>::new({
+            let inner = inner.clone();
+            move |_event: web_sys::CloseEvent| {
+                let mut inner = inner.lock().expect("Mutex is poised; qed");
+                inner.state = ConnectionState::Closed;
+
+                if let Some(waker) = inner.waker.take() {
+                    waker.wake();
+                }
+            }
+        });
+        socket.set_onclose(Some(close_callback.as_ref().unchecked_ref()));
+
+        let callbacks = (
+            open_callback,
+            message_callback,
+            error_callback,
+            close_callback,
+        );
+
+        Ok(Self {
+            inner,
+            socket: SendWrapper::new(socket),
+            _callbacks: SendWrapper::new(callbacks),
+        })
+    }
+}
+
+impl AsyncRead for WasmSocket {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        let mut inner = self.inner.lock().expect("Mutex is poised; qed");
+        inner.waker = Some(cx.waker().clone());
+
+        if self.socket.ready_state() == web_sys::WebSocket::CONNECTING {
+            return Poll::Pending;
+        }
+
+        match inner.state {
+            ConnectionState::Error => Poll::Ready(Err(io::Error::other("Socket error"))),
+            ConnectionState::Closed => Poll::Ready(Err(io::ErrorKind::BrokenPipe.into())),
+            ConnectionState::Connecting => Poll::Pending,
+            ConnectionState::Opened => {
+                if inner.data.is_empty() {
+                    return Poll::Pending;
+                }
+
+                let n = inner.data.len().min(buf.len());
+                for k in buf.iter_mut().take(n) {
+                    *k = inner.data.pop_front().expect("Buffer non empty; qed");
+                }
+                Poll::Ready(Ok(n))
+            }
+        }
+    }
+}
+
+impl AsyncWrite for WasmSocket {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        let mut inner = self.inner.lock().expect("Mutex is poised; qed");
+        inner.waker = Some(cx.waker().clone());
+
+        match inner.state {
+            ConnectionState::Error => Poll::Ready(Err(io::Error::other("Socket error"))),
+            ConnectionState::Closed => Poll::Ready(Err(io::ErrorKind::BrokenPipe.into())),
+            ConnectionState::Connecting => Poll::Pending,
+            ConnectionState::Opened => match self.socket.send_with_u8_array(buf) {
+                Ok(()) => Poll::Ready(Ok(buf.len())),
+                Err(err) => Poll::Ready(Err(io::Error::other(format!("Write error: {err:?}")))),
+            },
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        if self.socket.ready_state() == web_sys::WebSocket::CLOSED {
+            return Poll::Ready(Ok(()));
+        }
+
+        if self.socket.ready_state() != web_sys::WebSocket::CLOSING {
+            let _ = self.socket.close();
+        }
+
+        let mut inner = self.inner.lock().expect("Mutex is poised; qed");
+        inner.waker = Some(cx.waker().clone());
+        Poll::Pending
+    }
+}
+
+impl Drop for WasmSocket {
+    fn drop(&mut self) {
+        if self.socket.ready_state() != web_sys::WebSocket::CLOSING {
+            let _ = self.socket.close();
+        }
+
+        self.socket.set_onopen(None);
+        self.socket.set_onmessage(None);
+        self.socket.set_onerror(None);
+        self.socket.set_onclose(None);
+    }
+}
diff --git a/rust/crates/truapi-server/src/subscription.rs b/rust/crates/truapi-server/src/subscription.rs
new file mode 100644
index 00000000..8b24fd98
--- /dev/null
+++ b/rust/crates/truapi-server/src/subscription.rs
@@ -0,0 +1,495 @@
+//! Subscription lifecycle management.
+//!
+//! Tracks active subscriptions (start/receive/stop/interrupt) and handles
+//! cleanup when either side terminates. Each registered subscription drives
+//! its stream on a caller-supplied [`Spawner`]; the manager itself never
+//! creates threads or runtimes.
+
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+
+use futures::StreamExt;
+use futures::future::{BoxFuture, Either, select};
+use futures::stream::BoxStream;
+use parity_scale_codec::Encode;
+
+use crate::frame::{Payload, ProtocolMessage};
+use crate::transport::Transport;
+
+type StopFn = Box<dyn FnOnce() + Send>;
+
+/// Spawns a subscription-driving future onto the caller's runtime. The
+/// future is `Send` because the inner [`SubscriptionStream`] is a
+/// `BoxStream<'static, _>` and every captured value the manager threads
+/// through it is also `Send`. Each platform bridge supplies an
+/// implementation that hands the future to the runtime driving its
+/// transport (tokio `LocalSet`, `wasm_bindgen_futures::spawn_local`, ...).
+pub type Spawner = Arc<dyn Fn(BoxFuture<'static, ()>) + Send + Sync>;
+
+/// Convenience spawner for tests and embedders that don't yet wire a
+/// real runtime: starts a fresh OS thread per subscription and drives the
+/// future with `futures::executor::block_on`. Not available on wasm32 since
+/// the platform has no threads.
+#[cfg(not(target_arch = "wasm32"))]
+pub fn thread_per_subscription_spawner() -> Spawner {
+    Arc::new(|fut: BoxFuture<'static, ()>| {
+        std::thread::spawn(move || futures::executor::block_on(fut));
+    })
+}
+
+/// One yielded value of a subscription stream after SCALE-encoding.
+pub enum SubscriptionOutput {
+    /// A regular subscription item to deliver as a `_receive` frame.
+    Item(Vec<u8>),
+    /// Stream-initiated termination delivered as an `_interrupt` frame.
+    Interrupt(Vec<u8>),
+}
+
+/// Boxed stream of [`SubscriptionOutput`] consumed by the dispatcher.
+pub type SubscriptionStream = BoxStream<'static, SubscriptionOutput>;
+
+/// Wrap a host-side stream of typed items into the SCALE-encoded
+/// [`SubscriptionStream`] that the dispatcher delivers to the transport.
+///
+/// `Item` is the versioned wrapper for each emitted value (e.g.
+/// `versioned::account::HostAccountConnectionStatusSubscribeItem`). The
+/// generated dispatcher calls this with the second type parameter inferred
+/// from the host trait return.
+pub fn subscription_stream<Item, S>(stream: S) -> SubscriptionStream
+where
+    Item: Encode + 'static,
+    S: futures::Stream<Item = Item> + Send + 'static,
+{
+    Box::pin(stream.map(|item| SubscriptionOutput::Item(item.encode())))
+}
+
+/// Generation-stamped slot tracking the lifecycle of one subscription id.
+/// `request_id` is client-controlled and may be reused or raced against a
+/// `_stop`, so each reservation carries a monotonic generation and only the
+/// owner of the current generation may transition or remove the slot.
+enum Slot {
+    /// Reserved by the dispatcher before its `_start` handler resolved.
+    /// `cancelled` flips to `true` if a `_stop` arrives in that window so
+    /// activation aborts instead of leaking an unstoppable stream.
+    Pending { generation: u64, cancelled: bool },
+    /// A live subscription with its cancellation handle.
+    Live { generation: u64, cancel: StopFn },
+}
+
+/// Handle returned by [`SubscriptionManager::reserve`] and presented back to
+/// [`SubscriptionManager::activate`]. Ties an activation to the exact
+/// reservation it belongs to so a superseding `_start` for the same id
+/// cannot be activated by a stale handler.
+pub struct ReservationToken {
+    request_id: String,
+    generation: u64,
+}
+
+/// Manages active subscriptions on the server side.
+pub struct SubscriptionManager {
+    active: Arc<Mutex<HashMap<String, Slot>>>,
+    next_generation: Arc<AtomicU64>,
+    spawner: Spawner,
+}
+
+impl SubscriptionManager {
+    /// Create an empty manager driven by `spawner`.
+    pub fn new(spawner: Spawner) -> Self {
+        Self {
+            active: Arc::new(Mutex::new(HashMap::new())),
+            next_generation: Arc::new(AtomicU64::new(0)),
+            spawner,
+        }
+    }
+
+    /// Reserve the slot for `request_id` before its subscription stream is
+    /// available. Any live subscription already under that id is stopped and
+    /// replaced (re-subscribe semantics). A `_stop` arriving before
+    /// [`activate`](Self::activate) flips the reservation to cancelled.
+    pub fn reserve(&self, request_id: String) -> ReservationToken {
+        let generation = self.next_generation.fetch_add(1, Ordering::Relaxed);
+        let mut active = self.active.lock().unwrap();
+        if let Some(Slot::Live { cancel, .. }) = active.insert(
+            request_id.clone(),
+            Slot::Pending {
+                generation,
+                cancelled: false,
+            },
+        ) {
+            cancel();
+        }
+        ReservationToken {
+            request_id,
+            generation,
+        }
+    }
+
+    /// Drop a reservation whose `_start` handler failed before producing a
+    /// stream. No-op if the slot was superseded by a newer reservation.
+    pub fn cancel_reservation(&self, token: ReservationToken) {
+        let mut active = self.active.lock().unwrap();
+        let owned = matches!(
+            active.get(&token.request_id),
+            Some(Slot::Pending { generation, .. }) if *generation == token.generation
+        );
+        if owned {
+            active.remove(&token.request_id);
+        }
+    }
+
+    /// Activate a reserved subscription with its stream, forwarding stream
+    /// items as `_receive` frames until the stream ends or `_stop` is
+    /// received. No-ops without starting the stream if the reservation was
+    /// cancelled by a `_stop` or superseded by a newer reservation for the
+    /// same id.
+    pub fn activate(
+        &self,
+        token: ReservationToken,
+        receive_id: u8,
+        interrupt_id: u8,
+        mut stream: SubscriptionStream,
+        transport: Arc<dyn Transport>,
+    ) {
+        let ReservationToken {
+            request_id,
+            generation,
+        } = token;
+        let rid = request_id.clone();
+        let stream_transport = transport.clone();
+
+        // Cancellation channel.
+        let (cancel_tx, cancel_rx) = futures::channel::oneshot::channel::<()>();
+
+        // Transition the reserved slot to live, unless a `_stop` cancelled it
+        // or a newer reservation superseded it while the handler resolved.
+        {
+            let mut active = self.active.lock().unwrap();
+            match active.get(&request_id) {
+                Some(Slot::Pending {
+                    generation: g,
+                    cancelled,
+                }) if *g == generation => {
+                    if *cancelled {
+                        active.remove(&request_id);
+                        return;
+                    }
+                }
+                _ => return,
+            }
+            active.insert(
+                request_id.clone(),
+                Slot::Live {
+                    generation,
+                    cancel: Box::new(move || {
+                        let _ = cancel_tx.send(());
+                    }),
+                },
+            );
+        }
+
+        let active = self.active.clone();
+
+        let future: BoxFuture<'static, ()> = Box::pin(async move {
+            let completed = {
+                let mut cancel_rx = cancel_rx;
+                loop {
+                    match select(cancel_rx, stream.next()).await {
+                        Either::Left((_cancelled, _next)) => break false,
+                        Either::Right((item, next_cancel_rx)) => {
+                            cancel_rx = next_cancel_rx;
+                            match item {
+                                Some(SubscriptionOutput::Item(value)) => {
+                                    stream_transport.send(ProtocolMessage {
+                                        request_id: rid.clone(),
+                                        payload: Payload {
+                                            id: receive_id,
+                                            value,
+                                        },
+                                    })
+                                }
+                                Some(SubscriptionOutput::Interrupt(value)) => {
+                                    stream_transport.send(ProtocolMessage {
+                                        request_id: rid.clone(),
+                                        payload: Payload {
+                                            id: interrupt_id,
+                                            value,
+                                        },
+                                    });
+                                    break false;
+                                }
+                                None => break true,
+                            }
+                        }
+                    }
+                }
+            };
+
+            // Only remove the slot if it still holds THIS generation; a
+            // superseding reservation owns its own cleanup.
+            let removed = {
+                let mut active = active.lock().unwrap();
+                let owned = matches!(
+                    active.get(&request_id),
+                    Some(Slot::Live { generation: g, .. }) if *g == generation
+                );
+                if owned {
+                    active.remove(&request_id);
+                }
+                owned
+            };
+
+            if completed && removed {
+                transport.send(ProtocolMessage {
+                    request_id,
+                    payload: Payload {
+                        id: interrupt_id,
+                        value: Vec::new(),
+                    },
+                });
+            }
+        });
+
+        (self.spawner)(future);
+    }
+
+    /// Convenience for callers that already hold the stream with no async gap
+    /// between reservation and activation (tests and synchronous embedders).
+    pub fn register(
+        &self,
+        request_id: String,
+        receive_id: u8,
+        interrupt_id: u8,
+        stream: SubscriptionStream,
+        transport: Arc<dyn Transport>,
+    ) {
+        let token = self.reserve(request_id);
+        self.activate(token, receive_id, interrupt_id, stream, transport);
+    }
+
+    /// Handle a `_stop` frame from the product side. Cancels a live
+    /// subscription, or marks a still-pending reservation cancelled so its
+    /// in-flight activation aborts rather than leaking an unstoppable stream.
+    pub fn handle_stop(&self, request_id: &str) {
+        let mut active = self.active.lock().unwrap();
+        match active.get_mut(request_id) {
+            Some(Slot::Pending { cancelled, .. }) => {
+                *cancelled = true;
+            }
+            Some(Slot::Live { .. }) => {
+                if let Some(Slot::Live { cancel, .. }) = active.remove(request_id) {
+                    cancel();
+                }
+            }
+            None => {}
+        }
+    }
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use super::*;
+    use futures::stream;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    /// Transport that records every frame and notifies waiters when it
+    /// reaches a target count. Used to wait for the subscription's
+    /// background thread to drain a known number of frames.
+    struct RecordingTransport {
+        sent: Mutex<Vec<ProtocolMessage>>,
+        cvar: std::sync::Condvar,
+    }
+
+    impl RecordingTransport {
+        fn new() -> Self {
+            Self {
+                sent: Mutex::new(Vec::new()),
+                cvar: std::sync::Condvar::new(),
+            }
+        }
+        fn sent(&self) -> Vec<ProtocolMessage> {
+            self.sent.lock().unwrap().clone()
+        }
+        /// Wait until at least `count` frames have been recorded, or
+        /// `timeout` elapses. Returns the number of frames recorded at
+        /// wake-up time.
+        fn wait_for(&self, count: usize, timeout: std::time::Duration) -> usize {
+            let mut guard = self.sent.lock().unwrap();
+            let deadline = std::time::Instant::now() + timeout;
+            while guard.len() < count {
+                let now = std::time::Instant::now();
+                if now >= deadline {
+                    break;
+                }
+                let (new_guard, _) = self.cvar.wait_timeout(guard, deadline - now).unwrap();
+                guard = new_guard;
+            }
+            guard.len()
+        }
+    }
+
+    impl Transport for RecordingTransport {
+        fn send(&self, message: ProtocolMessage) {
+            self.sent.lock().unwrap().push(message);
+            self.cvar.notify_all();
+        }
+        fn on_message(
+            &self,
+            _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+        ) -> Box<dyn FnOnce()> {
+            Box::new(|| {})
+        }
+    }
+
+    fn dummy_stream(items: Vec<Vec<u8>>) -> SubscriptionStream {
+        Box::pin(stream::iter(
+            items.into_iter().map(SubscriptionOutput::Item),
+        ))
+    }
+
+    /// Register a never-ending stream then immediately stop it. The
+    /// stream's first poll must observe cancellation and exit without
+    /// having pushed any frame.
+    #[test]
+    fn register_then_stop_emits_no_extra_frames() {
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(thread_per_subscription_spawner());
+        let slow_stream: SubscriptionStream = Box::pin(stream::pending());
+        manager.register("p:1".to_string(), 99, 98, slow_stream, transport_dyn);
+        manager.handle_stop("p:1");
+        // Give the worker thread a beat to observe the cancel.
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        assert!(
+            transport_typed.sent().is_empty(),
+            "stopped subscription must not push any frame"
+        );
+    }
+
+    /// A stream that yields 2 items then ends naturally must produce 2
+    /// `_receive` frames followed by one `_interrupt` frame.
+    #[test]
+    fn register_completion_emits_interrupt() {
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(thread_per_subscription_spawner());
+        let items = dummy_stream(vec![vec![0xaa], vec![0xbb]]);
+        manager.register("p:1".to_string(), 99, 98, items, transport_dyn);
+        let observed = transport_typed.wait_for(3, std::time::Duration::from_secs(2));
+        assert_eq!(observed, 3, "expected 2 receive frames + 1 interrupt");
+        let frames = transport_typed.sent();
+        assert_eq!(frames[0].payload.id, 99);
+        assert_eq!(frames[0].payload.value, vec![0xaa]);
+        assert_eq!(frames[1].payload.id, 99);
+        assert_eq!(frames[1].payload.value, vec![0xbb]);
+        assert_eq!(frames[2].payload.id, 98);
+        assert_eq!(frames[2].payload.value, Vec::<u8>::new());
+    }
+
+    /// Calling `handle_stop` twice on the same request id must be a
+    /// no-op the second time around (the entry has already been removed,
+    /// no panic, no extra frames).
+    #[test]
+    fn double_stop_is_idempotent() {
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(thread_per_subscription_spawner());
+        let slow_stream: SubscriptionStream = Box::pin(stream::pending());
+        manager.register("p:1".to_string(), 99, 98, slow_stream, transport_dyn);
+        manager.handle_stop("p:1");
+        // Second call must not panic and must not emit any frame.
+        manager.handle_stop("p:1");
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        assert!(
+            transport_typed.sent().is_empty(),
+            "double-stop must not emit any frame"
+        );
+    }
+
+    /// The manager must drive subscriptions through the injected spawner,
+    /// not by reaching out to `std::thread::spawn` itself. The counter
+    /// inside the test spawner is the proof.
+    #[test]
+    fn subscription_uses_provided_spawner_not_native_thread() {
+        let invocations = Arc::new(AtomicUsize::new(0));
+        let invocations_for_spawner = invocations.clone();
+        let spawner: Spawner = Arc::new(move |fut: BoxFuture<'static, ()>| {
+            invocations_for_spawner.fetch_add(1, Ordering::SeqCst);
+            std::thread::spawn(move || futures::executor::block_on(fut));
+        });
+
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(spawner);
+        let items = dummy_stream(vec![vec![0xcc]]);
+        manager.register("p:1".to_string(), 99, 98, items, transport_dyn);
+
+        // Wait for the worker future to drain to completion so we know
+        // the spawner closure ran on this path.
+        let _ = transport_typed.wait_for(2, std::time::Duration::from_secs(2));
+        assert_eq!(
+            invocations.load(Ordering::SeqCst),
+            1,
+            "spawner must be invoked exactly once per register",
+        );
+    }
+
+    /// A `_stop` arriving before `activate` (the stop-before-register race on
+    /// non-serialized transports) must abort the subscription: no `_receive`
+    /// frames are emitted even though the stream had items to yield.
+    #[test]
+    fn stop_before_activate_aborts_subscription() {
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(thread_per_subscription_spawner());
+        let token = manager.reserve("p:1".to_string());
+        manager.handle_stop("p:1");
+        let items = dummy_stream(vec![vec![0x01], vec![0x02]]);
+        manager.activate(token, 99, 98, items, transport_dyn);
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        assert!(
+            transport_typed.sent().is_empty(),
+            "a stop before activate must abort the subscription"
+        );
+    }
+
+    /// Re-using a live request id (the duplicate-`_start` case) supersedes the
+    /// previous subscription rather than leaking it: the first stream is
+    /// stopped, only the second runs, and the superseded stream leaves no
+    /// frames behind.
+    #[test]
+    fn duplicate_start_supersedes_previous_without_leak() {
+        let transport_typed = Arc::new(RecordingTransport::new());
+        let transport_dyn: Arc<dyn Transport> = transport_typed.clone();
+        let manager = SubscriptionManager::new(thread_per_subscription_spawner());
+
+        // First subscription never yields; the second reservation for the
+        // same id must stop it.
+        let pending: SubscriptionStream = Box::pin(stream::pending());
+        manager.register("p:1".to_string(), 99, 98, pending, transport_dyn.clone());
+
+        // Second subscription yields one item then ends.
+        let items = dummy_stream(vec![vec![0xaa]]);
+        manager.register("p:1".to_string(), 99, 98, items, transport_dyn);
+
+        // Exactly the second stream's frames appear: one receive + one
+        // completion interrupt. The first (pending) stream contributes none.
+        let observed = transport_typed.wait_for(2, std::time::Duration::from_secs(2));
+        assert_eq!(
+            observed, 2,
+            "expected the second stream's receive + interrupt only"
+        );
+        let frames = transport_typed.sent();
+        assert_eq!(frames[0].payload.id, 99);
+        assert_eq!(frames[0].payload.value, vec![0xaa]);
+        assert_eq!(frames[1].payload.id, 98);
+
+        manager.handle_stop("p:1");
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        assert_eq!(
+            transport_typed.sent().len(),
+            2,
+            "no leaked frames from the superseded stream"
+        );
+    }
+}
diff --git a/rust/crates/truapi-server/src/test_support.rs b/rust/crates/truapi-server/src/test_support.rs
new file mode 100644
index 00000000..107da47b
--- /dev/null
+++ b/rust/crates/truapi-server/src/test_support.rs
@@ -0,0 +1,955 @@
+//! Shared fixtures for the runtime test modules: a stub platform, a
+//! recording json-rpc connection, and SSO statement/frame builders.
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
+#[cfg(target_arch = "wasm32")]
+use web_time::Duration;
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::chain_runtime::thread_per_task_spawner;
+use crate::runtime::sso_pairing::PAIRING_SUBSCRIBE_REQUEST_ID;
+use crate::runtime::sso_remote::SharedRemoteSubscriptionId;
+use crate::subscription::Spawner;
+
+use aes_gcm::aead::{Aead, KeyInit};
+use aes_gcm::{Aes256Gcm, Nonce};
+use futures::StreamExt;
+use futures::stream::{self, BoxStream};
+use hkdf::Hkdf;
+use p256::PublicKey as P256PublicKey;
+use p256::SecretKey as P256SecretKey;
+use p256::ecdh::diffie_hellman;
+use p256::elliptic_curve::sec1::ToEncodedPoint;
+use parity_scale_codec::{Decode, Encode};
+use schnorrkel::{ExpansionMode, MiniSecretKey};
+use sha2::Sha256;
+use truapi::v01;
+use truapi::versioned::account::HostAccountGetAliasRequest;
+use truapi::versioned::resource_allocation::HostRequestResourceAllocationRequest;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi_platform::{
+    AuthPresenter, AuthState, ChainProvider, Features as PlatformFeatures, JsonRpcConnection,
+    Navigation as PlatformNavigation, Notifications as PlatformNotifications,
+    Permissions as PlatformPermissions, PreimageHost, RuntimeConfig, SessionStore,
+    Storage as PlatformStorage, ThemeHost, UserConfirmation,
+};
+
+pub(crate) fn test_spawner() -> Spawner {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        thread_per_task_spawner()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        immediate_spawner()
+    }
+}
+
+pub(crate) fn immediate_spawner() -> Spawner {
+    Arc::new(futures::executor::block_on)
+}
+
+pub(crate) fn remote_subscription_slot() -> SharedRemoteSubscriptionId {
+    Arc::new(Mutex::new(None))
+}
+
+/// Test hook invoked after each recorded auth state.
+pub(crate) type AuthStateHook = Arc<dyn Fn(&AuthState) + Send + Sync>;
+
+/// Minimal Platform impl that only answers `feature_supported`. Every
+/// other callback returns a unit value or empty stream, so the runtime
+/// can exercise its delegation paths without pulling in a real backend.
+pub(crate) struct StubPlatform {
+    pub(crate) remote_permission_granted: bool,
+    pub(crate) account_alias_confirmed: bool,
+    pub(crate) account_alias_error: Option<&'static str>,
+    pub(crate) sign_payload_confirmed: bool,
+    pub(crate) sign_payload_error: Option<&'static str>,
+    pub(crate) sign_raw_confirmed: bool,
+    pub(crate) sign_raw_error: Option<&'static str>,
+    pub(crate) create_transaction_confirmed: bool,
+    pub(crate) create_transaction_error: Option<&'static str>,
+    pub(crate) resource_allocation_confirmed: bool,
+    pub(crate) resource_allocation_error: Option<&'static str>,
+    pub(crate) session_blob: Option<Vec<u8>>,
+    pub(crate) session_error: Option<&'static str>,
+    pub(crate) session_clears: Arc<Mutex<usize>>,
+    pub(crate) session_writes: Arc<Mutex<Vec<Vec<u8>>>>,
+    /// Every `auth_state_changed` emission in order.
+    pub(crate) auth_states: Arc<Mutex<Vec<AuthState>>>,
+    /// Invoked after each recorded auth state, outside any stub lock, so a
+    /// test can react to a transition (e.g. cancel the login it observes).
+    pub(crate) on_auth_state: Arc<Mutex<Option<AuthStateHook>>>,
+    /// Set when a `chain_connect_pending` connect future is dropped, which is
+    /// how a dropped login flow manifests on the stub.
+    pub(crate) pending_connect_dropped: Arc<AtomicBool>,
+    pub(crate) pairing_success_response: bool,
+    /// Deliver the pairing success statement only through a snapshot
+    /// query page; the live subscription stays silent.
+    pub(crate) pairing_success_via_query: bool,
+    pub(crate) notification_id: v01::NotificationId,
+    pub(crate) pushed_notifications: Arc<Mutex<Vec<v01::HostPushNotificationRequest>>>,
+    pub(crate) cancelled_notifications: Arc<Mutex<Vec<v01::NotificationId>>>,
+    pub(crate) sent_rpc: Arc<Mutex<Vec<String>>>,
+    pub(crate) rpc_responses: Vec<String>,
+    pub(crate) chain_connect_error: Option<&'static str>,
+    pub(crate) chain_connect_pending: bool,
+    pub(crate) local_storage: Arc<Mutex<std::collections::HashMap<String, Vec<u8>>>>,
+    /// When set, `Storage::read` fails with this reason.
+    pub(crate) local_storage_error: Option<&'static str>,
+    /// When set, `clear_session` notifies the session-store subscription
+    /// through this sender, mimicking native hosts.
+    pub(crate) session_store_tick_tx:
+        Option<futures::channel::mpsc::UnboundedSender<SessionStoreTick>>,
+    /// When set, `subscribe_session_store` yields this channel instead of
+    /// the default single tick.
+    pub(crate) session_store_ticks:
+        Arc<Mutex<Option<futures::channel::mpsc::UnboundedReceiver<SessionStoreTick>>>>,
+}
+
+pub(crate) type SessionStoreTick = Result<(), v01::GenericError>;
+
+impl Default for StubPlatform {
+    fn default() -> Self {
+        Self {
+            remote_permission_granted: true,
+            account_alias_confirmed: false,
+            account_alias_error: None,
+            sign_payload_confirmed: false,
+            sign_payload_error: None,
+            sign_raw_confirmed: false,
+            sign_raw_error: None,
+            create_transaction_confirmed: false,
+            create_transaction_error: None,
+            resource_allocation_confirmed: false,
+            resource_allocation_error: None,
+            session_blob: None,
+            session_error: None,
+            session_clears: Arc::new(Mutex::new(0)),
+            session_writes: Arc::new(Mutex::new(Vec::new())),
+            auth_states: Arc::new(Mutex::new(Vec::new())),
+            on_auth_state: Arc::new(Mutex::new(None)),
+            pending_connect_dropped: Arc::new(AtomicBool::new(false)),
+            pairing_success_response: false,
+            pairing_success_via_query: false,
+            notification_id: 0,
+            pushed_notifications: Arc::new(Mutex::new(Vec::new())),
+            cancelled_notifications: Arc::new(Mutex::new(Vec::new())),
+            sent_rpc: Arc::new(Mutex::new(Vec::new())),
+            rpc_responses: Vec::new(),
+            chain_connect_error: None,
+            chain_connect_pending: false,
+            local_storage: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            local_storage_error: None,
+            session_store_tick_tx: None,
+            session_store_ticks: Arc::new(Mutex::new(None)),
+        }
+    }
+}
+
+struct DropFlagGuard(Arc<AtomicBool>);
+
+impl Drop for DropFlagGuard {
+    fn drop(&mut self) {
+        self.0.store(true, Ordering::SeqCst);
+    }
+}
+
+/// First `Pairing` deeplink recorded on `auth_states`, if any.
+pub(crate) fn first_pairing_deeplink(auth_states: &Mutex<Vec<AuthState>>) -> Option<String> {
+    auth_states
+        .lock()
+        .expect("auth state list mutex poisoned")
+        .iter()
+        .find_map(|state| match state {
+            AuthState::Pairing { deeplink } => Some(deeplink.clone()),
+            _ => None,
+        })
+}
+
+pub(crate) fn stub_platform() -> Arc<StubPlatform> {
+    Arc::new(StubPlatform::default())
+}
+
+pub(crate) fn runtime_config(product_id: &str) -> RuntimeConfig {
+    RuntimeConfig {
+        product_label: product_id.trim_end_matches(".dot").to_string(),
+        product_id: product_id.to_string(),
+        site_id: "test".to_string(),
+        host_name: "Polkadot Web".to_string(),
+        host_icon: Some("https://example.invalid/dotli.png".to_string()),
+        host_version: None,
+        platform_type: None,
+        platform_version: None,
+        people_chain_genesis_hash: [0; 32],
+        pairing_deeplink_scheme: truapi_platform::PairingDeeplinkScheme::PolkadotApp,
+    }
+}
+
+pub(crate) fn session_info() -> crate::host_logic::session::SessionInfo {
+    crate::host_logic::session::SessionInfo {
+        public_key: [
+            0x80, 0x05, 0x28, 0xc9, 0x55, 0x87, 0x3e, 0x4c, 0x78, 0xb7, 0xdf, 0x24, 0xf7, 0x1d,
+            0xb8, 0xf5, 0x81, 0xaa, 0x99, 0xe3, 0x49, 0x3b, 0xf4, 0x96, 0xed, 0xf1, 0x51, 0xab,
+            0xc1, 0xd7, 0x20, 0x23,
+        ],
+        sso: None,
+        root_entropy_source: Some([
+            0x15, 0xcb, 0x94, 0x34, 0x84, 0x0b, 0x56, 0xbe, 0x1f, 0xdd, 0x91, 0xc4, 0x6a, 0x13,
+            0xf5, 0x20, 0xf4, 0x91, 0x61, 0x2e, 0xa5, 0xd6, 0x06, 0x92, 0x0d, 0x91, 0x38, 0xe8,
+            0xbd, 0xd6, 0x3c, 0xb0,
+        ]),
+        identity_account_id: Some([
+            0x80, 0x05, 0x28, 0xc9, 0x55, 0x87, 0x3e, 0x4c, 0x78, 0xb7, 0xdf, 0x24, 0xf7, 0x1d,
+            0xb8, 0xf5, 0x81, 0xaa, 0x99, 0xe3, 0x49, 0x3b, 0xf4, 0x96, 0xed, 0xf1, 0x51, 0xab,
+            0xc1, 0xd7, 0x20, 0x23,
+        ]),
+        lite_username: Some("alice".to_string()),
+        full_username: Some("Alice Smith".to_string()),
+    }
+}
+
+pub(crate) fn sso_session_info() -> crate::host_logic::session::SessionInfo {
+    let mut session = session_info();
+    let mini_secret = MiniSecretKey::from_bytes(&[7; 32]).unwrap();
+    let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+    let (_, peer_public_key) = peer_statement_keypair();
+    let core_secret = P256SecretKey::from_slice(&[1; 32]).unwrap();
+    let peer_secret = P256SecretKey::from_slice(&[2; 32]).unwrap();
+    session.sso = Some(crate::host_logic::session::SsoSessionInfo {
+        ss_secret: keypair.secret.to_bytes(),
+        ss_public_key: keypair.public.to_bytes(),
+        enc_secret: core_secret.to_bytes().into(),
+        peer_enc_pubkey: peer_secret
+            .public_key()
+            .to_encoded_point(false)
+            .as_bytes()
+            .try_into()
+            .unwrap(),
+        identity_account_id: peer_public_key,
+        session_id_own: [4; 32],
+        session_id_peer: [5; 32],
+        request_channel: [6; 32],
+        response_channel: [7; 32],
+        peer_request_channel: [8; 32],
+    });
+    session.root_entropy_source = Some(keypair.secret.to_bytes()[..32].try_into().unwrap());
+    session
+}
+
+pub(crate) fn peer_statement_keypair() -> ([u8; 64], [u8; 32]) {
+    let mini_secret = MiniSecretKey::from_bytes(&[9; 32]).unwrap();
+    let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+    (keypair.secret.to_bytes(), keypair.public.to_bytes())
+}
+
+pub(crate) fn signed_test_statement(data: Vec<u8>) -> Vec<u8> {
+    let (secret, public) = peer_statement_keypair();
+    crate::host_logic::statement_store::sign_statement_fields(
+        secret,
+        public,
+        vec![crate::host_logic::statement_store::StatementField::Data(
+            data,
+        )],
+    )
+    .unwrap()
+    .encode()
+}
+
+pub(crate) fn submitted_remote_message(
+    platform: &Arc<StubPlatform>,
+    session: &crate::host_logic::session::SessionInfo,
+) -> crate::host_logic::sso_messages::RemoteMessage {
+    let sent = platform.sent_rpc.lock().expect("rpc list mutex poisoned");
+    let submit = sent
+        .iter()
+        .rev()
+        .find(|request| request.contains("\"statement_submit\""))
+        .expect("statement_submit request should be sent");
+    let value: serde_json::Value = serde_json::from_str(submit).unwrap();
+    let statement_hex = value["params"][0].as_str().unwrap();
+    let statement = hex::decode(statement_hex.strip_prefix("0x").unwrap_or(statement_hex)).unwrap();
+    let encrypted = crate::host_logic::statement_store::decode_statement_data(&statement)
+        .expect("statement data should decode");
+    let data = crate::host_logic::sso_pairing::decrypt_session_statement_data(
+        session.sso.as_ref().unwrap(),
+        &encrypted,
+    )
+    .expect("statement data should decrypt");
+    let crate::host_logic::sso_pairing::SsoStatementData::Request { data, .. } = data else {
+        panic!("expected request statement data");
+    };
+    crate::host_logic::sso_messages::RemoteMessage::decode(&mut data[0].as_slice())
+        .expect("remote message should decode")
+}
+
+pub(crate) fn sso_success_responses(
+    session: &crate::host_logic::session::SessionInfo,
+    message_id: &str,
+    response: crate::host_logic::sso_messages::RemoteMessage,
+) -> Vec<String> {
+    let own_subscription_id = format!("own-sub-{message_id}");
+    let peer_subscription_id = format!("peer-sub-{message_id}");
+    vec![
+        subscribe_ack_frame(
+            &format!("truapi:sso-sub-own:{message_id}"),
+            &own_subscription_id,
+        ),
+        subscribe_ack_frame(
+            &format!("truapi:sso-sub-peer:{message_id}"),
+            &peer_subscription_id,
+        ),
+        new_statements_frame(
+            &own_subscription_id,
+            vec![sso_statement(
+                session,
+                crate::host_logic::sso_pairing::SsoStatementData::Response {
+                    request_id: message_id.to_string(),
+                    response_code: 0,
+                },
+                1,
+            )],
+        ),
+        new_statements_frame(
+            &peer_subscription_id,
+            vec![sso_statement(
+                session,
+                crate::host_logic::sso_pairing::SsoStatementData::Request {
+                    request_id: format!("wallet-response-{message_id}"),
+                    data: vec![response.encode()],
+                },
+                2,
+            )],
+        ),
+    ]
+}
+
+pub(crate) fn sso_peer_disconnect_responses(
+    session: &crate::host_logic::session::SessionInfo,
+    message_id: &str,
+) -> Vec<String> {
+    let own_subscription_id = format!("own-sub-{message_id}");
+    let peer_subscription_id = format!("peer-sub-{message_id}");
+    vec![
+        subscribe_ack_frame(
+            &format!("truapi:sso-sub-own:{message_id}"),
+            &own_subscription_id,
+        ),
+        subscribe_ack_frame(
+            &format!("truapi:sso-sub-peer:{message_id}"),
+            &peer_subscription_id,
+        ),
+        new_statements_frame(
+            &own_subscription_id,
+            vec![sso_statement(
+                session,
+                crate::host_logic::sso_pairing::SsoStatementData::Response {
+                    request_id: message_id.to_string(),
+                    response_code: 0,
+                },
+                1,
+            )],
+        ),
+        new_statements_frame(
+            &peer_subscription_id,
+            vec![sso_statement(
+                session,
+                crate::host_logic::sso_pairing::SsoStatementData::Request {
+                    request_id: format!("wallet-disconnect-{message_id}"),
+                    data: vec![
+                        crate::host_logic::sso_messages::RemoteMessage {
+                            message_id: format!("wallet-disconnect-{message_id}"),
+                            data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+                                crate::host_logic::sso_messages::RemoteMessageV1::Disconnected,
+                            ),
+                        }
+                        .encode(),
+                    ],
+                },
+                2,
+            )],
+        ),
+    ]
+}
+
+pub(crate) fn subscribe_ack_frame(request_id: &str, subscription_id: &str) -> String {
+    serde_json::json!({
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "result": subscription_id,
+    })
+    .to_string()
+}
+
+pub(crate) fn new_statements_frame(subscription_id: &str, statements: Vec<Vec<u8>>) -> String {
+    let statements = statements
+        .into_iter()
+        .map(|statement| format!("0x{}", hex::encode(statement)))
+        .collect::<Vec<_>>();
+    serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "statement_subscribeStatement",
+        "params": {
+            "subscription": subscription_id,
+            "result": {
+                "event": "newStatements",
+                "data": {
+                    "statements": statements,
+                    "remaining": 0,
+                },
+            },
+        },
+    })
+    .to_string()
+}
+
+fn sso_statement(
+    session: &crate::host_logic::session::SessionInfo,
+    data: crate::host_logic::sso_pairing::SsoStatementData,
+    nonce_seed: u8,
+) -> Vec<u8> {
+    let mut nonce = [0; crate::host_logic::sso_pairing::AES_GCM_NONCE_LEN];
+    nonce[0] = nonce_seed;
+    let encrypted = crate::host_logic::sso_pairing::encrypt_session_statement_data_with_nonce(
+        session.sso.as_ref().unwrap(),
+        &data,
+        nonce,
+    )
+    .unwrap();
+    signed_test_statement(encrypted)
+}
+
+fn core_encryption_public_key_from_deeplink(deeplink: &str) -> [u8; 65] {
+    pairing_device_from_deeplink(deeplink).1
+}
+
+pub(crate) fn pairing_device_from_deeplink(deeplink: &str) -> ([u8; 32], [u8; 65]) {
+    let encoded = deeplink
+        .split("handshake=")
+        .nth(1)
+        .expect("pairing deeplink should include handshake");
+    let handshake = hex::decode(encoded).expect("handshake should be hex");
+    let decoded = crate::host_logic::sso_pairing::VersionedHandshakeProposal::decode(
+        &mut handshake.as_slice(),
+    )
+    .expect("handshake should decode");
+    let crate::host_logic::sso_pairing::VersionedHandshakeProposal::V2(proposal) = decoded else {
+        panic!("handshake should be V2");
+    };
+    (
+        proposal.device.statement_account_id,
+        proposal.device.encryption_public_key,
+    )
+}
+
+fn wallet_handshake_statement(deeplink: &str) -> Vec<u8> {
+    let core_public_key =
+        P256PublicKey::from_sec1_bytes(&core_encryption_public_key_from_deeplink(deeplink))
+            .expect("core encryption public key should decode");
+    let wallet_ephemeral_secret = P256SecretKey::from_slice(&[3; 32]).unwrap();
+    let wallet_ephemeral_public = wallet_ephemeral_secret.public_key().to_encoded_point(false);
+    let mut wallet_ephemeral_public_bytes = [0u8; 65];
+    wallet_ephemeral_public_bytes.copy_from_slice(wallet_ephemeral_public.as_bytes());
+    let wallet_persistent_public: [u8; 65] = P256SecretKey::from_slice(&[2; 32])
+        .unwrap()
+        .public_key()
+        .to_encoded_point(false)
+        .as_bytes()
+        .try_into()
+        .unwrap();
+    let answer = crate::host_logic::sso_pairing::EncryptedHandshakeResponseV2::Success(Box::new(
+        crate::host_logic::sso_pairing::HandshakeSuccessV2 {
+            identity_account_id: peer_statement_keypair().1,
+            root_account_id: session_info().public_key,
+            identity_chat_private_key: [0x77; 32],
+            sso_enc_pub_key: wallet_persistent_public,
+            device_enc_pub_key: wallet_persistent_public,
+            root_entropy_source: [0x66; 32],
+        },
+    ));
+    let shared_secret = diffie_hellman(
+        wallet_ephemeral_secret.to_nonzero_scalar(),
+        core_public_key.as_affine(),
+    );
+    let hkdf = Hkdf::<Sha256>::new(None, shared_secret.raw_secret_bytes());
+    let mut aes_key = [0u8; 32];
+    hkdf.expand(&[], &mut aes_key).unwrap();
+    let nonce = [0x44; crate::host_logic::sso_pairing::AES_GCM_NONCE_LEN];
+    let cipher = Aes256Gcm::new_from_slice(&aes_key).unwrap();
+    let mut encrypted_message = nonce.to_vec();
+    encrypted_message.extend(
+        cipher
+            .encrypt(Nonce::from_slice(&nonce), answer.encode().as_slice())
+            .unwrap(),
+    );
+    let handshake = crate::host_logic::sso_pairing::VersionedHandshakeResponse::V2 {
+        encrypted_message,
+        public_key: wallet_ephemeral_public_bytes,
+    };
+
+    signed_test_statement(handshake.encode())
+}
+
+pub(crate) fn sign_response_message(
+    message_id: &str,
+    signature: Vec<u8>,
+    signed_transaction: Option<Vec<u8>>,
+) -> crate::host_logic::sso_messages::RemoteMessage {
+    crate::host_logic::sso_messages::RemoteMessage {
+        message_id: format!("wallet-{message_id}"),
+        data: crate::host_logic::sso_messages::RemoteMessageData::V1(
+            crate::host_logic::sso_messages::RemoteMessageV1::SignResponse(
+                crate::host_logic::sso_messages::SigningResponse {
+                    responding_to: message_id.to_string(),
+                    payload: Ok(
+                        crate::host_logic::sso_messages::SigningPayloadResponseData {
+                            signature,
+                            signed_transaction,
+                        },
+                    ),
+                },
+            ),
+        ),
+    }
+}
+
+pub(crate) fn account_id(identifier: &str, derivation_index: u32) -> v01::ProductAccountId {
+    v01::ProductAccountId {
+        dot_ns_identifier: identifier.to_string(),
+        derivation_index,
+    }
+}
+
+pub(crate) fn account_alias_request(identifier: &str) -> HostAccountGetAliasRequest {
+    HostAccountGetAliasRequest::V1(v01::HostAccountGetAliasRequest {
+        product_account_id: account_id(identifier, 0),
+    })
+}
+
+pub(crate) fn raw_payload() -> v01::RawPayload {
+    v01::RawPayload::Bytes {
+        bytes: b"hello".to_vec(),
+    }
+}
+
+pub(crate) fn sign_payload_data() -> v01::HostSignPayloadData {
+    v01::HostSignPayloadData {
+        block_hash: vec![0; 32],
+        block_number: vec![0; 4],
+        era: vec![0],
+        genesis_hash: vec![1; 32],
+        method: vec![0],
+        nonce: vec![0],
+        spec_version: vec![0],
+        tip: vec![0],
+        transaction_version: vec![0],
+        signed_extensions: vec![],
+        version: 4,
+        asset_id: None,
+        metadata_hash: None,
+        mode: None,
+        with_signed_transaction: None,
+    }
+}
+
+pub(crate) fn product_tx_payload(identifier: &str) -> v01::ProductAccountTxPayload {
+    v01::ProductAccountTxPayload {
+        signer: account_id(identifier, 0),
+        genesis_hash: [1; 32],
+        call_data: vec![0],
+        extensions: vec![],
+        tx_ext_version: 0,
+    }
+}
+
+pub(crate) fn resource_allocation_request() -> HostRequestResourceAllocationRequest {
+    HostRequestResourceAllocationRequest::V1(v01::HostRequestResourceAllocationRequest {
+        resources: vec![
+            v01::AllocatableResource::StatementStoreAllowance,
+            v01::AllocatableResource::AutoSigning,
+        ],
+    })
+}
+
+pub(crate) fn statement() -> v01::Statement {
+    v01::Statement {
+        proof: None,
+        decryption_key: None,
+        expiry: Some(99),
+        channel: Some([1; 32]),
+        topics: vec![[2; 32], [3; 32]],
+        data: Some(vec![4, 5, 6]),
+    }
+}
+
+pub(crate) fn signed_statement(topic: [u8; 32]) -> v01::SignedStatement {
+    v01::SignedStatement {
+        proof: v01::StatementProof::Sr25519 {
+            signature: [9; 64],
+            signer: [8; 32],
+        },
+        decryption_key: None,
+        expiry: Some(99),
+        channel: Some([1; 32]),
+        topics: vec![topic],
+        data: Some(vec![4, 5, 6]),
+    }
+}
+
+impl PlatformStorage for StubPlatform {
+    async fn read(&self, key: String) -> Result<Option<Vec<u8>>, v01::HostLocalStorageReadError> {
+        if let Some(reason) = self.local_storage_error {
+            return Err(v01::HostLocalStorageReadError::Unknown {
+                reason: reason.to_string(),
+            });
+        }
+        Ok(self
+            .local_storage
+            .lock()
+            .expect("local storage mutex poisoned")
+            .get(&key)
+            .cloned())
+    }
+    async fn write(
+        &self,
+        key: String,
+        value: Vec<u8>,
+    ) -> Result<(), v01::HostLocalStorageReadError> {
+        self.local_storage
+            .lock()
+            .expect("local storage mutex poisoned")
+            .insert(key, value);
+        Ok(())
+    }
+    async fn clear(&self, key: String) -> Result<(), v01::HostLocalStorageReadError> {
+        self.local_storage
+            .lock()
+            .expect("local storage mutex poisoned")
+            .remove(&key);
+        Ok(())
+    }
+}
+
+impl PlatformNavigation for StubPlatform {
+    async fn navigate_to(&self, _url: String) -> Result<(), v01::HostNavigateToError> {
+        Ok(())
+    }
+}
+
+impl PlatformNotifications for StubPlatform {
+    async fn push_notification(
+        &self,
+        notification: v01::HostPushNotificationRequest,
+    ) -> Result<v01::HostPushNotificationResponse, v01::GenericError> {
+        self.pushed_notifications
+            .lock()
+            .expect("notification list mutex poisoned")
+            .push(notification);
+        Ok(v01::HostPushNotificationResponse {
+            id: self.notification_id,
+        })
+    }
+
+    async fn cancel_notification(&self, id: u32) -> Result<(), v01::GenericError> {
+        self.cancelled_notifications
+            .lock()
+            .expect("notification cancellation list mutex poisoned")
+            .push(id);
+        Ok(())
+    }
+}
+
+impl PlatformPermissions for StubPlatform {
+    async fn device_permission(
+        &self,
+        _request: v01::HostDevicePermissionRequest,
+    ) -> Result<v01::HostDevicePermissionResponse, v01::GenericError> {
+        Ok(v01::HostDevicePermissionResponse { granted: true })
+    }
+
+    async fn remote_permission(
+        &self,
+        _request: v01::RemotePermissionRequest,
+    ) -> Result<v01::RemotePermissionResponse, v01::GenericError> {
+        Ok(v01::RemotePermissionResponse {
+            granted: self.remote_permission_granted,
+        })
+    }
+}
+
+impl PlatformFeatures for StubPlatform {
+    async fn feature_supported(
+        &self,
+        request: HostFeatureSupportedRequest,
+    ) -> Result<HostFeatureSupportedResponse, v01::GenericError> {
+        let HostFeatureSupportedRequest::V1(_) = request;
+        Ok(HostFeatureSupportedResponse::V1(
+            v01::HostFeatureSupportedResponse { supported: true },
+        ))
+    }
+}
+
+struct RecordingConnection {
+    sent: Arc<Mutex<Vec<String>>>,
+    responses: Vec<String>,
+    auth_states: Arc<Mutex<Vec<AuthState>>>,
+    pairing_success_response: bool,
+    pairing_success_via_query: bool,
+}
+
+impl JsonRpcConnection for RecordingConnection {
+    fn send(&self, request: String) {
+        self.sent
+            .lock()
+            .expect("rpc list mutex poisoned")
+            .push(request);
+    }
+    fn responses(&self) -> BoxStream<'static, String> {
+        if self.pairing_success_via_query {
+            let auth_states = self.auth_states.clone();
+            let sent = self.sent.clone();
+            return Box::pin(stream::unfold(0, move |state| {
+                let auth_states = auth_states.clone();
+                let sent = sent.clone();
+                async move {
+                    match state {
+                        0 => Some((
+                            subscribe_ack_frame(PAIRING_SUBSCRIBE_REQUEST_ID, "pairing-sub"),
+                            1,
+                        )),
+                        1 => {
+                            for _ in 0..100 {
+                                let query_id = sent
+                                    .lock()
+                                    .expect("rpc list mutex poisoned")
+                                    .iter()
+                                    .find_map(|request| {
+                                        let value: serde_json::Value =
+                                            serde_json::from_str(request).ok()?;
+                                        let id = value.get("id")?.as_str()?;
+                                        id.contains(":query:").then(|| id.to_string())
+                                    });
+                                if let Some(query_id) = query_id {
+                                    return Some((subscribe_ack_frame(&query_id, "query-sub"), 2));
+                                }
+                                futures_timer::Delay::new(Duration::from_millis(1)).await;
+                            }
+                            panic!("pairing snapshot query was not issued");
+                        }
+                        2 => {
+                            for _ in 0..100 {
+                                if let Some(deeplink) = first_pairing_deeplink(&auth_states) {
+                                    return Some((
+                                        new_statements_frame(
+                                            "query-sub",
+                                            vec![wallet_handshake_statement(&deeplink)],
+                                        ),
+                                        3,
+                                    ));
+                                }
+                                futures_timer::Delay::new(Duration::from_millis(1)).await;
+                            }
+                            panic!("pairing deeplink was not presented");
+                        }
+                        _ => None,
+                    }
+                }
+            }));
+        }
+        if self.pairing_success_response {
+            let auth_states = self.auth_states.clone();
+            return Box::pin(stream::unfold(0, move |state| {
+                let auth_states = auth_states.clone();
+                async move {
+                    match state {
+                        0 => Some((
+                            subscribe_ack_frame(PAIRING_SUBSCRIBE_REQUEST_ID, "pairing-sub"),
+                            1,
+                        )),
+                        1 => {
+                            for _ in 0..100 {
+                                if let Some(deeplink) = first_pairing_deeplink(&auth_states) {
+                                    return Some((
+                                        new_statements_frame(
+                                            "pairing-sub",
+                                            vec![wallet_handshake_statement(&deeplink)],
+                                        ),
+                                        2,
+                                    ));
+                                }
+                                futures_timer::Delay::new(Duration::from_millis(1)).await;
+                            }
+                            panic!("pairing deeplink was not presented");
+                        }
+                        _ => None,
+                    }
+                }
+            }));
+        }
+        if self.responses.is_empty() {
+            Box::pin(futures::stream::pending())
+        } else {
+            Box::pin(stream::iter(self.responses.clone()))
+        }
+    }
+}
+
+impl ChainProvider for StubPlatform {
+    async fn connect(
+        &self,
+        _genesis_hash: Vec<u8>,
+    ) -> Result<Box<dyn JsonRpcConnection>, v01::GenericError> {
+        if let Some(reason) = self.chain_connect_error {
+            return Err(v01::GenericError {
+                reason: reason.to_string(),
+            });
+        }
+        if self.chain_connect_pending {
+            let _guard = DropFlagGuard(self.pending_connect_dropped.clone());
+            futures::future::pending::<()>().await;
+        }
+        Ok(Box::new(RecordingConnection {
+            sent: self.sent_rpc.clone(),
+            responses: self.rpc_responses.clone(),
+            auth_states: self.auth_states.clone(),
+            pairing_success_response: self.pairing_success_response,
+            pairing_success_via_query: self.pairing_success_via_query,
+        }))
+    }
+}
+
+impl AuthPresenter for StubPlatform {
+    fn auth_state_changed(&self, state: AuthState) {
+        self.auth_states
+            .lock()
+            .expect("auth state list mutex poisoned")
+            .push(state.clone());
+        let hook = self
+            .on_auth_state
+            .lock()
+            .expect("auth state hook mutex poisoned")
+            .clone();
+        if let Some(hook) = hook {
+            hook(&state);
+        }
+    }
+}
+
+impl SessionStore for StubPlatform {
+    async fn read_session(&self) -> Result<Option<Vec<u8>>, v01::GenericError> {
+        if let Some(reason) = self.session_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.session_blob.clone())
+        }
+    }
+    async fn write_session(&self, value: Vec<u8>) -> Result<(), v01::GenericError> {
+        self.session_writes
+            .lock()
+            .expect("session write list mutex poisoned")
+            .push(value);
+        Ok(())
+    }
+    async fn clear_session(&self) -> Result<(), v01::GenericError> {
+        *self
+            .session_clears
+            .lock()
+            .expect("session clear counter mutex poisoned") += 1;
+        if let Some(sender) = &self.session_store_tick_tx {
+            let _ = sender.unbounded_send(Ok(()));
+        }
+        Ok(())
+    }
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), v01::GenericError>> {
+        if let Some(ticks) = self
+            .session_store_ticks
+            .lock()
+            .expect("session tick receiver mutex poisoned")
+            .take()
+        {
+            return ticks.boxed();
+        }
+        Box::pin(stream::once(async { Ok(()) }))
+    }
+}
+
+impl UserConfirmation for StubPlatform {
+    async fn confirm_sign_payload(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        if let Some(reason) = self.sign_payload_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.sign_payload_confirmed)
+        }
+    }
+    async fn confirm_sign_raw(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        if let Some(reason) = self.sign_raw_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.sign_raw_confirmed)
+        }
+    }
+    async fn confirm_create_transaction(
+        &self,
+        _review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        if let Some(reason) = self.create_transaction_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.create_transaction_confirmed)
+        }
+    }
+    async fn confirm_account_alias(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        if let Some(reason) = self.account_alias_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.account_alias_confirmed)
+        }
+    }
+    async fn confirm_resource_allocation(
+        &self,
+        _review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        if let Some(reason) = self.resource_allocation_error {
+            Err(v01::GenericError {
+                reason: reason.to_string(),
+            })
+        } else {
+            Ok(self.resource_allocation_confirmed)
+        }
+    }
+}
+
+impl ThemeHost for StubPlatform {
+    fn subscribe_theme(&self) -> BoxStream<'static, Result<v01::ThemeVariant, v01::GenericError>> {
+        Box::pin(stream::once(async { Ok(v01::ThemeVariant::Dark) }))
+    }
+}
+
+impl PreimageHost for StubPlatform {
+    async fn confirm_preimage_submit(&self, _size: u64) -> Result<(), v01::PreimageSubmitError> {
+        Ok(())
+    }
+    async fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, v01::PreimageSubmitError> {
+        Ok(value)
+    }
+    fn lookup_preimage(
+        &self,
+        _key: Vec<u8>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, v01::GenericError>> {
+        Box::pin(stream::once(async { Ok(Some(vec![9, 8, 7])) }))
+    }
+}
diff --git a/rust/crates/truapi-server/src/transport.rs b/rust/crates/truapi-server/src/transport.rs
new file mode 100644
index 00000000..ba58481f
--- /dev/null
+++ b/rust/crates/truapi-server/src/transport.rs
@@ -0,0 +1,12 @@
+//! Transport abstraction over platform-specific IPC mechanisms.
+
+use crate::frame::ProtocolMessage;
+
+/// A raw message pipe. Platform-specific implementations provide this.
+pub trait Transport: Send + Sync {
+    /// Send a protocol message to the other side.
+    fn send(&self, message: ProtocolMessage);
+
+    /// Register a handler for incoming messages. Returns an unsubscribe handle.
+    fn on_message(&self, handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>) -> Box<dyn FnOnce()>;
+}
diff --git a/rust/crates/truapi-server/src/wasm.rs b/rust/crates/truapi-server/src/wasm.rs
new file mode 100644
index 00000000..5316a1c1
--- /dev/null
+++ b/rust/crates/truapi-server/src/wasm.rs
@@ -0,0 +1,1128 @@
+//! wasm-bindgen surface. Exposes [`WasmTrUApiCore`] to JavaScript hosts so
+//! they can wire the TrUAPI core into a browser or worker shell.
+//!
+//! The browser side hands a `callbacks` object (a `JsBridge`) to the
+//! constructor. The bridge implements every host-side capability the
+//! [`truapi_platform::Platform`] trait set requires. Internally the bridge
+//! is wrapped in a [`SendWrapper`] so it satisfies the `Send` bound the
+//! platform trait set imposes; sound on wasm32 because the runtime is
+//! single-threaded.
+
+use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::task::{Context, Poll};
+
+use futures::channel::mpsc;
+use futures::future::{AbortHandle, Abortable};
+use futures::stream::{self, BoxStream, Stream, StreamExt};
+use js_sys::{Function, Reflect, Uint8Array};
+use parity_scale_codec::{Decode, Encode};
+use send_wrapper::SendWrapper;
+use truapi::v01;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi_platform::{
+    AuthPresenter, AuthState, ChainProvider, Features, JsonRpcConnection, Navigation,
+    Notifications, PairingDeeplinkScheme, Permissions, PreimageHost, RuntimeConfig,
+    RuntimeConfigValidationError, SessionStore, SessionUiInfo, Storage, ThemeHost,
+    UserConfirmation,
+};
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+
+use crate::TrUApiCore;
+use crate::frame::ProtocolMessage;
+use crate::subscription::Spawner;
+use crate::transport::Transport;
+
+/// Bundle of JS-side callbacks the bridge invokes. Names map to camelCase
+/// keys on the JS object passed to the constructor.
+struct JsBridge {
+    navigate_to: Function,
+    push_notification: Function,
+    cancel_notification: Option<Function>,
+    device_permission: Function,
+    remote_permission: Function,
+    feature_supported: Function,
+    local_storage_read: Function,
+    local_storage_write: Function,
+    local_storage_clear: Function,
+    confirm_sign_payload: Option<Function>,
+    confirm_sign_raw: Option<Function>,
+    confirm_create_transaction: Option<Function>,
+    confirm_account_alias: Option<Function>,
+    confirm_resource_allocation: Option<Function>,
+    confirm_preimage_submit: Option<Function>,
+    submit_preimage: Option<Function>,
+    lookup_preimage: Option<Function>,
+    subscribe_theme: Option<Function>,
+    auth_state_changed: Option<Function>,
+    read_session: Option<Function>,
+    write_session: Option<Function>,
+    clear_session: Option<Function>,
+    subscribe_session_store: Option<Function>,
+    /// Optional. Hosts that own JSON-RPC connections (e.g. dotli with its
+    /// "smoldot vs RPC node" toggle) provide this; otherwise chain calls
+    /// fail with an "unavailable" reason.
+    chain_connect: Option<Function>,
+    emit_frame: Function,
+    dispose: Function,
+}
+
+impl JsBridge {
+    fn from_js(callbacks: &JsValue) -> Result<Self, JsValue> {
+        Ok(Self {
+            navigate_to: get_function(callbacks, "navigateTo")?,
+            push_notification: get_function(callbacks, "pushNotification")?,
+            cancel_notification: get_optional_function(callbacks, "cancelNotification")?,
+            device_permission: get_function(callbacks, "devicePermission")?,
+            remote_permission: get_function(callbacks, "remotePermission")?,
+            feature_supported: get_function(callbacks, "featureSupported")?,
+            local_storage_read: get_function(callbacks, "localStorageRead")?,
+            local_storage_write: get_function(callbacks, "localStorageWrite")?,
+            local_storage_clear: get_function(callbacks, "localStorageClear")?,
+            confirm_sign_payload: get_optional_function(callbacks, "confirmSignPayload")?,
+            confirm_sign_raw: get_optional_function(callbacks, "confirmSignRaw")?,
+            confirm_create_transaction: get_optional_function(
+                callbacks,
+                "confirmCreateTransaction",
+            )?,
+            confirm_account_alias: get_optional_function(callbacks, "confirmAccountAlias")?,
+            confirm_resource_allocation: get_optional_function(
+                callbacks,
+                "confirmResourceAllocation",
+            )?,
+            confirm_preimage_submit: get_optional_function(callbacks, "confirmPreimageSubmit")?,
+            submit_preimage: get_optional_function(callbacks, "submitPreimage")?,
+            lookup_preimage: get_optional_function(callbacks, "preimageLookupSubscribe")?,
+            subscribe_theme: get_optional_function(callbacks, "themeSubscribe")?,
+            auth_state_changed: get_optional_function(callbacks, "authStateChanged")?,
+            read_session: get_optional_function(callbacks, "readSession")?,
+            write_session: get_optional_function(callbacks, "writeSession")?,
+            clear_session: get_optional_function(callbacks, "clearSession")?,
+            subscribe_session_store: get_optional_function(callbacks, "subscribeSessionStore")?,
+            chain_connect: get_optional_function(callbacks, "chainConnect")?,
+            emit_frame: get_function(callbacks, "emitFrame")?,
+            dispose: get_optional_function(callbacks, "dispose")?.unwrap_or_else(noop_function),
+        })
+    }
+}
+
+struct WasmCallbackTransport {
+    bridge: SendWrapper<Arc<JsBridge>>,
+    disposed: Arc<AtomicBool>,
+}
+
+impl Transport for WasmCallbackTransport {
+    fn send(&self, message: ProtocolMessage) {
+        if self.disposed.load(Ordering::Relaxed) {
+            return;
+        }
+        let frame = Uint8Array::from(message.encode().as_slice());
+        if let Err(err) = self.bridge.emit_frame.call1(&JsValue::NULL, &frame) {
+            web_sys::console::error_1(&err);
+        }
+    }
+
+    fn on_message(
+        &self,
+        _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+    ) -> Box<dyn FnOnce()> {
+        Box::new(|| {})
+    }
+}
+
+struct WasmPlatform {
+    bridge: SendWrapper<Arc<JsBridge>>,
+}
+
+impl WasmPlatform {
+    fn new(bridge: Arc<JsBridge>) -> Self {
+        Self {
+            bridge: SendWrapper::new(bridge),
+        }
+    }
+}
+
+impl Navigation for WasmPlatform {
+    async fn navigate_to(&self, url: String) -> Result<(), v01::HostNavigateToError> {
+        invoke_navigate_to(&self.bridge, &url)
+            .await
+            .map_err(|reason| v01::HostNavigateToError::Unknown { reason })
+    }
+}
+
+impl Notifications for WasmPlatform {
+    async fn push_notification(
+        &self,
+        notification: v01::HostPushNotificationRequest,
+    ) -> Result<v01::HostPushNotificationResponse, v01::GenericError> {
+        let id = invoke_u32(&self.bridge.push_notification, notification.encode())
+            .await
+            .map_err(generic)?;
+        Ok(v01::HostPushNotificationResponse { id })
+    }
+
+    async fn cancel_notification(&self, id: v01::NotificationId) -> Result<(), v01::GenericError> {
+        let Some(fn_) = self.bridge.cancel_notification.as_ref() else {
+            return Ok(());
+        };
+        invoke_u32_unit(fn_, id).await.map_err(generic)
+    }
+}
+
+impl Permissions for WasmPlatform {
+    async fn device_permission(
+        &self,
+        request: v01::HostDevicePermissionRequest,
+    ) -> Result<v01::HostDevicePermissionResponse, v01::GenericError> {
+        let granted = invoke_bool(&self.bridge.device_permission, request.encode())
+            .await
+            .map_err(generic)?;
+        Ok(v01::HostDevicePermissionResponse { granted })
+    }
+
+    async fn remote_permission(
+        &self,
+        request: v01::RemotePermissionRequest,
+    ) -> Result<v01::RemotePermissionResponse, v01::GenericError> {
+        let granted = invoke_bool(&self.bridge.remote_permission, request.encode())
+            .await
+            .map_err(generic)?;
+        Ok(v01::RemotePermissionResponse { granted })
+    }
+}
+
+impl Features for WasmPlatform {
+    async fn feature_supported(
+        &self,
+        request: HostFeatureSupportedRequest,
+    ) -> Result<HostFeatureSupportedResponse, v01::GenericError> {
+        let supported = invoke_bool(&self.bridge.feature_supported, request.encode())
+            .await
+            .map_err(generic)?;
+        Ok(HostFeatureSupportedResponse::V1(
+            v01::HostFeatureSupportedResponse { supported },
+        ))
+    }
+}
+
+impl Storage for WasmPlatform {
+    async fn read(&self, key: String) -> Result<Option<Vec<u8>>, v01::HostLocalStorageReadError> {
+        invoke_local_storage_read(&self.bridge, &key)
+            .await
+            .map_err(|reason| v01::HostLocalStorageReadError::Unknown { reason })
+    }
+
+    async fn write(
+        &self,
+        key: String,
+        value: Vec<u8>,
+    ) -> Result<(), v01::HostLocalStorageReadError> {
+        invoke_local_storage_write(&self.bridge, &key, &value)
+            .await
+            .map_err(|reason| v01::HostLocalStorageReadError::Unknown { reason })
+    }
+
+    async fn clear(&self, key: String) -> Result<(), v01::HostLocalStorageReadError> {
+        invoke_local_storage_clear(&self.bridge, &key)
+            .await
+            .map_err(|reason| v01::HostLocalStorageReadError::Unknown { reason })
+    }
+}
+
+impl ChainProvider for WasmPlatform {
+    async fn connect(
+        &self,
+        genesis_hash: Vec<u8>,
+    ) -> Result<Box<dyn JsonRpcConnection>, v01::GenericError> {
+        let chain_connect = match self.bridge.chain_connect.clone() {
+            Some(f) => f,
+            None => {
+                return Err(generic(
+                    "chainConnect callback not provided by host".to_string(),
+                ));
+            }
+        };
+        let chain_connect = SendWrapper::new(chain_connect);
+        SendWrapper::new(async move {
+            let (response_tx, response_rx) = mpsc::unbounded::<String>();
+            let on_response = Closure::wrap(Box::new(move |json: JsValue| {
+                // The host must hand back JSON-RPC frames as strings. Drop (and
+                // log) non-string values rather than forwarding an empty frame
+                // that would desync request/response correlation.
+                match json.as_string() {
+                    Some(s) => {
+                        let _ = response_tx.unbounded_send(s);
+                    }
+                    None => web_sys::console::error_1(&JsValue::from_str(
+                        "chainConnect onResponse expected a JSON string; dropping non-string value",
+                    )),
+                }
+            }) as Box<dyn FnMut(JsValue)>);
+
+            let genesis_arg = JsValue::from_str(&format!("0x{}", hex::encode(&genesis_hash)));
+            let returned = chain_connect
+                .call2(
+                    &JsValue::NULL,
+                    &genesis_arg,
+                    on_response.as_ref().unchecked_ref(),
+                )
+                .map_err(|err| generic(js_to_string(err)))?;
+            let resolved = await_optional_promise(returned).await.map_err(generic)?;
+            if resolved.is_null() || resolved.is_undefined() {
+                return Err(generic("chainConnect returned no connection".into()));
+            }
+            let send_fn = Reflect::get(&resolved, &JsValue::from_str("send"))
+                .map_err(|_| generic("chainConnect must return { send, close }".into()))?
+                .dyn_into::<Function>()
+                .map_err(|_| generic("chainConnect.send must be a function".into()))?;
+            let close_fn = Reflect::get(&resolved, &JsValue::from_str("close"))
+                .map_err(|_| generic("chainConnect.close must be a function".into()))?
+                .dyn_into::<Function>()
+                .map_err(|_| generic("chainConnect.close must be a function".into()))?;
+
+            Ok(Box::new(JsCallbackJsonRpcConnection {
+                send_fn: SendWrapper::new(send_fn),
+                close_fn: SendWrapper::new(close_fn),
+                _on_response: SendWrapper::new(on_response),
+                response_rx: std::sync::Mutex::new(Some(response_rx)),
+            }) as Box<dyn JsonRpcConnection>)
+        })
+        .await
+    }
+}
+
+impl AuthPresenter for WasmPlatform {
+    fn auth_state_changed(&self, state: AuthState) {
+        let Some(fn_) = self.bridge.auth_state_changed.as_ref() else {
+            return;
+        };
+        if let Err(err) = fn_.call1(&JsValue::NULL, &auth_state_to_js(&state)) {
+            web_sys::console::error_1(&err);
+        }
+    }
+}
+
+impl SessionStore for WasmPlatform {
+    async fn read_session(&self) -> Result<Option<Vec<u8>>, v01::GenericError> {
+        let Some(fn_) = self.bridge.read_session.as_ref() else {
+            return Ok(None);
+        };
+        invoke_optional_bytes(fn_).await.map_err(generic)
+    }
+
+    async fn write_session(&self, value: Vec<u8>) -> Result<(), v01::GenericError> {
+        let Some(fn_) = self.bridge.write_session.as_ref() else {
+            return Ok(());
+        };
+        invoke_bytes_unit(fn_, value).await.map_err(generic)
+    }
+
+    async fn clear_session(&self) -> Result<(), v01::GenericError> {
+        let Some(fn_) = self.bridge.clear_session.as_ref() else {
+            return Ok(());
+        };
+        invoke_no_args_unit(fn_).await.map_err(generic)
+    }
+
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), v01::GenericError>> {
+        let Some(fn_) = self.bridge.subscribe_session_store.as_ref() else {
+            return stream::once(async { Ok(()) }).boxed();
+        };
+        invoke_js_subscription(fn_, None, parse_session_store_tick).boxed()
+    }
+}
+
+impl UserConfirmation for WasmPlatform {
+    async fn confirm_sign_payload(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        let Some(fn_) = self.bridge.confirm_sign_payload.as_ref() else {
+            return Ok(false);
+        };
+        invoke_bool(fn_, review).await.map_err(generic)
+    }
+
+    async fn confirm_sign_raw(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        let Some(fn_) = self.bridge.confirm_sign_raw.as_ref() else {
+            return Ok(false);
+        };
+        invoke_bool(fn_, review).await.map_err(generic)
+    }
+
+    async fn confirm_create_transaction(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        let Some(fn_) = self.bridge.confirm_create_transaction.as_ref() else {
+            return Ok(false);
+        };
+        invoke_bool(fn_, review).await.map_err(generic)
+    }
+
+    async fn confirm_account_alias(&self, review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        let Some(fn_) = self.bridge.confirm_account_alias.as_ref() else {
+            return Ok(false);
+        };
+        invoke_bool(fn_, review).await.map_err(generic)
+    }
+
+    async fn confirm_resource_allocation(
+        &self,
+        review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        let Some(fn_) = self.bridge.confirm_resource_allocation.as_ref() else {
+            return Ok(false);
+        };
+        invoke_bool(fn_, review).await.map_err(generic)
+    }
+}
+
+impl ThemeHost for WasmPlatform {
+    fn subscribe_theme(&self) -> BoxStream<'static, Result<v01::ThemeVariant, v01::GenericError>> {
+        let Some(fn_) = self.bridge.subscribe_theme.as_ref() else {
+            return stream::once(async { Ok(v01::ThemeVariant::Dark) }).boxed();
+        };
+        invoke_js_subscription(fn_, None, parse_theme_item).boxed()
+    }
+}
+
+impl PreimageHost for WasmPlatform {
+    async fn confirm_preimage_submit(&self, size: u64) -> Result<(), v01::PreimageSubmitError> {
+        let Some(fn_) = self.bridge.confirm_preimage_submit.as_ref() else {
+            return Err(v01::PreimageSubmitError::Unknown {
+                reason: "confirmPreimageSubmit callback not provided by host".to_string(),
+            });
+        };
+        invoke_u64_unit(fn_, size)
+            .await
+            .map_err(|reason| v01::PreimageSubmitError::Unknown { reason })
+    }
+
+    async fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, v01::PreimageSubmitError> {
+        let Some(fn_) = self.bridge.submit_preimage.as_ref() else {
+            return Err(v01::PreimageSubmitError::Unknown {
+                reason: "submitPreimage callback not provided by host".to_string(),
+            });
+        };
+        invoke_bytes_return(fn_, value)
+            .await
+            .map_err(|reason| v01::PreimageSubmitError::Unknown { reason })
+    }
+
+    fn lookup_preimage(
+        &self,
+        key: Vec<u8>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, v01::GenericError>> {
+        let Some(fn_) = self.bridge.lookup_preimage.as_ref() else {
+            return stream::once(async { Ok(None) }).boxed();
+        };
+        invoke_js_subscription(fn_, Some(key), parse_preimage_lookup_item).boxed()
+    }
+}
+
+// Account, signing, and statement-store flows live in the Rust
+// core itself. Their `truapi::api::*` trait defaults return `Unsupported`
+// until those in-core implementations land. The JS bridge only carries
+// callbacks for the platform capabilities the core cannot satisfy alone.
+
+struct JsSubscriptionStream<T> {
+    rx: mpsc::UnboundedReceiver<T>,
+    _send_item: SendWrapper<Closure<dyn FnMut(JsValue)>>,
+    dispose: Option<SendWrapper<Function>>,
+}
+
+impl<T> Stream for JsSubscriptionStream<T> {
+    type Item = T;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Pin::new(&mut self.rx).poll_next(cx)
+    }
+}
+
+impl<T> Drop for JsSubscriptionStream<T> {
+    fn drop(&mut self) {
+        if let Some(dispose) = self.dispose.take() {
+            let _ = dispose.call0(&JsValue::NULL);
+        }
+    }
+}
+
+fn invoke_js_subscription<T>(
+    fn_: &Function,
+    payload: Option<Vec<u8>>,
+    parse_item: fn(JsValue) -> Result<T, String>,
+) -> BoxStream<'static, Result<T, v01::GenericError>>
+where
+    T: Send + 'static,
+{
+    let (tx, rx) = mpsc::unbounded::<Result<T, v01::GenericError>>();
+    let send_item = Closure::wrap(Box::new(move |value: JsValue| {
+        let item = parse_item(value).map_err(generic);
+        let _ = tx.unbounded_send(item);
+    }) as Box<dyn FnMut(JsValue)>);
+
+    let call_result = match payload {
+        Some(payload) => {
+            let arg = Uint8Array::from(payload.as_slice());
+            fn_.call2(&JsValue::NULL, &arg, send_item.as_ref().unchecked_ref())
+        }
+        None => fn_.call1(&JsValue::NULL, send_item.as_ref().unchecked_ref()),
+    };
+
+    let dispose = match call_result {
+        Ok(value) if value.is_null() || value.is_undefined() => None,
+        Ok(value) => match value.dyn_into::<Function>() {
+            Ok(dispose) => Some(SendWrapper::new(dispose)),
+            Err(_) => {
+                return stream::once(async {
+                    Err(generic(
+                        "subscription callback must return a dispose function, null, or undefined"
+                            .to_string(),
+                    ))
+                })
+                .boxed();
+            }
+        },
+        Err(err) => return stream::once(async { Err(generic(js_to_string(err))) }).boxed(),
+    };
+
+    Box::pin(JsSubscriptionStream {
+        rx,
+        _send_item: SendWrapper::new(send_item),
+        dispose,
+    })
+}
+
+struct JsCallbackJsonRpcConnection {
+    send_fn: SendWrapper<Function>,
+    close_fn: SendWrapper<Function>,
+    /// Closure must outlive the connection so JS keeps a live ref to the
+    /// response sink. Dropped together with the rest of the struct.
+    _on_response: SendWrapper<Closure<dyn FnMut(JsValue)>>,
+    response_rx: std::sync::Mutex<Option<mpsc::UnboundedReceiver<String>>>,
+}
+
+impl JsonRpcConnection for JsCallbackJsonRpcConnection {
+    fn send(&self, request: String) {
+        let arg = JsValue::from_str(&request);
+        if let Err(err) = self.send_fn.call1(&JsValue::NULL, &arg) {
+            web_sys::console::error_1(&err);
+        }
+    }
+
+    /// Single-take: the response receiver is handed out exactly once. A second
+    /// call yields an empty stream (and logs), since the channel has one
+    /// consumer.
+    fn responses(&self) -> BoxStream<'static, String> {
+        let mut guard = self.response_rx.lock().unwrap();
+        match guard.take() {
+            Some(rx) => rx.boxed(),
+            None => {
+                web_sys::console::error_1(&JsValue::from_str(
+                    "JsCallbackJsonRpcConnection::responses() called more than once",
+                ));
+                futures::stream::empty().boxed()
+            }
+        }
+    }
+}
+
+impl Drop for JsCallbackJsonRpcConnection {
+    fn drop(&mut self) {
+        let _ = self.close_fn.call0(&JsValue::NULL);
+    }
+}
+
+fn generic(reason: String) -> v01::GenericError {
+    v01::GenericError { reason }
+}
+
+/// Await the JS callback's return value if it's a Promise; pass other
+/// values through unchanged. Every host callback resolves through this so
+/// the JS side is free to be sync or async.
+async fn await_optional_promise(returned: JsValue) -> Result<JsValue, String> {
+    if returned.is_instance_of::<js_sys::Promise>() {
+        let promise = returned.unchecked_into::<js_sys::Promise>();
+        wasm_bindgen_futures::JsFuture::from(promise)
+            .await
+            .map_err(js_to_string)
+    } else {
+        Ok(returned)
+    }
+}
+
+fn invoke_navigate_to(
+    bridge: &JsBridge,
+    url: &str,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = bridge.navigate_to.clone();
+    let url = url.to_string();
+    SendWrapper::new(async move {
+        let arg = JsValue::from_str(&url);
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn invoke_bool(
+    fn_: &Function,
+    payload: Vec<u8>,
+) -> impl std::future::Future<Output = Result<bool, String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let arg = Uint8Array::from(payload.as_slice());
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        let resolved = await_optional_promise(returned).await?;
+        // A non-boolean resolved value is a host contract violation; surface it
+        // rather than silently masking it as `false` (which would read as a
+        // denial / unsupported and hide the host bug).
+        resolved
+            .as_bool()
+            .ok_or_else(|| "callback must resolve to a boolean".to_string())
+    })
+}
+
+fn invoke_u32(
+    fn_: &Function,
+    payload: Vec<u8>,
+) -> impl std::future::Future<Output = Result<u32, String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let arg = Uint8Array::from(payload.as_slice());
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        let resolved = await_optional_promise(returned).await?;
+        let n = resolved
+            .as_f64()
+            .ok_or_else(|| "callback must resolve to a u32 notification id".to_string())?;
+        if n.is_finite() && n >= 0.0 && n <= f64::from(u32::MAX) && n.fract() == 0.0 {
+            Ok(n as u32)
+        } else {
+            Err("callback must resolve to a u32 notification id".to_string())
+        }
+    })
+}
+
+fn invoke_u32_unit(
+    fn_: &Function,
+    value: u32,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let arg = JsValue::from_f64(f64::from(value));
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn invoke_u64_unit(
+    fn_: &Function,
+    value: u64,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        const MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;
+        if value > MAX_SAFE_INTEGER {
+            return Err("callback numeric argument exceeds JS safe integer range".to_string());
+        }
+        let arg = JsValue::from_f64(value as f64);
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn invoke_bytes_return(
+    fn_: &Function,
+    value: Vec<u8>,
+) -> impl std::future::Future<Output = Result<Vec<u8>, String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let arg = Uint8Array::from(value.as_slice());
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        let resolved = await_optional_promise(returned).await?;
+        resolved
+            .dyn_into::<Uint8Array>()
+            .map(|array| array.to_vec())
+            .map_err(|_| "callback must resolve to Uint8Array".to_string())
+    })
+}
+
+fn invoke_bytes_unit(
+    fn_: &Function,
+    value: Vec<u8>,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let arg = Uint8Array::from(value.as_slice());
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn parse_preimage_lookup_item(value: JsValue) -> Result<Option<Vec<u8>>, String> {
+    if value.is_null() || value.is_undefined() {
+        return Ok(None);
+    }
+    value
+        .dyn_into::<Uint8Array>()
+        .map(|array| Some(array.to_vec()))
+        .map_err(|_| "preimage lookup item must be Uint8Array, null, or undefined".to_string())
+}
+
+fn parse_theme_item(value: JsValue) -> Result<v01::ThemeVariant, String> {
+    if let Some(theme) = value.as_string() {
+        return match theme.as_str() {
+            "Light" | "light" => Ok(v01::ThemeVariant::Light),
+            "Dark" | "dark" => Ok(v01::ThemeVariant::Dark),
+            _ => Err("theme item string must be Light or Dark".to_string()),
+        };
+    }
+    if let Some(theme) = value.as_f64() {
+        return match theme as u8 {
+            0 if theme == 0.0 => Ok(v01::ThemeVariant::Light),
+            1 if theme == 1.0 => Ok(v01::ThemeVariant::Dark),
+            _ => Err("theme item number must be 0 or 1".to_string()),
+        };
+    }
+    value
+        .dyn_into::<Uint8Array>()
+        .map_err(|_| "theme item must be Light, Dark, 0, 1, or encoded ThemeVariant".to_string())
+        .and_then(|array| {
+            v01::ThemeVariant::decode(&mut array.to_vec().as_slice())
+                .map_err(|_| "encoded ThemeVariant item did not decode".to_string())
+        })
+}
+
+fn parse_session_store_tick(_value: JsValue) -> Result<(), String> {
+    Ok(())
+}
+
+/// Plain JS object mirroring the generated `AuthState` TS tagged union:
+/// `{ tag, value }` with `value` omitted for unit variants.
+fn auth_state_to_js(state: &AuthState) -> JsValue {
+    let object = js_sys::Object::new();
+    let set = |key: &str, value: &JsValue| {
+        let _ = Reflect::set(&object, &JsValue::from_str(key), value);
+    };
+    match state {
+        AuthState::Disconnected => {
+            set("tag", &JsValue::from_str("Disconnected"));
+        }
+        AuthState::Pairing { deeplink } => {
+            set("tag", &JsValue::from_str("Pairing"));
+            let value = js_sys::Object::new();
+            let _ = Reflect::set(
+                &value,
+                &JsValue::from_str("deeplink"),
+                &JsValue::from_str(deeplink),
+            );
+            set("value", &value.into());
+        }
+        AuthState::Connected(info) => {
+            set("tag", &JsValue::from_str("Connected"));
+            set("value", &session_ui_info_to_js(info));
+        }
+        AuthState::LoginFailed { reason } => {
+            set("tag", &JsValue::from_str("LoginFailed"));
+            let value = js_sys::Object::new();
+            let _ = Reflect::set(
+                &value,
+                &JsValue::from_str("reason"),
+                &JsValue::from_str(reason),
+            );
+            set("value", &value.into());
+        }
+    }
+    object.into()
+}
+
+/// Plain JS object mirroring the generated `SessionUiInfo` TS interface:
+/// `connected` is always present, the optional fields only when `Some`.
+fn session_ui_info_to_js(info: &SessionUiInfo) -> JsValue {
+    let object = js_sys::Object::new();
+    let set = |key: &str, value: &JsValue| {
+        let _ = Reflect::set(&object, &JsValue::from_str(key), value);
+    };
+    set("connected", &JsValue::from_bool(info.connected));
+    if let Some(public_key) = &info.public_key {
+        set("publicKey", &Uint8Array::from(public_key.as_slice()));
+    }
+    if let Some(identity_account_id) = &info.identity_account_id {
+        set(
+            "identityAccountId",
+            &Uint8Array::from(identity_account_id.as_slice()),
+        );
+    }
+    if let Some(lite_username) = &info.lite_username {
+        set("liteUsername", &JsValue::from_str(lite_username));
+    }
+    if let Some(full_username) = &info.full_username {
+        set("fullUsername", &JsValue::from_str(full_username));
+    }
+    object.into()
+}
+
+fn invoke_no_args_unit(
+    fn_: &Function,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let returned = fn_.call0(&JsValue::NULL).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn invoke_optional_bytes(
+    fn_: &Function,
+) -> impl std::future::Future<Output = Result<Option<Vec<u8>>, String>> + Send {
+    let fn_ = fn_.clone();
+    SendWrapper::new(async move {
+        let returned = fn_.call0(&JsValue::NULL).map_err(js_to_string)?;
+        let resolved = await_optional_promise(returned).await?;
+        if resolved.is_null() || resolved.is_undefined() {
+            return Ok(None);
+        }
+        let array = resolved
+            .dyn_into::<Uint8Array>()
+            .map_err(|_| "callback must resolve to Uint8Array, null or undefined".to_string())?;
+        Ok(Some(array.to_vec()))
+    })
+}
+
+fn invoke_local_storage_read(
+    bridge: &JsBridge,
+    key: &str,
+) -> impl std::future::Future<Output = Result<Option<Vec<u8>>, String>> + Send {
+    let fn_ = bridge.local_storage_read.clone();
+    let key = key.to_string();
+    SendWrapper::new(async move {
+        let arg = JsValue::from_str(&key);
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        let resolved = await_optional_promise(returned).await?;
+        if resolved.is_null() || resolved.is_undefined() {
+            return Ok(None);
+        }
+        let array = resolved.dyn_into::<Uint8Array>().map_err(|_| {
+            "localStorageRead must resolve to Uint8Array, null or undefined".to_string()
+        })?;
+        Ok(Some(array.to_vec()))
+    })
+}
+
+fn invoke_local_storage_write(
+    bridge: &JsBridge,
+    key: &str,
+    value: &[u8],
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = bridge.local_storage_write.clone();
+    let key = key.to_string();
+    let value = value.to_vec();
+    SendWrapper::new(async move {
+        let key_arg = JsValue::from_str(&key);
+        let value_arg = Uint8Array::from(value.as_slice());
+        let returned = fn_
+            .call2(&JsValue::NULL, &key_arg, &value_arg)
+            .map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn invoke_local_storage_clear(
+    bridge: &JsBridge,
+    key: &str,
+) -> impl std::future::Future<Output = Result<(), String>> + Send {
+    let fn_ = bridge.local_storage_clear.clone();
+    let key = key.to_string();
+    SendWrapper::new(async move {
+        let arg = JsValue::from_str(&key);
+        let returned = fn_.call1(&JsValue::NULL, &arg).map_err(js_to_string)?;
+        await_optional_promise(returned).await.map(|_| ())
+    })
+}
+
+fn js_to_string(value: JsValue) -> String {
+    value
+        .as_string()
+        .or_else(|| {
+            value
+                .dyn_ref::<js_sys::Error>()
+                .map(|err| err.message().into())
+        })
+        .unwrap_or_else(|| format!("{value:?}"))
+}
+
+fn get_function(callbacks: &JsValue, name: &str) -> Result<Function, JsValue> {
+    let value = Reflect::get(callbacks, &JsValue::from_str(name))?;
+    value
+        .dyn_into::<Function>()
+        .map_err(|_| JsValue::from_str(&format!("callbacks.{name} must be a function")))
+}
+
+fn get_optional_function(callbacks: &JsValue, name: &str) -> Result<Option<Function>, JsValue> {
+    let value = Reflect::get(callbacks, &JsValue::from_str(name))?;
+    if value.is_null() || value.is_undefined() {
+        return Ok(None);
+    }
+    value
+        .dyn_into::<Function>()
+        .map(Some)
+        .map_err(|_| JsValue::from_str(&format!("callbacks.{name} must be a function")))
+}
+
+fn noop_function() -> Function {
+    Function::new_no_args("")
+}
+
+fn runtime_config_from_js(value: &JsValue) -> Result<RuntimeConfig, JsValue> {
+    if value.is_null() || value.is_undefined() {
+        return Err(JsValue::from_str("runtimeConfig is required"));
+    }
+
+    let config = RuntimeConfig {
+        product_label: get_required_string(value, "productLabel")?,
+        product_id: get_required_string(value, "productId")?,
+        site_id: get_required_string(value, "siteId")?,
+        host_name: get_required_string(value, "hostName")?,
+        host_icon: get_optional_string(value, "hostIcon")?,
+        host_version: get_optional_string(value, "hostVersion")?,
+        platform_type: get_optional_string(value, "platformType")?,
+        platform_version: get_optional_string(value, "platformVersion")?,
+        people_chain_genesis_hash: get_required_bytes32(value, "peopleChainGenesisHash")?,
+        pairing_deeplink_scheme: {
+            let scheme = get_required_string(value, "pairingDeeplinkScheme")?;
+            match scheme.as_str() {
+                "polkadotapp" | "polkadotApp" | "PolkadotApp" => PairingDeeplinkScheme::PolkadotApp,
+                "polkadotappdev" | "polkadotAppDev" | "PolkadotAppDev" => {
+                    PairingDeeplinkScheme::PolkadotAppDev
+                }
+                other => {
+                    return Err(JsValue::from_str(&format!(
+                        "runtimeConfig.pairingDeeplinkScheme has unsupported value {other:?}"
+                    )));
+                }
+            }
+        },
+    };
+    config.validate().map_err(runtime_config_validation_to_js)?;
+    Ok(config)
+}
+
+fn runtime_config_validation_to_js(err: RuntimeConfigValidationError) -> JsValue {
+    match err {
+        RuntimeConfigValidationError::EmptyField { field } => JsValue::from_str(&format!(
+            "runtimeConfig.{} must not be empty",
+            runtime_config_field_to_js(field)
+        )),
+        RuntimeConfigValidationError::InvalidHostIcon { reason } => JsValue::from_str(&format!(
+            "runtimeConfig.hostIcon must be an absolute HTTPS URL: {reason}"
+        )),
+        RuntimeConfigValidationError::InsecureHostIcon { scheme } => JsValue::from_str(&format!(
+            "runtimeConfig.hostIcon must use https scheme, got {scheme:?}"
+        )),
+    }
+}
+
+fn runtime_config_field_to_js(field: &str) -> &str {
+    match field {
+        "product_label" => "productLabel",
+        "product_id" => "productId",
+        "site_id" => "siteId",
+        "host_name" => "hostName",
+        "people_chain_genesis_hash" => "peopleChainGenesisHash",
+        other => other,
+    }
+}
+
+fn get_optional_string(value: &JsValue, name: &str) -> Result<Option<String>, JsValue> {
+    let property = Reflect::get(value, &JsValue::from_str(name))?;
+    if property.is_null() || property.is_undefined() {
+        return Ok(None);
+    }
+    property
+        .as_string()
+        .map(Some)
+        .ok_or_else(|| JsValue::from_str(&format!("runtimeConfig.{name} must be a string")))
+}
+
+fn get_required_string(value: &JsValue, name: &str) -> Result<String, JsValue> {
+    get_optional_string(value, name)?
+        .ok_or_else(|| JsValue::from_str(&format!("runtimeConfig.{name} is required")))
+}
+
+fn get_optional_bytes32(value: &JsValue, name: &str) -> Result<Option<[u8; 32]>, JsValue> {
+    let property = Reflect::get(value, &JsValue::from_str(name))?;
+    if property.is_null() || property.is_undefined() {
+        return Ok(None);
+    }
+    if let Some(hex) = property.as_string() {
+        return parse_hex32(&hex)
+            .map(Some)
+            .map_err(|reason| JsValue::from_str(&format!("runtimeConfig.{name}: {reason}")));
+    }
+    let array = property.dyn_into::<Uint8Array>().map_err(|_| {
+        JsValue::from_str(&format!("runtimeConfig.{name} must be hex or Uint8Array"))
+    })?;
+    let bytes = array.to_vec();
+    bytes.try_into().map(Some).map_err(|bytes: Vec<u8>| {
+        JsValue::from_str(&format!(
+            "runtimeConfig.{name} must be exactly 32 bytes, got {}",
+            bytes.len()
+        ))
+    })
+}
+
+fn get_required_bytes32(value: &JsValue, name: &str) -> Result<[u8; 32], JsValue> {
+    get_optional_bytes32(value, name)?
+        .ok_or_else(|| JsValue::from_str(&format!("runtimeConfig.{name} is required")))
+}
+
+fn parse_hex32(value: &str) -> Result<[u8; 32], String> {
+    let raw = value.strip_prefix("0x").unwrap_or(value);
+    if raw.len() != 64 {
+        return Err(format!(
+            "expected 32-byte hex string, got {} hex chars",
+            raw.len()
+        ));
+    }
+    let bytes = hex::decode(raw).map_err(|_| "invalid hex".to_string())?;
+    bytes
+        .try_into()
+        .map_err(|bytes: Vec<u8>| format!("expected 32 bytes, got {}", bytes.len()))
+}
+
+struct WasmCoreInner {
+    core: TrUApiCore,
+    transport: Arc<WasmCallbackTransport>,
+    dispose_fn: SendWrapper<Function>,
+    disposed: Cell<bool>,
+    disposing: Cell<bool>,
+    /// Abort handles for in-flight `receive_from_product` dispatches, keyed
+    /// by a local counter. `dispose` aborts them all so long-pending handlers
+    /// unwind instead of outliving the core.
+    in_flight: RefCell<HashMap<u64, AbortHandle>>,
+    next_dispatch_id: Cell<u64>,
+}
+
+/// Set the live log level (`off`/`error`/`warn`/`info`/`debug`/`trace`).
+/// Hosts read their `truapi:logLevel` flag (web: localStorage) and call this
+/// during boot, or again at any time to re-tune verbosity.
+#[wasm_bindgen(js_name = setLogLevel)]
+pub fn set_log_level(level: &str) {
+    crate::logging::set_level_from_str(level);
+}
+
+/// JS-callable handle to the TrUAPI core. Constructed once per shell boot.
+#[wasm_bindgen]
+pub struct WasmTrUApiCore {
+    inner: Rc<WasmCoreInner>,
+}
+
+#[wasm_bindgen]
+impl WasmTrUApiCore {
+    /// Build the core from a JS callbacks object. The object must define
+    /// every host capability the [`truapi_platform::Platform`] trait set
+    /// requires (camelCase property names; see the source for the full
+    /// list).
+    #[wasm_bindgen(constructor)]
+    pub fn new(callbacks: JsValue, runtime_config: JsValue) -> Result<WasmTrUApiCore, JsValue> {
+        // Surface Rust panics to the browser console. A panic mid-dispatch
+        // aborts the call as a wasm trap; the host should treat a thrown error
+        // from `receiveFromProduct` as a fatal-instance signal and rebuild the
+        // core rather than continue using it.
+        console_error_panic_hook::set_once();
+        crate::logging::init();
+        let bridge = Arc::new(JsBridge::from_js(&callbacks)?);
+        let disposed = Arc::new(AtomicBool::new(false));
+        let transport = Arc::new(WasmCallbackTransport {
+            bridge: SendWrapper::new(bridge.clone()),
+            disposed: disposed.clone(),
+        });
+        let dispose_fn = SendWrapper::new(bridge.dispose.clone());
+        let platform = Arc::new(WasmPlatform::new(bridge));
+        let spawner: Spawner = Arc::new(|fut| {
+            wasm_bindgen_futures::spawn_local(fut);
+        });
+        let runtime_config = runtime_config_from_js(&runtime_config)?;
+        let core = TrUApiCore::from_platform_with_config(platform, runtime_config, spawner);
+        Ok(Self {
+            inner: Rc::new(WasmCoreInner {
+                core,
+                transport,
+                dispose_fn,
+                disposed: Cell::new(false),
+                disposing: Cell::new(false),
+                in_flight: RefCell::new(HashMap::new()),
+                next_dispatch_id: Cell::new(0),
+            }),
+        })
+    }
+
+    /// Push a SCALE-encoded protocol frame into the dispatcher. Responses
+    /// (and subscription items) flow back through the `emitFrame`
+    /// callback.
+    #[wasm_bindgen(js_name = receiveFromProduct)]
+    pub async fn receive_from_product(&self, frame: Vec<u8>) -> Result<(), JsValue> {
+        if self.inner.disposed.get() {
+            return Ok(());
+        }
+
+        let message = ProtocolMessage::decode(&mut &*frame)
+            .map_err(|err| JsValue::from_str(&format!("invalid frame: {err}")))?;
+
+        let transport: Arc<dyn Transport> = self.inner.transport.clone();
+        // Register the dispatch so `dispose` can abort it; a long-pending
+        // handler then unwinds instead of outliving the core.
+        let dispatch_id = self.inner.next_dispatch_id.get();
+        self.inner.next_dispatch_id.set(dispatch_id.wrapping_add(1));
+        let (abort_handle, abort_registration) = AbortHandle::new_pair();
+        self.inner
+            .in_flight
+            .borrow_mut()
+            .insert(dispatch_id, abort_handle);
+        let _ = Abortable::new(
+            self.inner.core.dispatch(message, transport),
+            abort_registration,
+        )
+        .await;
+        self.inner.in_flight.borrow_mut().remove(&dispatch_id);
+        Ok(())
+    }
+
+    /// Tear down the bridge. Invokes the JS-side `dispose` callback so the
+    /// host can drop its end of the wiring.
+    pub fn dispose(&self) -> Result<(), JsValue> {
+        if self.inner.disposed.get() {
+            return Ok(());
+        }
+        if self.inner.disposing.replace(true) {
+            return Ok(());
+        }
+
+        self.inner.transport.disposed.store(true, Ordering::Relaxed);
+        for (_, handle) in self.inner.in_flight.borrow_mut().drain() {
+            handle.abort();
+        }
+
+        let result = self.inner.dispose_fn.call0(&JsValue::NULL).map(|_| ());
+
+        self.inner.disposed.set(true);
+        self.inner.disposing.set(false);
+        result
+    }
+
+    /// Core-owned logout/disconnect. Best-effort notifies the SSO peer when
+    /// the session has channel material, then clears in-memory and persisted
+    /// session state.
+    #[wasm_bindgen(js_name = disconnect)]
+    pub async fn disconnect(&self) -> Result<(), JsValue> {
+        self.inner.core.disconnect_async().await;
+        Ok(())
+    }
+
+    /// Cancel any in-flight `request_login` pairing. The host receives a
+    /// `Disconnected` auth state immediately and the pending login resolves
+    /// to `Rejected`. A no-op when no login is in progress.
+    #[wasm_bindgen(js_name = cancelLogin)]
+    pub fn cancel_login(&self) {
+        self.inner.core.cancel_login();
+    }
+}
diff --git a/rust/crates/truapi-server/src/ws_bridge.rs b/rust/crates/truapi-server/src/ws_bridge.rs
new file mode 100644
index 00000000..dfc271d3
--- /dev/null
+++ b/rust/crates/truapi-server/src/ws_bridge.rs
@@ -0,0 +1,725 @@
+//! Localhost WebSocket bridge. Binds to `127.0.0.1:<port>`, gates each
+//! connection on a session token, and relays SCALE-encoded
+//! [`ProtocolMessage`] frames into a [`TrUApiCore`].
+//!
+//! Feature-gated (`ws-bridge`) so wasm32 and no-tokio build paths stay lean.
+//!
+//! The bridge owns a `tokio` runtime spawned at [`WsBridge::start`] time and
+//! shuts down both the accept loop and the runtime when the handle is dropped
+//! or [`WsBridge::stop`] is called.
+//!
+//! Security model: the listener binds to `127.0.0.1` only, and every
+//! connection must present the per-session 256-bit token (`?t=<token>`,
+//! drawn from the OS CSPRNG) before the WebSocket upgrade completes. The token
+//! is the sole authentication gate and is compared in constant time. It is
+//! handed only to the host's embedded WebView, so the bridge does not also pin
+//! the `Origin` header (the WebView's origin is not known a priori). Inbound
+//! messages are size-capped, and the per-connection outbound queue and the
+//! total connection count are bounded to contain a misbehaving local peer.
+
+use std::io;
+use std::net::SocketAddr;
+use std::sync::{Arc, Mutex};
+use std::thread;
+
+use futures::{SinkExt, StreamExt};
+use parity_scale_codec::{Decode, Encode};
+use rand::RngCore;
+use tokio::net::TcpListener;
+use tokio::sync::{mpsc, oneshot};
+use tokio::task::LocalSet;
+use tokio_tungstenite::tungstenite::Message as WsMessage;
+use tokio_tungstenite::tungstenite::handshake::server::{ErrorResponse, Request, Response};
+use tokio_tungstenite::tungstenite::http::{Response as HttpResponse, StatusCode};
+use tokio_tungstenite::tungstenite::protocol::CloseFrame;
+use tokio_tungstenite::tungstenite::protocol::WebSocketConfig;
+use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
+
+use crate::{ProtocolMessage, TrUApiCore, Transport};
+
+/// Maximum simultaneous connections the bridge will service. The product uses
+/// a single connection; the cap bounds resource use from a buggy or hostile
+/// local peer opening many sockets.
+const MAX_WS_BRIDGE_CONNECTIONS: usize = 32;
+
+/// Bound on the per-connection outbound frame queue. A peer that stops reading
+/// cannot make the core buffer responses without limit; once the queue fills
+/// the connection is treated as closed.
+const OUTBOUND_QUEUE_CAP: usize = 4096;
+
+/// Ceiling on a single inbound WebSocket message / frame. `ProtocolMessage`
+/// frames on this SCALE control channel are small; the cap prevents a
+/// memory-amplification DoS well below tungstenite's 64 MiB default.
+const MAX_WS_MESSAGE_BYTES: usize = 8 << 20;
+
+/// Per-session descriptor returned to the host: product uses `port + token`
+/// to build its WebSocket URL (e.g. `ws://127.0.0.1:<port>/?t=<token>`).
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct WsBridgeEndpoint {
+    /// Localhost port the bridge is listening on.
+    pub port: u16,
+    /// Session token; the connecting client must supply this as the
+    /// `?t=<token>` query parameter to be accepted.
+    pub token: String,
+}
+
+/// Failure modes returned from host-facing `start_ws_bridge` wrappers.
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+#[uniffi(flat_error)]
+pub enum WsBridgeStartError {
+    /// A bridge is already running for this host.
+    #[error("ws bridge already running")]
+    AlreadyRunning,
+    /// Anything else (bind failure, runtime spin-up failure, ...).
+    #[error("ws bridge start failed: {0}")]
+    Io(String),
+}
+
+impl From<io::Error> for WsBridgeStartError {
+    fn from(err: io::Error) -> Self {
+        if err.kind() == io::ErrorKind::AlreadyExists {
+            WsBridgeStartError::AlreadyRunning
+        } else {
+            WsBridgeStartError::Io(err.to_string())
+        }
+    }
+}
+
+/// Logger callback shape used by the bridge for lifecycle events. The
+/// Android and iOS wrappers adapt their per-platform callback interfaces to
+/// this platform-neutral shape.
+pub type BridgeLogger = Arc<dyn Fn(&str, &str) + Send + Sync>;
+
+/// Running bridge handle. Drop or call [`WsBridge::stop`] to shut down.
+///
+/// The bridge owns a dedicated OS thread that runs a `tokio` current-thread
+/// runtime + `LocalSet`. Using `spawn_local` is required because the
+/// dispatcher's per-method futures are `LocalBoxFuture` (the truapi trait
+/// uses `async fn`, whose auto-generated futures are not `Send`).
+pub struct WsBridge {
+    shutdown: Option<oneshot::Sender<()>>,
+    thread: Option<thread::JoinHandle<()>>,
+}
+
+impl WsBridge {
+    /// Bind a localhost listener and start the accept loop on a dedicated
+    /// OS thread. Returns the [`WsBridgeEndpoint`] descriptor the host
+    /// hands to the product alongside the bridge handle.
+    pub fn start(
+        bind_port: u16,
+        core: Arc<TrUApiCore>,
+        logger: BridgeLogger,
+    ) -> io::Result<(Self, WsBridgeEndpoint)> {
+        let mut token_bytes = [0u8; 32];
+        rand::thread_rng().fill_bytes(&mut token_bytes);
+        let token = hex::encode(token_bytes);
+
+        // Bind synchronously so we can surface bind errors back to the
+        // caller and discover the actual port the OS handed back. The
+        // listener is registered with tokio inside the worker thread
+        // because a `tokio::net::TcpListener` is bound to the runtime that
+        // created it.
+        let std_listener =
+            std::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], bind_port)))?;
+        std_listener.set_nonblocking(true)?;
+        let port = std_listener.local_addr()?.port();
+
+        let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel::<io::Result<()>>();
+        let accept_token = token.clone();
+        let accept_logger = logger.clone();
+        let worker_logger = logger.clone();
+        let thread = thread::Builder::new()
+            .name("truapi-ws-bridge".to_string())
+            .spawn(move || {
+                let rt = match tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                {
+                    Ok(rt) => rt,
+                    Err(err) => {
+                        let _ = ready_tx.send(Err(io::Error::other(err.to_string())));
+                        return;
+                    }
+                };
+                let local = LocalSet::new();
+                let listener_setup = rt.block_on(async { TcpListener::from_std(std_listener) });
+                let listener = match listener_setup {
+                    Ok(listener) => {
+                        let _ = ready_tx.send(Ok(()));
+                        listener
+                    }
+                    Err(err) => {
+                        let _ = ready_tx.send(Err(err));
+                        return;
+                    }
+                };
+                local.block_on(
+                    &rt,
+                    accept_loop(listener, core, accept_token, accept_logger, shutdown_rx),
+                );
+                worker_logger("truapi.ws_bridge.worker_exit", "worker thread exiting");
+            })?;
+
+        // Block until the worker thread reports the listener is registered
+        // with its runtime, so the caller knows the bridge is ready to
+        // accept connections by the time `start` returns.
+        match ready_rx.recv() {
+            Ok(Ok(())) => {}
+            Ok(Err(err)) => return Err(err),
+            Err(err) => return Err(io::Error::other(err.to_string())),
+        }
+
+        logger(
+            "truapi.ws_bridge.started",
+            &format!("port={port} token_len={}", token.len()),
+        );
+
+        Ok((
+            Self {
+                shutdown: Some(shutdown_tx),
+                thread: Some(thread),
+            },
+            WsBridgeEndpoint { port, token },
+        ))
+    }
+
+    /// Signal the accept loop to exit and join the worker thread.
+    pub fn stop(&mut self) {
+        if let Some(tx) = self.shutdown.take() {
+            let _ = tx.send(());
+        }
+        if let Some(handle) = self.thread.take() {
+            let _ = handle.join();
+        }
+    }
+}
+
+impl Drop for WsBridge {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+
+async fn accept_loop(
+    listener: TcpListener,
+    core: Arc<TrUApiCore>,
+    expected_token: String,
+    logger: BridgeLogger,
+    mut shutdown: oneshot::Receiver<()>,
+) {
+    let mut handles: Vec<tokio::task::JoinHandle<()>> = Vec::new();
+    loop {
+        tokio::select! {
+            _ = &mut shutdown => {
+                logger("truapi.ws_bridge.shutdown", "accept loop exiting");
+                for h in &handles {
+                    h.abort();
+                }
+                break;
+            }
+            accepted = listener.accept() => {
+                let (stream, peer) = match accepted {
+                    Ok(pair) => pair,
+                    Err(err) => {
+                        logger("truapi.ws_bridge.accept_error", &err.to_string());
+                        continue;
+                    }
+                };
+                handles.retain(|h| !h.is_finished());
+                if handles.len() >= MAX_WS_BRIDGE_CONNECTIONS {
+                    logger("truapi.ws_bridge.connection_limit", &peer.to_string());
+                    drop(stream);
+                    continue;
+                }
+                let core = core.clone();
+                let logger = logger.clone();
+                let expected = expected_token.clone();
+                handles.push(tokio::task::spawn_local(async move {
+                    handle_connection(stream, peer, core, expected, logger).await;
+                }));
+            }
+        }
+    }
+}
+
+// `clippy::result_large_err` fires on the handshake callback because
+// tokio-tungstenite's `ErrorResponse` type carries the full HTTP response
+// (~136 bytes). The closure signature is dictated by tokio-tungstenite's
+// API, so the lint can only be silenced at the call site.
+#[allow(clippy::result_large_err)]
+async fn handle_connection(
+    stream: tokio::net::TcpStream,
+    peer: SocketAddr,
+    core: Arc<TrUApiCore>,
+    expected_token: String,
+    logger: BridgeLogger,
+) {
+    let auth_logger = logger.clone();
+    let callback = |req: &Request, resp: Response| -> Result<Response, ErrorResponse> {
+        if path_token_matches(
+            req.uri().path_and_query().map(|p| p.as_str()),
+            &expected_token,
+        ) {
+            Ok(resp)
+        } else {
+            auth_logger("truapi.ws_bridge.reject_unauthorized", &peer.to_string());
+            let mut err: ErrorResponse = HttpResponse::new(Some("invalid token".to_string()));
+            *err.status_mut() = StatusCode::UNAUTHORIZED;
+            Err(err)
+        }
+    };
+
+    // Cap inbound message/frame size so a peer cannot force the runtime to
+    // buffer up to tungstenite's 64 MiB default on this small control channel.
+    let config = WebSocketConfig {
+        max_message_size: Some(MAX_WS_MESSAGE_BYTES),
+        max_frame_size: Some(MAX_WS_MESSAGE_BYTES),
+        ..Default::default()
+    };
+    let ws = match tokio_tungstenite::accept_hdr_async_with_config(stream, callback, Some(config))
+        .await
+    {
+        Ok(ws) => ws,
+        Err(err) => {
+            logger("truapi.ws_bridge.handshake_error", &err.to_string());
+            return;
+        }
+    };
+
+    logger("truapi.ws_bridge.connection_open", &peer.to_string());
+    let (mut sink, mut source) = ws.split();
+    let (out_tx, mut out_rx) = mpsc::channel::<Vec<u8>>(OUTBOUND_QUEUE_CAP);
+    let transport: Arc<dyn Transport> = Arc::new(WsTransport::new(out_tx));
+
+    let pump_logger = logger.clone();
+    let pump = tokio::task::spawn_local(async move {
+        while let Some(bytes) = out_rx.recv().await {
+            if let Err(err) = sink.send(WsMessage::Binary(bytes)).await {
+                pump_logger("truapi.ws_bridge.send_error", &err.to_string());
+                break;
+            }
+        }
+        let _ = sink
+            .send(WsMessage::Close(Some(CloseFrame {
+                code: CloseCode::Normal,
+                reason: "bridge closing".into(),
+            })))
+            .await;
+        let _ = sink.close().await;
+    });
+
+    // Dispatch each inbound frame on its own local task so a slow request
+    // handler (e.g. a login pending on the pairing prompt) cannot stall the
+    // read loop and starve later frames on the same connection. Responses may
+    // interleave; the wire protocol matches them by request id, and
+    // `WsTransport::send` is safe to call from concurrent local tasks.
+    let mut in_flight: Vec<tokio::task::JoinHandle<()>> = Vec::new();
+    while let Some(frame) = source.next().await {
+        match frame {
+            Ok(WsMessage::Binary(bytes)) => {
+                let message = match ProtocolMessage::decode(&mut &*bytes) {
+                    Ok(m) => m,
+                    Err(err) => {
+                        logger("truapi.ws_bridge.decode_error", &err.to_string());
+                        continue;
+                    }
+                };
+                in_flight.retain(|task| !task.is_finished());
+                let core = core.clone();
+                let transport = transport.clone();
+                in_flight.push(tokio::task::spawn_local(async move {
+                    core.dispatch(message, transport).await;
+                }));
+            }
+            Ok(WsMessage::Text(_)) => {
+                logger("truapi.ws_bridge.text_frame_ignored", "");
+            }
+            Ok(WsMessage::Close(_)) => break,
+            Ok(_) => {}
+            Err(err) => {
+                logger("truapi.ws_bridge.read_error", &err.to_string());
+                break;
+            }
+        }
+    }
+
+    // The connection is gone: cancel in-flight dispatches so long-pending
+    // handlers unwind instead of outliving the connection.
+    for task in &in_flight {
+        task.abort();
+    }
+
+    drop(transport);
+    let _ = pump.await;
+    logger("truapi.ws_bridge.connection_closed", &peer.to_string());
+}
+
+fn path_token_matches(path_and_query: Option<&str>, expected: &str) -> bool {
+    let Some(raw) = path_and_query else {
+        return false;
+    };
+    let query = match raw.find('?') {
+        Some(idx) => &raw[idx + 1..],
+        None => return false,
+    };
+    for pair in query.split('&') {
+        let (key, value) = match pair.split_once('=') {
+            Some(kv) => kv,
+            None => continue,
+        };
+        if key == "t" && constant_time_eq(value.as_bytes(), expected.as_bytes()) {
+            return true;
+        }
+    }
+    false
+}
+
+/// Constant-time byte-slice equality, used for the session-token check so a
+/// local peer cannot recover the token via early-exit comparison timing. The
+/// token length is fixed and public, so a length mismatch may short-circuit;
+/// only the value comparison must be constant time.
+fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+    let mut diff = 0u8;
+    for (x, y) in a.iter().zip(b.iter()) {
+        diff |= x ^ y;
+    }
+    diff == 0
+}
+
+struct WsTransport {
+    outbound: mpsc::Sender<Vec<u8>>,
+    closed: Mutex<bool>,
+}
+
+impl WsTransport {
+    fn new(outbound: mpsc::Sender<Vec<u8>>) -> Self {
+        Self {
+            outbound,
+            closed: Mutex::new(false),
+        }
+    }
+}
+
+impl Transport for WsTransport {
+    fn send(&self, message: ProtocolMessage) {
+        if *self.closed.lock().unwrap() {
+            return;
+        }
+        // Non-blocking: a full queue means the peer stopped reading, so the
+        // connection is treated as closed rather than buffering without bound.
+        if self.outbound.try_send(message.encode()).is_err() {
+            *self.closed.lock().unwrap() = true;
+        }
+    }
+
+    fn on_message(
+        &self,
+        _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+    ) -> Box<dyn FnOnce()> {
+        Box::new(|| {})
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use parity_scale_codec::Encode;
+    use truapi::v01;
+    use truapi::versioned::account::HostRequestLoginRequest;
+    use truapi::versioned::system::HostFeatureSupportedRequest;
+
+    use crate::frame::{Payload, request_ids};
+    use crate::test_support::{StubPlatform, first_pairing_deeplink, runtime_config};
+    use std::sync::atomic::Ordering;
+    use truapi_platform::AuthState;
+
+    fn test_core() -> Arc<TrUApiCore> {
+        core_for(Arc::new(StubPlatform::default()))
+    }
+
+    fn core_for(platform: Arc<StubPlatform>) -> Arc<TrUApiCore> {
+        Arc::new(TrUApiCore::from_platform_with_config(
+            platform,
+            runtime_config("dotli.dot"),
+            crate::subscription::thread_per_subscription_spawner(),
+        ))
+    }
+
+    #[test]
+    fn path_token_matches_exact() {
+        assert!(path_token_matches(Some("/?t=abc"), "abc"));
+        assert!(path_token_matches(Some("/?foo=1&t=abc"), "abc"));
+        assert!(!path_token_matches(Some("/?t=other"), "abc"));
+        assert!(!path_token_matches(Some("/?token=abc"), "abc"));
+        assert!(!path_token_matches(Some("/"), "abc"));
+        assert!(!path_token_matches(None, "abc"));
+    }
+
+    /// Spin the bridge up on `127.0.0.1:0`, dial it with a real
+    /// `tokio-tungstenite` client, send a known SCALE frame, and verify
+    /// the bridge echoes the SCALE-encoded `feature_supported` response.
+    #[test]
+    fn round_trip_feature_supported_through_bridge() {
+        let core = test_core();
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        let url = format!("ws://127.0.0.1:{}/?t={}", endpoint.port, endpoint.token);
+
+        // Use a fresh `tokio` runtime on the test thread so we don't fight
+        // the bridge's runtime, which lives on a different worker thread.
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+
+        let ids = request_ids("system_feature_supported").expect("known request method");
+        let response_bytes = rt.block_on(async {
+            let (mut ws, _) = tokio_tungstenite::connect_async(&url).await.expect("dial");
+
+            let request_frame = ProtocolMessage {
+                request_id: "p:1".into(),
+                payload: Payload {
+                    id: ids.request_id,
+                    value: HostFeatureSupportedRequest::V1(
+                        v01::HostFeatureSupportedRequest::Chain {
+                            genesis_hash: vec![0u8; 32],
+                        },
+                    )
+                    .encode(),
+                },
+            };
+            ws.send(WsMessage::Binary(request_frame.encode()))
+                .await
+                .expect("send");
+
+            // Block until the bridge replies with the response frame.
+            loop {
+                match ws.next().await {
+                    Some(Ok(WsMessage::Binary(bytes))) => break bytes,
+                    Some(Ok(_)) => continue,
+                    Some(Err(err)) => panic!("ws error: {err}"),
+                    None => panic!("connection closed before response"),
+                }
+            }
+        });
+
+        let response = ProtocolMessage::decode(&mut &response_bytes[..]).expect("decode response");
+        assert_eq!(response.request_id, "p:1");
+        assert_eq!(response.payload.id, ids.response_id);
+        // Wire payload is `Result<Ok, Err>`-shaped:
+        // [Ok disc=0x00][V1 variant 0x00][supported=1]
+        assert_eq!(response.payload.value, vec![0x00, 0x00, 0x01]);
+
+        bridge.stop();
+    }
+
+    fn request_frame(request_id: &str, method: &str, value: Vec<u8>) -> WsMessage {
+        let ids = request_ids(method).expect("known request method");
+        WsMessage::Binary(
+            ProtocolMessage {
+                request_id: request_id.into(),
+                payload: Payload {
+                    id: ids.request_id,
+                    value,
+                },
+            }
+            .encode(),
+        )
+    }
+
+    fn login_frame(request_id: &str) -> WsMessage {
+        request_frame(
+            request_id,
+            "account_request_login",
+            HostRequestLoginRequest::V1(v01::HostRequestLoginRequest { reason: None }).encode(),
+        )
+    }
+
+    /// A request whose handler pends (a login waiting on the pairing prompt)
+    /// must not serialize the connection: a concurrent `feature_supported`
+    /// on the same socket still round-trips while the login is in flight.
+    #[test]
+    fn slow_request_does_not_block_concurrent_round_trip() {
+        let platform = Arc::new(StubPlatform {
+            chain_connect_pending: true,
+            ..Default::default()
+        });
+        let auth_states = platform.auth_states.clone();
+        let core = core_for(platform);
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        let url = format!("ws://127.0.0.1:{}/?t={}", endpoint.port, endpoint.token);
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+
+        let feature_ids = request_ids("system_feature_supported").expect("known request method");
+        let response = rt.block_on(async {
+            let (mut ws, _) = tokio_tungstenite::connect_async(&url).await.expect("dial");
+            ws.send(login_frame("p:login")).await.expect("send login");
+
+            // Wait until the login handler has emitted the pairing state and
+            // is pending on the statement-store connect.
+            for _ in 0..1000 {
+                if first_pairing_deeplink(&auth_states).is_some() {
+                    break;
+                }
+                tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+            }
+            assert!(
+                first_pairing_deeplink(&auth_states).is_some(),
+                "login handler did not reach the pairing prompt"
+            );
+
+            ws.send(request_frame(
+                "p:feature",
+                "system_feature_supported",
+                HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+                    genesis_hash: vec![0u8; 32],
+                })
+                .encode(),
+            ))
+            .await
+            .expect("send feature_supported");
+
+            let bytes = tokio::time::timeout(std::time::Duration::from_secs(10), async {
+                loop {
+                    match ws.next().await {
+                        Some(Ok(WsMessage::Binary(bytes))) => break bytes,
+                        Some(Ok(_)) => continue,
+                        Some(Err(err)) => panic!("ws error: {err}"),
+                        None => panic!("connection closed before response"),
+                    }
+                }
+            })
+            .await
+            .expect("feature_supported must answer while the login is pending");
+            ProtocolMessage::decode(&mut &bytes[..]).expect("decode response")
+        });
+
+        assert_eq!(response.request_id, "p:feature");
+        assert_eq!(response.payload.id, feature_ids.response_id);
+        bridge.stop();
+    }
+
+    /// Dropping the client connection cancels in-flight requests: a pending
+    /// `request_login` unwinds (its statement-store connect future is
+    /// dropped) instead of outliving the connection, and the abandoned
+    /// pairing state is reset for the host UI.
+    #[test]
+    fn connection_drop_cancels_pending_request_login() {
+        let platform = Arc::new(StubPlatform {
+            chain_connect_pending: true,
+            ..Default::default()
+        });
+        let auth_states = platform.auth_states.clone();
+        let pending_connect_dropped = platform.pending_connect_dropped.clone();
+        let core = core_for(platform);
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        let url = format!("ws://127.0.0.1:{}/?t={}", endpoint.port, endpoint.token);
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+
+        rt.block_on(async {
+            let (mut ws, _) = tokio_tungstenite::connect_async(&url).await.expect("dial");
+            ws.send(login_frame("p:login")).await.expect("send login");
+
+            for _ in 0..1000 {
+                if first_pairing_deeplink(&auth_states).is_some() {
+                    break;
+                }
+                tokio::time::sleep(std::time::Duration::from_millis(5)).await;
+            }
+            assert!(
+                first_pairing_deeplink(&auth_states).is_some(),
+                "login handler did not reach the pairing prompt"
+            );
+
+            ws.close(None).await.ok();
+        });
+
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        while !pending_connect_dropped.load(Ordering::SeqCst) {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "pending request_login was not cancelled on connection drop"
+            );
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        loop {
+            let last = auth_states
+                .lock()
+                .expect("auth state list mutex poisoned")
+                .last()
+                .cloned();
+            if last == Some(AuthState::Disconnected) {
+                break;
+            }
+            assert!(
+                std::time::Instant::now() < deadline,
+                "abandoned pairing was not reset to Disconnected, last state: {last:?}"
+            );
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+        bridge.stop();
+    }
+
+    /// A handshake with the wrong `?t=` token must be rejected at the HTTP
+    /// upgrade step with a 401, not silently dropped.
+    #[test]
+    fn wrong_token_is_rejected_at_handshake() {
+        let core = test_core();
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        let url = format!("ws://127.0.0.1:{}/?t=bogus", endpoint.port);
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+
+        let err = rt
+            .block_on(async { tokio_tungstenite::connect_async(&url).await })
+            .expect_err("connection must be refused");
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("401") || msg.to_lowercase().contains("unauthorized"),
+            "expected 401/unauthorized rejection, got: {msg}",
+        );
+
+        bridge.stop();
+    }
+
+    /// Dropping a `WsBridge` handle without an explicit `stop()` must still
+    /// shut the worker thread down cleanly. `Drop::drop` calls `stop`, and
+    /// a second `stop` (from drop after the test's explicit one) is a
+    /// no-op.
+    #[test]
+    fn drop_calls_stop_idempotently() {
+        let core = test_core();
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (bridge, _endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        // Drop the bridge; the worker thread must join via Drop.
+        drop(bridge);
+
+        // Build a second bridge and explicitly stop twice. The second
+        // call has no shutdown sender and no thread handle left to join,
+        // so it returns without panicking.
+        let core = test_core();
+        let logger: BridgeLogger = Arc::new(|_, _| {});
+        let (mut bridge, _endpoint) = WsBridge::start(0, core, logger).expect("start bridge");
+        bridge.stop();
+        bridge.stop();
+    }
+}
diff --git a/rust/crates/truapi-server/tests/common/mod.rs b/rust/crates/truapi-server/tests/common/mod.rs
new file mode 100644
index 00000000..96bdb126
--- /dev/null
+++ b/rust/crates/truapi-server/tests/common/mod.rs
@@ -0,0 +1,180 @@
+#[cfg(target_arch = "wasm32")]
+use std::sync::Arc;
+
+use futures::stream::{self, BoxStream};
+use truapi::v01;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi_platform::{
+    AuthPresenter, ChainProvider, Features, JsonRpcConnection, Navigation, Notifications,
+    PairingDeeplinkScheme, Permissions, PreimageHost, RuntimeConfig, SessionStore, Storage,
+    ThemeHost, UserConfirmation,
+};
+
+pub fn test_spawner() -> truapi_server::subscription::Spawner {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        truapi_server::subscription::thread_per_subscription_spawner()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        Arc::new(futures::executor::block_on)
+    }
+}
+
+pub fn test_runtime_config() -> RuntimeConfig {
+    RuntimeConfig {
+        product_label: "dotli".to_string(),
+        product_id: "dotli.dot".to_string(),
+        site_id: "dot.li".to_string(),
+        host_name: "Polkadot Web".to_string(),
+        host_icon: Some("https://dot.li/dotli.png".to_string()),
+        host_version: None,
+        platform_type: None,
+        platform_version: None,
+        people_chain_genesis_hash: [0xa2; 32],
+        pairing_deeplink_scheme: PairingDeeplinkScheme::PolkadotApp,
+    }
+}
+
+pub struct WireShapePlatform;
+
+impl Storage for WireShapePlatform {
+    async fn read(&self, _key: String) -> Result<Option<Vec<u8>>, v01::HostLocalStorageReadError> {
+        Err(v01::HostLocalStorageReadError::Full)
+    }
+    async fn write(
+        &self,
+        _key: String,
+        _value: Vec<u8>,
+    ) -> Result<(), v01::HostLocalStorageReadError> {
+        Ok(())
+    }
+    async fn clear(&self, _key: String) -> Result<(), v01::HostLocalStorageReadError> {
+        Ok(())
+    }
+}
+
+impl Navigation for WireShapePlatform {
+    async fn navigate_to(&self, _url: String) -> Result<(), v01::HostNavigateToError> {
+        Ok(())
+    }
+}
+
+impl Notifications for WireShapePlatform {
+    async fn push_notification(
+        &self,
+        _notification: v01::HostPushNotificationRequest,
+    ) -> Result<v01::HostPushNotificationResponse, v01::GenericError> {
+        Ok(v01::HostPushNotificationResponse { id: 0 })
+    }
+
+    async fn cancel_notification(&self, _id: u32) -> Result<(), v01::GenericError> {
+        Ok(())
+    }
+}
+
+impl Permissions for WireShapePlatform {
+    async fn device_permission(
+        &self,
+        _request: v01::HostDevicePermissionRequest,
+    ) -> Result<v01::HostDevicePermissionResponse, v01::GenericError> {
+        Ok(v01::HostDevicePermissionResponse { granted: true })
+    }
+    async fn remote_permission(
+        &self,
+        _request: v01::RemotePermissionRequest,
+    ) -> Result<v01::RemotePermissionResponse, v01::GenericError> {
+        Ok(v01::RemotePermissionResponse { granted: true })
+    }
+}
+
+impl Features for WireShapePlatform {
+    async fn feature_supported(
+        &self,
+        _request: HostFeatureSupportedRequest,
+    ) -> Result<HostFeatureSupportedResponse, v01::GenericError> {
+        Ok(HostFeatureSupportedResponse::V1(
+            v01::HostFeatureSupportedResponse { supported: true },
+        ))
+    }
+}
+
+struct DeadConnection;
+
+impl JsonRpcConnection for DeadConnection {
+    fn send(&self, _request: String) {}
+    fn responses(&self) -> BoxStream<'static, String> {
+        Box::pin(stream::empty())
+    }
+}
+
+impl ChainProvider for WireShapePlatform {
+    async fn connect(
+        &self,
+        _genesis_hash: Vec<u8>,
+    ) -> Result<Box<dyn JsonRpcConnection>, v01::GenericError> {
+        Ok(Box::new(DeadConnection))
+    }
+}
+
+impl AuthPresenter for WireShapePlatform {}
+
+impl SessionStore for WireShapePlatform {
+    async fn read_session(&self) -> Result<Option<Vec<u8>>, v01::GenericError> {
+        Ok(None)
+    }
+    async fn write_session(&self, _value: Vec<u8>) -> Result<(), v01::GenericError> {
+        Ok(())
+    }
+    async fn clear_session(&self) -> Result<(), v01::GenericError> {
+        Ok(())
+    }
+    fn subscribe_session_store(&self) -> BoxStream<'static, Result<(), v01::GenericError>> {
+        Box::pin(stream::once(async { Ok(()) }))
+    }
+}
+
+impl UserConfirmation for WireShapePlatform {
+    async fn confirm_sign_payload(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        Ok(false)
+    }
+    async fn confirm_sign_raw(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        Ok(false)
+    }
+    async fn confirm_create_transaction(
+        &self,
+        _review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        Ok(false)
+    }
+    async fn confirm_account_alias(&self, _review: Vec<u8>) -> Result<bool, v01::GenericError> {
+        Ok(false)
+    }
+    async fn confirm_resource_allocation(
+        &self,
+        _review: Vec<u8>,
+    ) -> Result<bool, v01::GenericError> {
+        Ok(false)
+    }
+}
+
+impl ThemeHost for WireShapePlatform {
+    fn subscribe_theme(&self) -> BoxStream<'static, Result<v01::ThemeVariant, v01::GenericError>> {
+        Box::pin(stream::empty())
+    }
+}
+
+impl PreimageHost for WireShapePlatform {
+    async fn confirm_preimage_submit(&self, _size: u64) -> Result<(), v01::PreimageSubmitError> {
+        Ok(())
+    }
+    async fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, v01::PreimageSubmitError> {
+        Ok(value)
+    }
+    fn lookup_preimage(
+        &self,
+        _key: Vec<u8>,
+    ) -> BoxStream<'static, Result<Option<Vec<u8>>, v01::GenericError>> {
+        Box::pin(stream::empty())
+    }
+}
diff --git a/rust/crates/truapi-server/tests/golden_frame.rs b/rust/crates/truapi-server/tests/golden_frame.rs
new file mode 100644
index 00000000..24dd21fa
--- /dev/null
+++ b/rust/crates/truapi-server/tests/golden_frame.rs
@@ -0,0 +1,53 @@
+//! Binary golden-frame regression test.
+//!
+//! Loads `tests/snapshots/golden-account-get.bin` (the captured raw bytes
+//! of an `account_get_account_request` frame) and asserts that
+//! `ProtocolMessage::decode` produces the expected in-memory shape.
+//!
+//! The frame encodes:
+//!   requestId = "p:1"
+//!   payload   = account_get_account_request,
+//!               inner = HostAccountGetRequest::V1(("foo", 0u32))
+//!
+//! On the wire (14 bytes):
+//!   [0c 70 3a 31]                      requestId = compact-len(3) + "p:1"
+//!   [16]                               discriminant 22 = account_get_account_request
+//!   [00]                               versioned wrapper variant V1
+//!   [0c 66 6f 6f]                      "foo"
+//!   [00 00 00 00]                      u32 = 0
+//!
+//! If this test fails after a wire-protocol change, regenerate the file
+//! deliberately and re-check the change against the wire table.
+
+use parity_scale_codec::{Decode, Encode};
+use truapi_server::generated::wire_table;
+use truapi_server::{Payload, ProtocolMessage};
+
+const GOLDEN: &[u8] = include_bytes!("snapshots/golden-account-get.bin");
+
+#[test]
+fn golden_account_get_frame_decodes_to_expected_message() {
+    let decoded = ProtocolMessage::decode(&mut &GOLDEN[..])
+        .expect("golden frame must decode with the current wire codec");
+
+    let mut expected_inner = Vec::new();
+    expected_inner.push(0x00u8); // V1 variant
+    "foo".to_string().encode_to(&mut expected_inner);
+    0u32.encode_to(&mut expected_inner);
+
+    let expected = ProtocolMessage {
+        request_id: "p:1".to_string(),
+        payload: Payload {
+            id: wire_table::ACCOUNT_GET_ACCOUNT.request_id,
+            value: expected_inner,
+        },
+    };
+    assert_eq!(decoded, expected);
+}
+
+#[test]
+fn golden_account_get_frame_round_trips() {
+    // Encoding the in-memory shape must reproduce the on-disk bytes exactly.
+    let decoded = ProtocolMessage::decode(&mut &GOLDEN[..]).expect("decode");
+    assert_eq!(decoded.encode(), GOLDEN);
+}
diff --git a/rust/crates/truapi-server/tests/snapshots/golden-account-get.bin b/rust/crates/truapi-server/tests/snapshots/golden-account-get.bin
new file mode 100644
index 00000000..c66be11b
Binary files /dev/null and b/rust/crates/truapi-server/tests/snapshots/golden-account-get.bin differ
diff --git a/rust/crates/truapi-server/tests/wasm_crypto_vectors.rs b/rust/crates/truapi-server/tests/wasm_crypto_vectors.rs
new file mode 100644
index 00000000..3add1123
--- /dev/null
+++ b/rust/crates/truapi-server/tests/wasm_crypto_vectors.rs
@@ -0,0 +1,236 @@
+#![cfg(target_arch = "wasm32")]
+
+use aes_gcm::aead::{Aead, KeyInit};
+use aes_gcm::{Aes256Gcm, Nonce};
+use hkdf::Hkdf;
+use p256::SecretKey;
+use p256::ecdh::diffie_hellman;
+use p256::elliptic_curve::sec1::ToEncodedPoint;
+use parity_scale_codec::{Decode, Encode};
+use schnorrkel::{ExpansionMode, MiniSecretKey};
+use sha2::Sha256;
+use truapi_platform::{PairingDeeplinkScheme, RuntimeConfig};
+use truapi_server::host_logic::entropy::derive_product_entropy;
+use truapi_server::host_logic::product_account::{
+    derive_product_public_key, product_public_key_to_address,
+};
+use truapi_server::host_logic::session::SsoSessionInfo;
+use truapi_server::host_logic::sso_pairing::{
+    AES_GCM_NONCE_LEN, EncryptedHandshakeResponseV2, HandshakeMetadataEntry, HandshakeMetadataKey,
+    HandshakeSuccessV2, PairingBootstrap, SsoStatementData, VersionedHandshakeProposal,
+    VersionedHandshakeResponse, bootstrap_topic, build_pairing_deeplink, decode_app_handshake_data,
+    decrypt_session_statement_data, decrypt_v2_handshake_response,
+    encrypt_session_statement_data_with_nonce, establish_sso_session_info,
+};
+use truapi_server::host_logic::statement_store::{
+    build_signed_session_request_statement, decode_verified_statement_data,
+};
+use wasm_bindgen_test::wasm_bindgen_test;
+
+const ROOT_PUBLIC_KEY: [u8; 32] = [
+    0x80, 0x05, 0x28, 0xc9, 0x55, 0x87, 0x3e, 0x4c, 0x78, 0xb7, 0xdf, 0x24, 0xf7, 0x1d, 0xb8, 0xf5,
+    0x81, 0xaa, 0x99, 0xe3, 0x49, 0x3b, 0xf4, 0x96, 0xed, 0xf1, 0x51, 0xab, 0xc1, 0xd7, 0x20, 0x23,
+];
+
+const SS_PUBLIC: [u8; 32] = [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+];
+
+const ENC_PUBLIC: [u8; 65] = [
+    0x04, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+    0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
+    0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
+    0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
+    0x3f,
+];
+
+fn entropy_secret() -> [u8; 32] {
+    let mut secret = [0u8; 32];
+    for (i, byte) in secret.iter_mut().enumerate() {
+        *byte = i as u8;
+    }
+    secret
+}
+
+fn runtime_config() -> RuntimeConfig {
+    RuntimeConfig {
+        product_label: "dotli".to_string(),
+        product_id: "dotli.dot".to_string(),
+        site_id: "dot.li".to_string(),
+        host_name: "Polkadot Web".to_string(),
+        host_icon: Some("https://example.invalid/dotli.png".to_string()),
+        host_version: Some("1.2.3".to_string()),
+        platform_type: Some("Firefox".to_string()),
+        platform_version: Some("192.32".to_string()),
+        people_chain_genesis_hash: [0xa2; 32],
+        pairing_deeplink_scheme: PairingDeeplinkScheme::PolkadotApp,
+    }
+}
+
+fn statement_session() -> SsoSessionInfo {
+    let mini_secret = MiniSecretKey::from_bytes(&[7; 32]).unwrap();
+    let keypair = mini_secret.expand_to_keypair(ExpansionMode::Ed25519);
+    SsoSessionInfo {
+        ss_secret: keypair.secret.to_bytes(),
+        ss_public_key: keypair.public.to_bytes(),
+        enc_secret: [1; 32],
+        peer_enc_pubkey: [2; 65],
+        identity_account_id: [3; 32],
+        session_id_own: [4; 32],
+        session_id_peer: [5; 32],
+        request_channel: [6; 32],
+        response_channel: [7; 32],
+        peer_request_channel: [8; 32],
+    }
+}
+
+fn sso_session() -> SsoSessionInfo {
+    let core_secret = SecretKey::from_slice(&[1; 32]).unwrap();
+    let core_public = core_secret.public_key().to_encoded_point(false);
+    let bootstrap = PairingBootstrap {
+        deeplink: "polkadotapp://pair?handshake=00".to_string(),
+        topic: [0x11; 32],
+        statement_store_public_key: [0x22; 32],
+        statement_store_secret: [0x33; 64],
+        encryption_public_key: core_public.as_bytes().try_into().unwrap(),
+        encryption_secret_key: [1; 32],
+    };
+    let peer_secret = SecretKey::from_slice(&[2; 32]).unwrap();
+    let peer_sso_enc_pub_key = peer_secret
+        .public_key()
+        .to_encoded_point(false)
+        .as_bytes()
+        .try_into()
+        .unwrap();
+
+    establish_sso_session_info(&bootstrap, [0x55; 32], peer_sso_enc_pub_key).unwrap()
+}
+
+#[wasm_bindgen_test]
+fn product_account_and_entropy_vectors_match_dotli() {
+    let derived = derive_product_public_key(ROOT_PUBLIC_KEY, "myapp.dot", 0).unwrap();
+    assert_eq!(
+        hex::encode(derived),
+        "281489e3dd1c4dbe88cd670a59edcc9c44d64f510d302bd527ec306f10292f08"
+    );
+    assert_eq!(
+        product_public_key_to_address(derived),
+        "5CyFsdhwjXy7wWpDEM6isungQ3LfGnu9UXkt7paBQ6DYRxk1"
+    );
+
+    let entropy = derive_product_entropy(&entropy_secret(), "myapp.dot", b"product-key").unwrap();
+    assert_eq!(
+        hex::encode(entropy),
+        "ab1887248c9de3cf4b8c5a255782796d3d35a98c8eb2d7df61a410db8b14da36"
+    );
+}
+
+#[wasm_bindgen_test]
+fn pairing_deeplink_topic_and_scale_vectors_match_dotli() {
+    let config = runtime_config();
+    let deeplink = build_pairing_deeplink(
+        PairingDeeplinkScheme::PolkadotApp,
+        SS_PUBLIC,
+        ENC_PUBLIC,
+        &config,
+    );
+    assert!(deeplink.starts_with("polkadotapp://pair?handshake=01"));
+    let encoded = hex::decode(deeplink.split("handshake=").nth(1).unwrap()).unwrap();
+    let decoded = VersionedHandshakeProposal::decode(&mut &encoded[..]).unwrap();
+    let VersionedHandshakeProposal::V2(proposal) = decoded else {
+        panic!("expected V2 proposal");
+    };
+    assert_eq!(proposal.device.statement_account_id, SS_PUBLIC);
+    assert_eq!(proposal.device.encryption_public_key, ENC_PUBLIC);
+    assert!(proposal.metadata.contains(&HandshakeMetadataEntry(
+        HandshakeMetadataKey::HostName,
+        "Polkadot Web".to_string()
+    )));
+    assert!(proposal.metadata.contains(&HandshakeMetadataEntry(
+        HandshakeMetadataKey::HostIcon,
+        "https://example.invalid/dotli.png".to_string()
+    )));
+    assert_eq!(
+        hex::encode(bootstrap_topic(SS_PUBLIC, ENC_PUBLIC)),
+        "031c589833c39b1dfbe3c1304ced75fa7b0d841035db008e5b407bfadd2779a4"
+    );
+
+    let answer = VersionedHandshakeResponse::V2 {
+        encrypted_message: vec![0xde, 0xad],
+        public_key: ENC_PUBLIC,
+    };
+    assert_eq!(decode_app_handshake_data(&answer.encode()).unwrap(), answer);
+}
+
+#[wasm_bindgen_test]
+fn p256_hkdf_aes_gcm_vectors_work_on_wasm() {
+    let core_secret = SecretKey::from_slice(&[1; 32]).unwrap();
+    let wallet_ephemeral_secret = SecretKey::from_slice(&[2; 32]).unwrap();
+    let wallet_ephemeral_public = wallet_ephemeral_secret.public_key().to_encoded_point(false);
+
+    let shared_secret = diffie_hellman(
+        wallet_ephemeral_secret.to_nonzero_scalar(),
+        core_secret.public_key().as_affine(),
+    );
+    let hkdf = Hkdf::<Sha256>::new(None, shared_secret.raw_secret_bytes());
+    let mut aes_key = [0u8; 32];
+    hkdf.expand(&[], &mut aes_key).unwrap();
+
+    let sensitive = EncryptedHandshakeResponseV2::Success(HandshakeSuccessV2 {
+        identity_account_id: [8; 32],
+        root_account_id: [7; 32],
+        identity_chat_private_key: [6; 32],
+        sso_enc_pub_key: ENC_PUBLIC,
+        device_enc_pub_key: ENC_PUBLIC,
+        root_entropy_source: [5; 32],
+    });
+    let nonce = [9u8; AES_GCM_NONCE_LEN];
+    let cipher = Aes256Gcm::new_from_slice(&aes_key).unwrap();
+    let mut encrypted = nonce.to_vec();
+    encrypted.extend(
+        cipher
+            .encrypt(Nonce::from_slice(&nonce), sensitive.encode().as_slice())
+            .unwrap(),
+    );
+
+    assert_eq!(
+        decrypt_v2_handshake_response(
+            core_secret.to_bytes().into(),
+            wallet_ephemeral_public.as_bytes().try_into().unwrap(),
+            &encrypted,
+        )
+        .unwrap(),
+        sensitive
+    );
+}
+
+#[wasm_bindgen_test]
+fn session_crypto_and_statement_proof_vectors_work_on_wasm() {
+    let session = sso_session();
+    let data = SsoStatementData::Request {
+        request_id: "req-1".to_string(),
+        data: vec![vec![0xde, 0xad]],
+    };
+    let nonce = [9u8; AES_GCM_NONCE_LEN];
+    let encrypted = encrypt_session_statement_data_with_nonce(&session, &data, nonce).unwrap();
+
+    assert_eq!(&encrypted[..AES_GCM_NONCE_LEN], nonce);
+    assert_eq!(
+        SsoStatementData::decode(&mut &data.encode()[..]).unwrap(),
+        data
+    );
+    assert_eq!(
+        decrypt_session_statement_data(&session, &encrypted).unwrap(),
+        data
+    );
+
+    let statement_session = statement_session();
+    let statement =
+        build_signed_session_request_statement(&statement_session, vec![0xde, 0xad], 42).unwrap();
+    let verified =
+        decode_verified_statement_data(&statement, Some(statement_session.ss_public_key)).unwrap();
+
+    assert_eq!(verified.signer, statement_session.ss_public_key);
+    assert_eq!(verified.data, vec![0xde, 0xad]);
+}
diff --git a/rust/crates/truapi-server/tests/wire_result_shape.rs b/rust/crates/truapi-server/tests/wire_result_shape.rs
new file mode 100644
index 00000000..bafa0bf7
--- /dev/null
+++ b/rust/crates/truapi-server/tests/wire_result_shape.rs
@@ -0,0 +1,434 @@
+//! Result-wire-shape regression test.
+//!
+//! The TS host/client codec expects every request response to be
+//! `Result<Ok, Err>`-shaped on the wire (one leading discriminant byte
+//! followed by the SCALE-encoded value). This test stands up a
+//! `TrUApiCore::from_platform_with_config` with a platform whose `Features`
+//! impl returns `Ok(supported = true)` and asserts:
+//!
+//! - A `system_feature_supported_request` produces a response whose
+//!   payload begins with `0x00` (Ok), followed by the encoded
+//!   `HostFeatureSupportedResponse::V1(true)`.
+//! - A `local_storage_read_request` whose stub returns
+//!   `Err(HostLocalStorageReadError::Full)` produces a response whose
+//!   payload begins with `0x01` (Err), followed by the encoded
+//!   `CallError::Domain(Full)`.
+//!
+//! Both halves prove the wire layout stays in lockstep with the TS
+//! `S.Result(ok, err)` codec.
+
+use std::sync::Arc;
+
+use parity_scale_codec::{Decode, Encode};
+
+use truapi::v01;
+use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
+use truapi::versioned::{account, payment, statement_store};
+
+use truapi_server::{
+    Payload, ProtocolMessage, TrUApiCore, encode_call_error_payload, request_ids, subscription_ids,
+};
+
+mod common;
+use common::{WireShapePlatform, test_runtime_config, test_spawner};
+
+const PAYMENTS_NOT_IMPLEMENTED: &str = "Payments are not supported in dot.li";
+
+fn dispatch(core: &TrUApiCore, frame: ProtocolMessage) -> ProtocolMessage {
+    let encoded = frame.encode();
+    let response_bytes = core
+        .receive_from_product(&encoded)
+        .expect("dispatcher emitted a response frame");
+    ProtocolMessage::decode(&mut &response_bytes[..]).expect("decode response")
+}
+
+#[test]
+fn feature_supported_ok_response_uses_ok_discriminant() {
+    let core = make_core();
+    let request = HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+        genesis_hash: vec![0u8; 32],
+    });
+    let ids = request_ids("system_feature_supported").expect("known request method");
+    let frame = ProtocolMessage {
+        request_id: "p:1".into(),
+        payload: Payload {
+            id: ids.request_id,
+            value: request.encode(),
+        },
+    };
+    let response = dispatch(&core, frame);
+    assert_eq!(response.request_id, "p:1");
+    assert_eq!(response.payload.id, ids.response_id);
+
+    // Wire payload: [Ok disc=0x00][encoded versioned response]
+    let mut expected = vec![0x00u8];
+    HostFeatureSupportedResponse::V1(v01::HostFeatureSupportedResponse { supported: true })
+        .encode_to(&mut expected);
+    assert_eq!(response.payload.value, expected);
+    // The Result-disc byte is unambiguously 0x00 for Ok.
+    assert_eq!(response.payload.value.first(), Some(&0x00));
+}
+
+#[test]
+fn local_storage_read_err_response_uses_err_discriminant() {
+    let core = make_core();
+    let request = truapi::versioned::local_storage::HostLocalStorageReadRequest::V1(
+        v01::HostLocalStorageReadRequest {
+            key: "missing".to_string(),
+        },
+    );
+    let ids = request_ids("local_storage_read").expect("known request method");
+    let frame = ProtocolMessage {
+        request_id: "p:2".into(),
+        payload: Payload {
+            id: ids.request_id,
+            value: request.encode(),
+        },
+    };
+    let response = dispatch(&core, frame);
+    assert_eq!(response.request_id, "p:2");
+    assert_eq!(response.payload.id, ids.response_id);
+
+    // Wire payload: `[Err disc=0x01][CallError::Domain variant=0x00][encoded
+    // domain error]`. Build the expected bytes from the typed value the runtime
+    // wraps (the stub returns `Full`) rather than a hand-written literal, so a
+    // reorder of any domain enum variant is caught instead of silently passing.
+    let domain = truapi::versioned::local_storage::HostLocalStorageReadError::V1(
+        v01::HostLocalStorageReadError::Full,
+    );
+    let mut expected = vec![0x01u8, 0x00u8];
+    domain.encode_to(&mut expected);
+    assert_eq!(response.payload.value, expected);
+    assert_eq!(response.payload.value.first(), Some(&0x01));
+}
+
+fn assert_request_returns_unsupported(
+    core: &TrUApiCore,
+    request_id: &str,
+    method: &str,
+    value: Vec<u8>,
+) {
+    let ids = request_ids(method).expect("known request method");
+    let response = dispatch(
+        core,
+        ProtocolMessage {
+            request_id: request_id.into(),
+            payload: Payload {
+                id: ids.request_id,
+                value,
+            },
+        },
+    );
+    assert_eq!(response.request_id, request_id);
+    assert_eq!(response.payload.id, ids.response_id);
+    assert_eq!(
+        response.payload.value,
+        vec![0x01, 0x02],
+        "{method} must remain explicitly unavailable for current dotli parity"
+    );
+}
+
+fn assert_request_returns_domain_error<E: Encode>(
+    core: &TrUApiCore,
+    request_id: &str,
+    method: &str,
+    value: Vec<u8>,
+    error: truapi::CallError<E>,
+) {
+    let ids = request_ids(method).expect("known request method");
+    let response = dispatch(
+        core,
+        ProtocolMessage {
+            request_id: request_id.into(),
+            payload: Payload {
+                id: ids.request_id,
+                value,
+            },
+        },
+    );
+    assert_eq!(response.request_id, request_id);
+    assert_eq!(response.payload.id, ids.response_id);
+    let mut expected = vec![0x01u8];
+    expected.extend(encode_call_error_payload(error));
+    assert_eq!(response.payload.value, expected);
+}
+
+fn assert_subscription_start_interrupts_error<E: Encode>(
+    core: &TrUApiCore,
+    request_id: &str,
+    method: &str,
+    value: Vec<u8>,
+    error: truapi::CallError<E>,
+) {
+    use std::sync::Mutex;
+    use truapi_server::Transport;
+
+    #[derive(Default)]
+    struct RecordingTransport {
+        sent: Mutex<Vec<ProtocolMessage>>,
+    }
+    impl Transport for RecordingTransport {
+        fn send(&self, message: ProtocolMessage) {
+            self.sent.lock().unwrap().push(message);
+        }
+        fn on_message(
+            &self,
+            _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+        ) -> Box<dyn FnOnce()> {
+            Box::new(|| {})
+        }
+    }
+
+    let ids = subscription_ids(method).expect("known subscription method");
+    let transport = Arc::new(RecordingTransport::default());
+    futures::executor::block_on(core.dispatch(
+        ProtocolMessage {
+            request_id: request_id.into(),
+            payload: Payload {
+                id: ids.start_id,
+                value,
+            },
+        },
+        transport.clone(),
+    ));
+
+    let sent = transport.sent.lock().unwrap();
+    assert_eq!(sent.len(), 1);
+    assert_eq!(sent[0].request_id, request_id);
+    assert_eq!(sent[0].payload.id, ids.interrupt_id);
+    assert_eq!(sent[0].payload.value, encode_call_error_payload(error));
+}
+
+#[test]
+fn deferred_account_proof_returns_unsupported() {
+    let core = make_core();
+    let request = account::HostAccountCreateProofRequest::V1(v01::HostAccountCreateProofRequest {
+        product_account_id: v01::ProductAccountId {
+            dot_ns_identifier: "myapp.dot".to_string(),
+            derivation_index: 0,
+        },
+        ring_location: v01::RingLocation {
+            genesis_hash: vec![0u8; 32],
+            ring_root_hash: vec![1u8; 32],
+            hints: None,
+        },
+        context: Vec::new(),
+    });
+
+    assert_request_returns_unsupported(
+        &core,
+        "p:account-proof",
+        "account_create_account_proof",
+        request.encode(),
+    );
+}
+
+#[test]
+fn deferred_payment_requests_return_dotli_not_implemented_errors() {
+    let core = make_core();
+    let request = payment::HostPaymentRequest::V1(v01::HostPaymentRequest {
+        from: None,
+        amount: 1,
+        destination: [0u8; 32],
+    });
+
+    assert_request_returns_domain_error(
+        &core,
+        "p:payment",
+        "payment_request",
+        request.encode(),
+        truapi::CallError::Domain(payment::HostPaymentError::V1(
+            v01::HostPaymentError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )),
+    );
+
+    let top_up = payment::HostPaymentTopUpRequest::V1(v01::HostPaymentTopUpRequest {
+        into: None,
+        amount: 1,
+        source: v01::PaymentTopUpSource::ProductAccount {
+            derivation_index: 0,
+        },
+    });
+    assert_request_returns_domain_error(
+        &core,
+        "p:top-up",
+        "payment_top_up",
+        top_up.encode(),
+        truapi::CallError::Domain(payment::HostPaymentTopUpError::V1(
+            v01::HostPaymentTopUpError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )),
+    );
+}
+
+#[test]
+fn deferred_payment_subscriptions_interrupt_dotli_not_implemented_errors() {
+    let core = make_core();
+    let balance =
+        payment::HostPaymentBalanceSubscribeRequest::V1(v01::HostPaymentBalanceSubscribeRequest {
+            purse: None,
+        });
+    assert_subscription_start_interrupts_error(
+        &core,
+        "p:balance",
+        "payment_balance_subscribe",
+        balance.encode(),
+        truapi::CallError::Domain(payment::HostPaymentBalanceSubscribeError::V1(
+            v01::HostPaymentBalanceSubscribeError::PermissionDenied,
+        )),
+    );
+
+    let status =
+        payment::HostPaymentStatusSubscribeRequest::V1(v01::HostPaymentStatusSubscribeRequest {
+            payment_id: "payment-id".to_string(),
+        });
+    assert_subscription_start_interrupts_error(
+        &core,
+        "p:status",
+        "payment_status_subscribe",
+        status.encode(),
+        truapi::CallError::Domain(payment::HostPaymentStatusSubscribeError::V1(
+            v01::HostPaymentStatusSubscribeError::Unknown {
+                reason: PAYMENTS_NOT_IMPLEMENTED.to_string(),
+            },
+        )),
+    );
+}
+
+#[test]
+fn statement_store_subscribe_topic_limit_interrupts_with_typed_error() {
+    let core = make_core();
+    let request = statement_store::RemoteStatementStoreSubscribeRequest::V1(
+        v01::RemoteStatementStoreSubscribeRequest::MatchAny(vec![[7u8; 32]; 129]),
+    );
+
+    assert_subscription_start_interrupts_error(
+        &core,
+        "p:ss-too-many",
+        "statement_store_subscribe",
+        request.encode(),
+        truapi::CallError::Domain(statement_store::RemoteStatementStoreSubscribeError::V1(
+            v01::GenericError {
+                reason: "MatchAny has 129 topics, maximum is 128".to_string(),
+            },
+        )),
+    );
+}
+
+fn make_core() -> TrUApiCore {
+    TrUApiCore::from_platform_with_config(
+        Arc::new(WireShapePlatform),
+        test_runtime_config(),
+        test_spawner(),
+    )
+}
+
+/// Untrusted product input that is not a decodable frame must be dropped
+/// (return `None`), never panic. Exercises the decode-failure boundary in
+/// `receive_from_product` that the happy-path tests above bypass.
+#[test]
+fn malformed_frames_are_dropped_without_panic() {
+    let core = make_core();
+
+    // Empty input and arbitrary garbage.
+    assert!(core.receive_from_product(&[]).is_none());
+    assert!(
+        core.receive_from_product(&[0xff, 0xff, 0xff, 0xff])
+            .is_none()
+    );
+
+    // A truncated SCALE string header (claims length but no body).
+    assert!(
+        core.receive_from_product(&[200u8 << 2, 0x61, 0x62])
+            .is_none()
+    );
+
+    // A well-formed requestId envelope carrying an unknown wire discriminant.
+    let mut unknown_disc = Vec::new();
+    "p:1".to_string().encode_to(&mut unknown_disc);
+    unknown_disc.push(0xFA);
+    unknown_disc.extend_from_slice(&[0u8; 4]);
+    assert!(core.receive_from_product(&unknown_disc).is_none());
+}
+
+/// Drive a subscription through the encoded-frame boundary: `_start` yields
+/// the initial `_receive`, then `_stop` tears it down so a later session
+/// change produces no further frames. Covers the wire layer the in-crate
+/// `subscription.rs` unit tests bypass.
+#[test]
+fn subscription_start_receive_stop_through_wire_boundary() {
+    use std::sync::Mutex;
+    use std::time::{Duration, Instant};
+    use truapi_server::Transport;
+
+    #[derive(Default)]
+    struct RecordingTransport {
+        sent: Mutex<Vec<ProtocolMessage>>,
+    }
+    impl Transport for RecordingTransport {
+        fn send(&self, message: ProtocolMessage) {
+            self.sent.lock().unwrap().push(message);
+        }
+        fn on_message(
+            &self,
+            _handler: Box<dyn Fn(ProtocolMessage) + Send + Sync>,
+        ) -> Box<dyn FnOnce()> {
+            Box::new(|| {})
+        }
+    }
+
+    let core = make_core();
+    let transport = Arc::new(RecordingTransport::default());
+    let dyn_transport: Arc<dyn Transport> = transport.clone();
+
+    let method = "account_connection_status_subscribe";
+    let ids = subscription_ids(method).expect("known subscription method");
+    let start = ProtocolMessage {
+        request_id: "p:1".into(),
+        payload: Payload {
+            id: ids.start_id,
+            value: Vec::new(),
+        },
+    };
+    futures::executor::block_on(core.dispatch(start, dyn_transport.clone()));
+
+    // Wait for the initial `_receive` item (Disconnected).
+    let deadline = Instant::now() + Duration::from_secs(2);
+    while transport.sent.lock().unwrap().is_empty() {
+        assert!(Instant::now() < deadline, "no initial _receive frame");
+        std::thread::sleep(Duration::from_millis(10));
+    }
+    assert_eq!(transport.sent.lock().unwrap()[0].payload.id, ids.receive_id);
+
+    // Stop the subscription, then push a session change. A live subscription
+    // would emit a Connected `_receive`; a stopped one must stay silent.
+    let stop = ProtocolMessage {
+        request_id: "p:1".into(),
+        payload: Payload {
+            id: ids.stop_id,
+            value: Vec::new(),
+        },
+    };
+    futures::executor::block_on(core.dispatch(stop, dyn_transport));
+    std::thread::sleep(Duration::from_millis(50));
+
+    core.session_state()
+        .set_session(truapi_server::host_logic::session::SessionInfo {
+            public_key: [7u8; 32],
+            sso: None,
+            root_entropy_source: None,
+            identity_account_id: None,
+            lite_username: None,
+            full_username: None,
+        });
+    std::thread::sleep(Duration::from_millis(50));
+
+    assert_eq!(
+        transport.sent.lock().unwrap().len(),
+        1,
+        "stopped subscription must emit no further frames"
+    );
+}
diff --git a/rust/crates/truapi-server/tests/wire_table_ts_parity.rs b/rust/crates/truapi-server/tests/wire_table_ts_parity.rs
new file mode 100644
index 00000000..e349139c
--- /dev/null
+++ b/rust/crates/truapi-server/tests/wire_table_ts_parity.rs
@@ -0,0 +1,228 @@
+//! Cross-language parity check: the Rust `WIRE_TABLE` and the TS
+//! `wire-table.ts` must list the exact same `(method, request_id, response_id)`
+//! tuples in the same order. A drift here means a product built against one
+//! side will fail to decode frames produced by the other.
+//!
+//! Both files are auto-generated text artifacts of `truapi-codegen`; the
+//! parser is a small line scanner so the test runs as part of `cargo test`
+//! without any node/bun dependency.
+//!
+//! The TS file lives under `js/packages/truapi/src/generated/wire-table.ts`
+//! and is `.gitignore`d (regenerated by `scripts/codegen.sh`). When the
+//! generated file is absent, the test logs a skip notice and passes, unless
+//! `TRUAPI_REQUIRE_GENERATED_TS=1` is set (CI sets it after running codegen),
+//! in which case the missing file is a hard failure.
+
+use std::path::PathBuf;
+
+const RUST_TABLE: &str = include_str!("../src/generated/wire_table.rs");
+
+#[derive(Debug, PartialEq, Eq)]
+struct Row {
+    method: String,
+    request_or_start: u8,
+    response_or_receive: u8,
+    /// Subscription `_stop` / `_interrupt` ids; `None` for request methods.
+    stop: Option<u8>,
+    interrupt: Option<u8>,
+    is_subscription: bool,
+}
+
+/// Parse a wire id. A malformed id is a hard failure, never a silent `0`: a
+/// defensive fallback here would let a symmetric codegen-format change collapse
+/// both tables to `0`s and pass the parity check while real drift slipped by.
+fn parse_id(raw: &str, method: &str) -> u8 {
+    raw.trim_end_matches(',')
+        .trim()
+        .parse()
+        .unwrap_or_else(|_| panic!("unparseable wire id for `{method}`: {raw:?}"))
+}
+
+fn parse_rust(src: &str) -> Vec<Row> {
+    // The Rust codegen emits one named `pub const FOO_BAR: RequestFrameIds = ...`
+    // (or `SubscriptionFrameIds`) per method. The const name is
+    // `SCREAMING_SNAKE_CASE` of the method name; we lowercase it to match the
+    // TS const names. This mirrors `parse_ts` below.
+    let mut out = Vec::new();
+    let mut iter = src.lines();
+    while let Some(line) = iter.next() {
+        let trimmed = line.trim();
+        let Some(rest) = trimmed.strip_prefix("pub const ") else {
+            continue;
+        };
+        let Some(colon) = rest.find(':') else {
+            continue;
+        };
+        let is_subscription = rest.contains("SubscriptionFrameIds");
+        // Skip non-id consts (e.g. `WIRE_TABLE: &[WireEntry]`).
+        if !is_subscription && !rest.contains("RequestFrameIds") {
+            continue;
+        }
+        let method = rest[..colon].trim().to_ascii_lowercase();
+        let mut request_or_start = None;
+        let mut response_or_receive = None;
+        let mut stop = None;
+        let mut interrupt = None;
+        for inner in iter.by_ref() {
+            let t = inner.trim();
+            if t.starts_with("};") {
+                break;
+            }
+            if let Some(rest) = t
+                .strip_prefix("request_id: ")
+                .or_else(|| t.strip_prefix("start_id: "))
+            {
+                request_or_start = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t
+                .strip_prefix("response_id: ")
+                .or_else(|| t.strip_prefix("receive_id: "))
+            {
+                response_or_receive = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t.strip_prefix("stop_id: ") {
+                stop = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t.strip_prefix("interrupt_id: ") {
+                interrupt = Some(parse_id(rest, &method));
+            }
+        }
+        if let (Some(rs), Some(rr)) = (request_or_start, response_or_receive) {
+            out.push(Row {
+                method,
+                request_or_start: rs,
+                response_or_receive: rr,
+                stop,
+                interrupt,
+                is_subscription,
+            });
+        }
+    }
+    out
+}
+
+fn parse_ts(src: &str) -> Vec<Row> {
+    // The TS codegen emits one named `export const FOO_BAR = { ... }` per
+    // method. The const name is `SCREAMING_SNAKE_CASE` of the method name;
+    // we lowercase it to match the Rust `method:` strings.
+    let mut out = Vec::new();
+    let mut iter = src.lines().peekable();
+    while let Some(line) = iter.next() {
+        let trimmed = line.trim();
+        let Some(rest) = trimmed.strip_prefix("export const ") else {
+            continue;
+        };
+        let Some(name_end) = rest.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) else {
+            continue;
+        };
+        let method = rest[..name_end].to_ascii_lowercase();
+        let mut request_or_start = None;
+        let mut response_or_receive = None;
+        let mut stop = None;
+        let mut interrupt = None;
+        let mut is_subscription = false;
+        for inner in iter.by_ref() {
+            let t = inner.trim();
+            if t.starts_with("start:") || t.contains("SubscriptionFrameIds") {
+                is_subscription = true;
+            }
+            if let Some(rest) = t
+                .strip_prefix("request: ")
+                .or_else(|| t.strip_prefix("start: "))
+            {
+                request_or_start = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t
+                .strip_prefix("response: ")
+                .or_else(|| t.strip_prefix("receive: "))
+            {
+                response_or_receive = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t.strip_prefix("stop: ") {
+                stop = Some(parse_id(rest, &method));
+            }
+            if let Some(rest) = t.strip_prefix("interrupt: ") {
+                interrupt = Some(parse_id(rest, &method));
+            }
+            if t.starts_with("} as const") || t == "}" {
+                if let (Some(rs), Some(rr)) = (request_or_start, response_or_receive) {
+                    out.push(Row {
+                        method,
+                        request_or_start: rs,
+                        response_or_receive: rr,
+                        stop,
+                        interrupt,
+                        is_subscription,
+                    });
+                }
+                break;
+            }
+        }
+    }
+    out
+}
+
+#[test]
+fn rust_and_ts_wire_tables_agree() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let ts_path = manifest
+        .join("../../../js/packages/truapi/src/generated/wire-table.ts")
+        .canonicalize();
+
+    let require_ts = std::env::var("TRUAPI_REQUIRE_GENERATED_TS").as_deref() == Ok("1");
+
+    let ts_path = match ts_path {
+        Ok(p) => p,
+        Err(_) => {
+            assert!(
+                !require_ts,
+                "TRUAPI_REQUIRE_GENERATED_TS=1 but wire-table.ts is missing; run scripts/codegen.sh"
+            );
+            eprintln!(
+                "skipping wire-table parity check: TS wire-table.ts is not present \
+                 (run scripts/codegen.sh to generate it)"
+            );
+            return;
+        }
+    };
+
+    let ts_src = match std::fs::read_to_string(&ts_path) {
+        Ok(s) => s,
+        Err(_) => {
+            assert!(
+                !require_ts,
+                "TRUAPI_REQUIRE_GENERATED_TS=1 but {} is unreadable",
+                ts_path.display()
+            );
+            eprintln!(
+                "skipping wire-table parity check: could not read {}",
+                ts_path.display()
+            );
+            return;
+        }
+    };
+
+    let rust_rows = parse_rust(RUST_TABLE);
+    let ts_rows = parse_ts(&ts_src);
+    // Lower bound pinned to the known table size so a parser/codegen regression
+    // that quietly shrinks both tables in lockstep cannot pass: `assert_eq!`
+    // alone is satisfied by two equal-but-truncated tables.
+    const MIN_EXPECTED_ROWS: usize = 60;
+    assert!(
+        rust_rows.len() >= MIN_EXPECTED_ROWS,
+        "rust parser produced {} entries (expected >= {MIN_EXPECTED_ROWS}); \
+         wire_table.rs format may have changed",
+        rust_rows.len()
+    );
+    assert!(
+        ts_rows.len() >= MIN_EXPECTED_ROWS,
+        "ts parser produced {} entries (expected >= {MIN_EXPECTED_ROWS}); \
+         wire-table.ts format may have changed",
+        ts_rows.len()
+    );
+    assert_eq!(
+        rust_rows, ts_rows,
+        "Rust WIRE_TABLE and TS wire-table.ts diverged. Regenerate both via \
+         `scripts/codegen.sh` so the codegen pipeline produces them in lockstep.",
+    );
+}
diff --git a/rust/crates/truapi/src/api/account.rs b/rust/crates/truapi/src/api/account.rs
index 7c4e065f..ccffa200 100644
--- a/rust/crates/truapi/src/api/account.rs
+++ b/rust/crates/truapi/src/api/account.rs
@@ -17,10 +17,12 @@ pub trait Account: Send + Sync {
     /// Subscribe to account connection status changes.
     ///
     /// ```ts
-    /// import { firstValueFrom, from } from "rxjs";
+    /// import { filter, firstValueFrom, from } from "rxjs";
     ///
     /// const status = await firstValueFrom(
-    ///   from(truapi.account.connectionStatusSubscribe()),
+    ///   from(truapi.account.connectionStatusSubscribe()).pipe(
+    ///     filter((status) => status === "Connected"),
+    ///   ),
     /// );
     /// console.log("connection status:", status);
     /// ```
diff --git a/rust/crates/truapi/src/api/statement_store.rs b/rust/crates/truapi/src/api/statement_store.rs
index 5addc9b7..16cfc8cd 100644
--- a/rust/crates/truapi/src/api/statement_store.rs
+++ b/rust/crates/truapi/src/api/statement_store.rs
@@ -6,7 +6,8 @@ use crate::versioned::statement_store::{
     RemoteStatementStoreCreateProofAuthorizedResponse, RemoteStatementStoreCreateProofError,
     RemoteStatementStoreCreateProofRequest, RemoteStatementStoreCreateProofResponse,
     RemoteStatementStoreSubmitError, RemoteStatementStoreSubmitRequest,
-    RemoteStatementStoreSubscribeItem, RemoteStatementStoreSubscribeRequest,
+    RemoteStatementStoreSubscribeError, RemoteStatementStoreSubscribeItem,
+    RemoteStatementStoreSubscribeRequest,
 };
 use crate::wire;
 use crate::{CallContext, CallError, Subscription};
@@ -56,8 +57,11 @@ pub trait StatementStore: Send + Sync {
         &self,
         _cx: &CallContext,
         _request: RemoteStatementStoreSubscribeRequest,
-    ) -> Subscription<RemoteStatementStoreSubscribeItem> {
-        Subscription::empty()
+    ) -> Result<
+        Subscription<RemoteStatementStoreSubscribeItem>,
+        CallError<RemoteStatementStoreSubscribeError>,
+    > {
+        Err(CallError::unavailable())
     }
 
     /// Create a proof for a statement.
diff --git a/rust/crates/truapi/src/v01/permissions.rs b/rust/crates/truapi/src/v01/permissions.rs
index c4873a6f..a3a88560 100644
--- a/rust/crates/truapi/src/v01/permissions.rs
+++ b/rust/crates/truapi/src/v01/permissions.rs
@@ -53,6 +53,9 @@ pub enum RemotePermission {
     /// Submitting statements on behalf of the user via `remote_statement_store_submit`.
     #[display("submit statements")]
     StatementSubmit,
+    /// Disclosing the user's primary DotNS username.
+    #[display("disclose identity")]
+    UserId,
 }
 
 /// remote-permission request (RFC 0002).
diff --git a/rust/crates/truapi/src/versioned/statement_store.rs b/rust/crates/truapi/src/versioned/statement_store.rs
index 979885ba..ed31d47e 100644
--- a/rust/crates/truapi/src/versioned/statement_store.rs
+++ b/rust/crates/truapi/src/versioned/statement_store.rs
@@ -5,6 +5,7 @@ use crate::v01;
 truapi_macros::versioned_type! {
     pub enum RemoteStatementStoreSubscribeRequest { V1 => v01::RemoteStatementStoreSubscribeRequest }
     pub enum RemoteStatementStoreSubscribeItem { V1 => v01::RemoteStatementStoreSubscribeItem }
+    pub enum RemoteStatementStoreSubscribeError { V1 => v01::GenericError }
     pub enum RemoteStatementStoreCreateProofRequest { V1 => v01::RemoteStatementStoreCreateProofRequest }
     pub enum RemoteStatementStoreCreateProofResponse { V1 => v01::RemoteStatementStoreCreateProofResponse }
     pub enum RemoteStatementStoreCreateProofError { V1 => v01::RemoteStatementStoreCreateProofError }
diff --git a/scripts/codegen.sh b/scripts/codegen.sh
index 8584b0c4..5a4516cc 100755
--- a/scripts/codegen.sh
+++ b/scripts/codegen.sh
@@ -1,13 +1,19 @@
 #!/usr/bin/env bash
-# Regenerate js/packages/truapi/src/generated/* from rust/crates/truapi.
+# Regenerate generated TrUAPI artifacts from rust/crates/truapi plus host
+# callback TypeScript from rust/crates/truapi-platform.
 #
 # Pipeline:
-#   1. cargo +nightly rustdoc -p truapi --output-format json -> target/doc/truapi.json
-#   2. cargo run -p truapi-codegen -- --input target/doc/truapi.json
+#   1. cargo +$RUSTDOC_TOOLCHAIN rustdoc -p truapi --output-format json -> target/doc/truapi.json
+#   2. cargo +$RUSTDOC_TOOLCHAIN rustdoc -p truapi-platform --output-format json -> target/doc/truapi_platform.json
+#   3. cargo run -p truapi-codegen -- --input target/doc/truapi.json
 #                                     --output js/packages/truapi/src/generated
 #                                     --playground-output js/packages/truapi/src/playground
 #                                     --client-examples-output playground/test/generated/examples
 #                                     --host-output js/packages/truapi-host/src/generated
+#                                     --rust-output rust/crates/truapi-server/src/generated
+#                                     --platform-input target/doc/truapi_platform.json
+#                                     --platform-ts-output js/packages/truapi-host-wasm/src/generated
+#                                     --explorer-output js/packages/truapi/src/explorer
 #                                     --codec-version 1
 #
 # The client surface defaults to the latest wire version any versioned
@@ -21,16 +27,52 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$ROOT"
 
-cargo +nightly rustdoc -p truapi -- -Z unstable-options --output-format json
+# rustdoc JSON output requires nightly. `cargo +nightly` is preferred (CI
+# installs a fresh one), but a given day's rolling nightly can be broken on a
+# platform (e.g. an LLVM-init SIGSEGV). Probe for a usable toolchain and fall
+# back to the newest installed dated `nightly-YYYY-MM-DD` that actually runs.
+# Set RUSTDOC_TOOLCHAIN to pin one explicitly and skip the probe.
+toolchain_runs() {
+  rustc "+$1" --crate-name probe --crate-type cdylib --print=file-names - \
+    </dev/null >/dev/null 2>&1
+}
+
+select_rustdoc_toolchain() {
+  if [ -n "${RUSTDOC_TOOLCHAIN:-}" ]; then
+    echo "$RUSTDOC_TOOLCHAIN"
+    return
+  fi
+  local candidate
+  for candidate in nightly $(rustup toolchain list 2>/dev/null \
+    | grep -oE '^nightly-[0-9]{4}-[0-9]{2}-[0-9]{2}' | sort -ru); do
+    if toolchain_runs "$candidate"; then
+      echo "$candidate"
+      return
+    fi
+  done
+  echo "no working nightly toolchain found; install one with \`rustup toolchain install nightly\` or set RUSTDOC_TOOLCHAIN" >&2
+  exit 1
+}
+
+RUSTDOC_TOOLCHAIN="$(select_rustdoc_toolchain)"
+echo "Using rustdoc toolchain: $RUSTDOC_TOOLCHAIN"
+
+cargo "+$RUSTDOC_TOOLCHAIN" rustdoc -p truapi -- -Z unstable-options --output-format json
+cargo "+$RUSTDOC_TOOLCHAIN" rustdoc -p truapi-platform -- -Z unstable-options --output-format json
 cargo run -p truapi-codegen -- \
   --input target/doc/truapi.json \
   --output js/packages/truapi/src/generated \
   --playground-output js/packages/truapi/src/playground \
   --client-examples-output playground/test/generated/examples \
   --host-output js/packages/truapi-host/src/generated \
+  --rust-output rust/crates/truapi-server/src/generated \
+  --platform-input target/doc/truapi_platform.json \
+  --platform-ts-output js/packages/truapi-host-wasm/src/generated \
   --explorer-output js/packages/truapi/src/explorer \
   --codec-version 1
 
+rustfmt --edition 2024 rust/crates/truapi-server/src/generated/*.rs
+
 node scripts/regen-explorer-versions.mjs
 
 npm exec --yes -- prettier --write \
@@ -38,7 +80,8 @@ npm exec --yes -- prettier --write \
   "js/packages/truapi/src/playground/**/*.ts" \
   "js/packages/truapi/src/explorer/**/*.ts" \
   "playground/test/generated/examples/**/*.ts" \
-  "js/packages/truapi-host/src/generated/**/*.ts"
+  "js/packages/truapi-host/src/generated/**/*.ts" \
+  "js/packages/truapi-host-wasm/src/generated/**/*.ts"
 
 # Rebuild dist/ so downstream consumers (in particular the playground,
 # which picks up @parity/truapi via yarn 1.x file: snapshot) see the
@@ -58,9 +101,12 @@ if [ "${TRUAPI_SKIP_PACKAGE_BUILD:-0}" != "1" ]; then
   node scripts/bundle-truapi-dts.mjs
   npm run build --prefix js/packages/truapi
   npm run build --prefix js/packages/truapi-host
+  npm run build --prefix js/packages/truapi-host-wasm
 fi
 
 echo "Generated client at js/packages/truapi/src/generated/"
 echo "Generated playground metadata at js/packages/truapi/src/playground/codegen/"
 echo "Generated client examples at playground/test/generated/examples/"
 echo "Generated host package at js/packages/truapi-host/src/generated/"
+echo "Generated Rust dispatcher at rust/crates/truapi-server/src/generated/"
+echo "Generated host-callbacks at js/packages/truapi-host-wasm/src/generated/"