diff --git a/js/packages/truapi/package.json b/js/packages/truapi/package.json
index b462528b..6b8e2f61 100644
--- a/js/packages/truapi/package.json
+++ b/js/packages/truapi/package.json
@@ -79,6 +79,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/scale.ts b/js/packages/truapi/src/scale.ts
index ac92039b..f5670ffa 100644
--- a/js/packages/truapi/src/scale.ts
+++ b/js/packages/truapi/src/scale.ts
@@ -8,17 +8,25 @@
 import {
   Bytes,
   Enum,
+  Struct,
+  _void,
   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";
 
 export {
+  Bytes,
   Enum,
   Option,
   Result,
@@ -59,7 +67,9 @@ export const OptionBool: Codec<boolean | undefined> = enhanceCodec(
       case 2:
         return false;
       default:
-        throw new Error(`Unknown OptionBool byte: ${byte}. Expected 0, 1, or 2.`);
+        throw new Error(
+          `Unknown OptionBool byte: ${byte}. Expected 0, 1, or 2.`,
+        );
     }
   },
 );
@@ -79,22 +89,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 +123,51 @@ 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> {
+  type WireCallError =
+    | { tag: "Domain"; value: D }
+    | { tag: "Denied"; value?: undefined }
+    | { tag: "Unsupported"; value?: undefined }
+    | { tag: "MalformedFrame"; value: { reason: string } }
+    | { tag: "HostFailure"; value: { reason: string } };
+
+  const wire = Enum({
+    Domain: domain,
+    Denied: _void,
+    Unsupported: _void,
+    MalformedFrame: Struct({ reason: scaleStr }),
+    HostFailure: Struct({ reason: scaleStr }),
+  }) as unknown as Codec<WireCallError>;
+
+  return enhanceCodec(
+    wire,
+    (value: D): WireCallError => ({ tag: "Domain", value }),
+    (value: WireCallError): D => {
+      switch (value.tag) {
+        case "Domain":
+          return value.value;
+        case "Denied":
+          throw new Error("Host denied the request");
+        case "Unsupported":
+          throw new Error("Host does not support this request");
+        case "MalformedFrame":
+          throw new Error(`Malformed request frame: ${value.value.reason}`);
+        case "HostFailure":
+          throw new Error(`Host failure: ${value.value.reason}`);
+      }
+    },
+  );
+}
+
 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 f2059342..0f9ad4de 100644
--- a/js/packages/truapi/src/transport.ts
+++ b/js/packages/truapi/src/transport.ts
@@ -1,3 +1,4 @@
+import { concatBytes } from "@noble/hashes/utils.js";
 import { err, ok, type Result, type ResultAsync } from "neverthrow";
 
 import { str, u8, type ResultPayload } from "./scale.js";
@@ -279,6 +280,10 @@ export interface WireProvider {
 
   /**
    * 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;
 
@@ -288,21 +293,6 @@ export interface WireProvider {
   dispose(): void;
 }
 
-/**
- * Concatenate byte arrays without mutating the source arrays.
- **/
-function concatBytes(parts: Uint8Array[]): Uint8Array {
-  let total = 0;
-  for (const p of parts) total += p.length;
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const p of parts) {
-    out.set(p, off);
-    off += p.length;
-  }
-  return out;
-}
-
 /**
  * Encode a `ProtocolMessage` into a SCALE wire frame.
  **/
@@ -314,11 +304,7 @@ export function encodeWireMessage(
     return err(new Error(`Invalid wire discriminant: ${id}`));
   }
   return ok(
-    concatBytes([
-      str.enc(message.requestId),
-      u8.enc(id),
-      message.payload.value,
-    ]),
+    concatBytes(str.enc(message.requestId), u8.enc(id), message.payload.value),
   );
 }
 
diff --git a/package-lock.json b/package-lock.json
index d72aab67..51905f9a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,6 +21,7 @@
       "version": "0.3.1",
       "license": "MIT",
       "dependencies": {
+        "@noble/hashes": "^2.2.0",
         "neverthrow": "^8.2.0",
         "scale-ts": "^1.6.1"
       },
@@ -365,6 +366,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",
       "dev": true,
diff --git a/playground/CLAUDE.md b/playground/CLAUDE.md
index a5d6ce72..093e4c60 100644
--- a/playground/CLAUDE.md
+++ b/playground/CLAUDE.md
@@ -7,6 +7,9 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 An interactive explorer for the TrUAPI, the Host API surface exposed to products running inside the Polkadot Desktop Browser webview. The app must be opened from within a Host environment. It talks to the host over iframe `postMessage` frames or the native webview `window.__HOST_API_PORT__` MessagePort.
 
 To develop locally, run `yarn dev` and open the app via `https://dot.li/localhost:3000` inside the Desktop Host.
+For host-backed diagnosis/e2e runs, signer-bot settings may live in the
+repo-root `.env`; if they are not present in the current worktree environment,
+load or copy them from that file before treating signer-bot as unavailable.
 
 ## Commands
 
diff --git a/playground/src/app/page.tsx b/playground/src/app/page.tsx
index 9df8e0be..d8205f86 100644
--- a/playground/src/app/page.tsx
+++ b/playground/src/app/page.tsx
@@ -23,6 +23,7 @@ import {
   runDiagnosis,
   runSingleTest,
 } from "@/src/lib/auto-test";
+import { installE2EHooks } from "@/src/lib/e2e-hooks";
 import packageJson from "../../package.json";
 
 const VERSION_LABEL = `v${packageJson.version}`;
@@ -188,6 +189,7 @@ export default function PlaygroundPage() {
 
   useEffect(() => {
     try {
+      installE2EHooks();
       return subscribeConnectionStatus(setStatus);
     } catch {
       setStatus("disconnected");
diff --git a/playground/src/components/DiagnosisView.tsx b/playground/src/components/DiagnosisView.tsx
index 7cbfa7bf..0200a0b6 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());
     // No-op outside a host container; navigation is best-effort.
@@ -143,7 +147,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>
@@ -151,6 +160,7 @@ export function DiagnosisView({
         {hasResults && (
           <span
             className="autotest__summary"
+            data-testid="diagnosis-summary"
             data-has-fail={!isRunning && failCount > 0}
           >
             {passCount} success · {failCount} failed
@@ -158,9 +168,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"}
@@ -186,6 +204,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 01394802..617072d8 100644
--- a/playground/src/lib/auto-test.ts
+++ b/playground/src/lib/auto-test.ts
@@ -14,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"]);
@@ -32,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;
@@ -59,9 +64,16 @@ 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);
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeout = setTimeout(
+      () => reject(new Error(`timed out after ${timeoutMs / 1000}s`)),
+      timeoutMs,
+    );
+  });
 
   // The example decides pass/fail explicitly: it resolves on success and throws
   // (via `assert(...)` or any uncaught error) on failure. `console.*` is pure
@@ -74,16 +86,11 @@ async function runOne({
         "App must be opened inside a TrUAPI host (iframe or webview).",
       );
     }
-    run = await runExample({ source, client, onLog });
-    await Promise.race([
-      run.promise,
-      new Promise<never>((_, reject) =>
-        setTimeout(
-          () => reject(new Error(`timed out after ${timeoutMs / 1000}s`)),
-          timeoutMs,
-        ),
-      ),
+    run = await Promise.race([
+      runExample({ source, client, onLog }),
+      timeoutPromise,
     ]);
+    await Promise.race([run.promise, timeoutPromise]);
     onUpdate(id, {
       status: "pass",
       request: source,
@@ -98,6 +105,7 @@ async function runOne({
       output: log ? `${log}\n${message}` : message,
     });
   } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
     run?.cancel();
   }
 }
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/e2e-hooks.ts b/playground/src/lib/e2e-hooks.ts
new file mode 100644
index 00000000..22918465
--- /dev/null
+++ b/playground/src/lib/e2e-hooks.ts
@@ -0,0 +1,198 @@
+import type {
+  HostAccountConnectionStatusSubscribeItem,
+  Subscription,
+} from "@parity/truapi";
+import {
+  getClientSync,
+  subscribeConnectionStatus,
+  type ConnectionStatus,
+} from "@parity/truapi/sandbox";
+
+type AccountStatus = HostAccountConnectionStatusSubscribeItem;
+
+type StatusWaiter = {
+  status: AccountStatus;
+  resolve: (statuses: AccountStatus[]) => void;
+  reject: (error: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+};
+
+export interface TruapiPlaygroundE2E {
+  connectionStatus(): ConnectionStatus;
+  waitForConnectionStatus(
+    status: ConnectionStatus,
+    timeoutMs?: number,
+  ): Promise<ConnectionStatus>;
+  startAccountConnectionStatusProbe(): AccountStatus[];
+  accountConnectionStatuses(): AccountStatus[];
+  waitForAccountConnectionStatus(
+    status: AccountStatus,
+    timeoutMs?: number,
+  ): Promise<AccountStatus[]>;
+  stopAccountConnectionStatusProbe(): void;
+}
+
+declare global {
+  interface Window {
+    __truapiPlaygroundE2E?: TruapiPlaygroundE2E;
+    __TRUAPI_PLAYGROUND_E2E__?: boolean;
+  }
+}
+
+let accountStatusSub: Subscription | null = null;
+let accountStatuses: AccountStatus[] = [];
+let hostStatus: ConnectionStatus = "connecting";
+const waiters = new Set<StatusWaiter>();
+
+function e2eEnabled(): boolean {
+  if (window.__TRUAPI_PLAYGROUND_E2E__ === true) return true;
+  if (new URLSearchParams(window.location.search).has("e2e")) return true;
+  try {
+    return window.localStorage.getItem("truapi:playground:e2e") === "1";
+  } catch {
+    return false;
+  }
+}
+
+function stopAccountConnectionStatusProbe(): void {
+  accountStatusSub?.unsubscribe();
+  accountStatusSub = null;
+  for (const waiter of waiters) {
+    clearTimeout(waiter.timer);
+    waiter.reject(new Error("account connection status probe stopped"));
+  }
+  waiters.clear();
+}
+
+function notifyAccountStatus(status: AccountStatus): void {
+  accountStatuses.push(status);
+  for (const waiter of [...waiters]) {
+    if (waiter.status !== status) continue;
+    clearTimeout(waiter.timer);
+    waiters.delete(waiter);
+    waiter.resolve([...accountStatuses]);
+  }
+}
+
+function startAccountConnectionStatusProbe(): AccountStatus[] {
+  stopAccountConnectionStatusProbe();
+  accountStatuses = [];
+  const client = getClientSync();
+  if (!client) {
+    throw new Error("App must be opened inside a TrUAPI host.");
+  }
+  accountStatusSub = client.account.connectionStatusSubscribe().subscribe({
+    next: notifyAccountStatus,
+    error: (error) => {
+      for (const waiter of waiters) {
+        clearTimeout(waiter.timer);
+        waiter.reject(error);
+      }
+      waiters.clear();
+    },
+  });
+  return [...accountStatuses];
+}
+
+function accountConnectionStatuses(): AccountStatus[] {
+  return [...accountStatuses];
+}
+
+function connectionStatus(): ConnectionStatus {
+  return hostStatus;
+}
+
+function waitForConnectionStatus(
+  status: ConnectionStatus,
+  timeoutMs = 30_000,
+): Promise<ConnectionStatus> {
+  if (hostStatus === status) {
+    return Promise.resolve(hostStatus);
+  }
+
+  return new Promise((resolve, reject) => {
+    let done = false;
+    let unsubscribe: (() => void) | null = null;
+    let unsubscribeAfterSubscribe = false;
+    const finish = (
+      next: ConnectionStatus,
+      error?: Error,
+    ): void => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (unsubscribe) {
+        unsubscribe();
+      } else {
+        unsubscribeAfterSubscribe = true;
+      }
+      if (error) {
+        reject(error);
+      } else {
+        resolve(next);
+      }
+    };
+    const timer = setTimeout(() => {
+      finish(
+        hostStatus,
+        new Error(
+          `timed out waiting for host connection status ${status}; current status is ${hostStatus}`,
+        ),
+      );
+    }, timeoutMs);
+
+    try {
+      unsubscribe = subscribeConnectionStatus((next) => {
+        hostStatus = next;
+        if (next === status) {
+          finish(next);
+        }
+      });
+      if (unsubscribeAfterSubscribe) {
+        unsubscribe();
+      }
+    } catch (error) {
+      finish(
+        hostStatus,
+        error instanceof Error ? error : new Error(String(error)),
+      );
+    }
+  });
+}
+
+function waitForAccountConnectionStatus(
+  status: AccountStatus,
+  timeoutMs = 30_000,
+): Promise<AccountStatus[]> {
+  if (accountStatuses.includes(status)) {
+    return Promise.resolve([...accountStatuses]);
+  }
+  return new Promise((resolve, reject) => {
+    const waiter: StatusWaiter = {
+      status,
+      resolve,
+      reject,
+      timer: setTimeout(() => {
+        waiters.delete(waiter);
+        reject(
+          new Error(
+            `timed out waiting for account connection status ${status}; saw ${accountStatuses.join(", ")}`,
+          ),
+        );
+      }, timeoutMs),
+    };
+    waiters.add(waiter);
+  });
+}
+
+export function installE2EHooks(): void {
+  if (!e2eEnabled()) return;
+  window.__truapiPlaygroundE2E = {
+    connectionStatus,
+    waitForConnectionStatus,
+    startAccountConnectionStatusProbe,
+    accountConnectionStatuses,
+    waitForAccountConnectionStatus,
+    stopAccountConnectionStatusProbe,
+  };
+}
diff --git a/playground/src/lib/example-runner.ts b/playground/src/lib/example-runner.ts
index d37e85e3..97cf72df 100644
--- a/playground/src/lib/example-runner.ts
+++ b/playground/src/lib/example-runner.ts
@@ -82,11 +82,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/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/playground/yarn.lock b/playground/yarn.lock
index 138352bb..a485b3d9 100644
--- a/playground/yarn.lock
+++ b/playground/yarn.lock
@@ -376,6 +376,11 @@
   resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.8.0.tgz#cee43d801fcef9644b11b8194857695acd5f815a"
   integrity sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==
 
+"@noble/hashes@^2.2.0":
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-2.2.0.tgz#22da1d16a469954fce877055d559900a6c73b63b"
+  integrity sha512-IYqDGiTXab6FniAgnSdZwgWbomxpy9FtYvLKs7wCUs2a8RkITG+DFGO1DM9cr+E3/RgADRpFjrKVaJ1z6sjtEg==
+
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
   resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"