fix: terminate telemetry work on disposal

Give the best-effort telemetry adapter a terminal ACTIVE/DISPOSED lifecycle.
dispose() now removes the pagehide listener, clears the queue, invalidates
scheduled callback generations and aborts the in-flight sink; emit after
dispose is a no-op and a sink that ignores the abort cannot reschedule or
update post-dispose state. flush() joins the active delivery instead of
resolving early, and runtime infrastructure teardown disposes telemetry first.

Telemetry and diagnostics capacities are validated at construction against a
documented ceiling, so NaN or Infinity can no longer disable eviction.

Co-Authored-By: Claude Opus 5 (1M context) <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,
+      );
+    },
+  );
 });