chore: sync the frontend template from 4dc033c to 8157ad4

The product was materialized from the template at `4dc033c` and has stayed
on it through 43 template commits, so it was missing all three rounds of
adapter remediation — including files it never had, such as the shared
`abortable-operation` primitive and the `exact-snapshot` decoder that
later fixes are written against. Taking only the newest round was not
possible for that reason: the delta is coherent only as a whole.

The product had not touched `src/adapters` at all since materialization,
so the 140-file delta applied with a three-way merge and no conflicts.
`package.json` was the single overlap and merged cleanly: the product owns
`name`, the template contributed `check:adapter-inventory`,
`check:remediation-ledger` and the image-resolve-signal type fixture.
All 24 product-owned files — README, index.html, CI workflow, i18n
catalog, home page, generated schemas, evidence scripts, component and
visual snapshots — are byte-identical to `main`.

`template.lock.json` now pins the synced revision and tree.

Verified in this repository, not inherited from the template: six type
projects, lint, nine gates (adapter inventory, remediation ledger,
registries, diagnostics, realtime boundaries, architecture, browser
file/storage boundaries, optional recipes, documentation), the production
build, and 2,054 of 2,073 tests. The 19 failures are all in
`tests/unit/ci-artifact-contract.test.ts` and are the same pre-existing
sandbox RLIMIT, EMFILE, umask and `/tmp` permission behaviour the template
records; four suites that failed once under parallel load pass in
isolation.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/unit/browser-rpc/browser-rpc-runtime.test.ts

@@ -5,6 +5,7 @@ import {
   createUnavailableBrowserRpcTransport,
   defineBrowserRpcTransport,
   type BrowserRpcObservation,
+  type BrowserRpcServerStreamLease,
   type BrowserRpcStreamFrame,
   type BrowserRpcTransport,
 } from "../../../src/adapters/browser-rpc/index.ts";
@@ -257,8 +258,12 @@ describe("Browser RPC provider-neutral runtime", () => {
             failure: { code: "UNAVAILABLE" },
           };
         },
-        async *openServerStream() {
-          yield Object.freeze({ kind: "TERMINAL", ok: true });
+        openServerStream() {
+          return serverStreamLease(
+            (async function* () {
+              yield Object.freeze({ kind: "TERMINAL" as const, ok: true as const });
+            })(),
+          );
         },
       }),
     ).toThrow("transport is invalid");
@@ -425,11 +430,41 @@ function streamTransport(
     protocol: "CONNECT_HTTP",
     rpcKind: "SERVER_STREAM",
     openServerStream(call) {
-      return source(call.signal);
+      return serverStreamLease(source(call.signal));
     },
   });
 }
 
+/**
+ * RPC-RR-01. Wraps a plain frame sequence in the lease the transport contract
+ * requires. `cancel` resolves `waitClosed`, which is what a cooperative
+ * transport does.
+ */
+let leaseSequence = 0;
+
+function serverStreamLease(
+  frames: AsyncIterable<BrowserRpcStreamFrame>,
+  options: Readonly<{
+    onCancel?: (reason: string) => void;
+    closeOnCancel?: boolean;
+  }> = {},
+): BrowserRpcServerStreamLease {
+  leaseSequence += 1;
+  let release: (() => void) | undefined;
+  const closed = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  return Object.freeze({
+    streamId: `test-stream-${leaseSequence}`,
+    frames,
+    cancel(reason: string) {
+      options.onCancel?.(reason);
+      if (options.closeOnCancel !== false) release?.();
+    },
+    waitClosed: () => closed,
+  });
+}
+
 function message(
   id: string,
   name: string,