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/telemetry.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
+import { createDiagnosticsAdapter } from "../../src/adapters/diagnostics/bounded-diagnostics.ts";
 import {
   createTelemetryAdapter,
   safeTraceparent,
@@ -236,4 +237,122 @@ describe("best-effort telemetry adapter", () => {
     expect(adapter.pendingCount()).toBe(0);
     expect(remove).toHaveBeenCalledWith("pagehide", expect.any(Function));
   });
+
+  it("drops queued events and invalidates scheduled callbacks on dispose", async () => {
+    const callbacks: Array<() => void> = [];
+    const fetcher = vi.fn(async () => new Response(null, { status: 204 }));
+    const adapter = createTelemetryAdapter({
+      enabled: true,
+      endpoint: "https://telemetry.test/events",
+      schedule: (callback) => callbacks.push(callback),
+      fetcher,
+    });
+    adapter.emit("api.request.failed", validAttributes);
+    expect(adapter.pendingCount()).toBe(1);
+
+    adapter.dispose();
+    expect(adapter.pendingCount()).toBe(0);
+
+    for (const callback of callbacks) callback();
+    await Promise.resolve();
+    expect(fetcher).not.toHaveBeenCalled();
+    // Disposal is a silent shutdown, not a recursive drop event.
+    expect(adapter.dropReasons()).toEqual({});
+  });
+
+  it("ignores emit after dispose", async () => {
+    const fetcher = vi.fn(async () => new Response(null, { status: 204 }));
+    const adapter = createTelemetryAdapter({
+      enabled: true,
+      endpoint: "https://telemetry.test/events",
+      schedule: () => {},
+      fetcher,
+    });
+    adapter.dispose();
+    adapter.emit("api.request.failed", validAttributes);
+    await adapter.flush();
+
+    expect(adapter.pendingCount()).toBe(0);
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it("aborts an in-flight sink and prevents post-dispose rescheduling", async () => {
+    const callbacks: Array<() => void> = [];
+    let observedSignal: AbortSignal | undefined;
+    let releaseSink: (() => void) | undefined;
+    const fetcher = vi.fn(async (_input: unknown, init?: RequestInit) => {
+      observedSignal = init?.signal ?? undefined;
+      await new Promise<void>((resolve) => {
+        releaseSink = resolve;
+      });
+      return new Response(null, { status: 204 });
+    });
+    const adapter = createTelemetryAdapter({
+      enabled: true,
+      endpoint: "https://telemetry.test/events",
+      schedule: (callback) => callbacks.push(callback),
+      fetcher: fetcher as unknown as typeof fetch,
+    });
+    adapter.emit("api.request.failed", validAttributes);
+    callbacks.splice(0).forEach((callback) => callback());
+    await vi.waitFor(() => expect(fetcher).toHaveBeenCalledOnce());
+
+    adapter.dispose();
+    expect(observedSignal?.aborted).toBe(true);
+
+    // The sink ignored the abort and settles late.
+    releaseSink?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(callbacks).toHaveLength(0);
+    expect(fetcher).toHaveBeenCalledOnce();
+  });
+
+  it("joins an already active flush", async () => {
+    let releaseSink: (() => void) | undefined;
+    const fetcher = vi.fn(async () => {
+      await new Promise<void>((resolve) => {
+        releaseSink = resolve;
+      });
+      return new Response(null, { status: 204 });
+    });
+    const adapter = createTelemetryAdapter({
+      enabled: true,
+      endpoint: "https://telemetry.test/events",
+      schedule: () => {},
+      fetcher: fetcher as unknown as typeof fetch,
+    });
+    adapter.emit("api.request.failed", validAttributes);
+
+    const first = adapter.flush();
+    await vi.waitFor(() => expect(fetcher).toHaveBeenCalledOnce());
+    let secondSettled = false;
+    const second = adapter.flush().then(() => {
+      secondSettled = true;
+    });
+    await Promise.resolve();
+    expect(secondSettled).toBe(false);
+
+    releaseSink?.();
+    await first;
+    await second;
+    expect(secondSettled).toBe(true);
+    adapter.dispose();
+  });
+
+  it.each([Number.NaN, Number.POSITIVE_INFINITY, 0, -1, 1.5])(
+    "rejects invalid telemetry and diagnostics capacity %s",
+    (value) => {
+      expect(() =>
+        createTelemetryAdapter({
+          enabled: true,
+          endpoint: "https://telemetry.test/events",
+          maxQueue: value,
+        }),
+      ).toThrow(TypeError);
+      expect(() => createDiagnosticsAdapter({ maxEntries: value })).toThrow(
+        TypeError,
+      );
+    },
+  );
 });