@spotify-confidence/csr-common 0.0.0 → 0.17.3

package/src/uploader/create-uploader.ts

@@ -0,0 +1,309 @@
+import type { CreateUploaderOptions, Frame, Uploader } from './types';
+import { ClientContext, collectUserAgentContext } from './client-context';
+import { workerScript } from './worker/worker-script';
+
+const STORAGE_TAB_ID = 'csr:tabId';
+const STORAGE_SESSION = 'csr:session';
+const STORAGE_COUNTER = 'csr:counter';
+const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
+
+interface PortLike {
+  postMessage(m: unknown): void;
+  setHandler(cb: (data: unknown) => void): void;
+}
+
+interface WelcomeMessage {
+  type: 'welcome';
+  result: { sessionId: string; sessionToken: string } | { skipRecording: true };
+  adoptedFromSessionId?: string;
+  /** Worker-assigned fresh tabId because this tab is a duplicate of another live one. */
+  newTabId?: string;
+  resetCounter?: boolean;
+}
+interface DeadMessage {
+  type: 'dead';
+  reason: string;
+}
+interface StateMessage {
+  type: 'state';
+  connected: boolean;
+}
+interface LogMessage {
+  type: 'log';
+  msg: string;
+}
+type WelcomeOrDead = WelcomeMessage | DeadMessage;
+type IncomingMessage = WelcomeMessage | DeadMessage | StateMessage | LogMessage;
+
+export async function createUploader(opts: CreateUploaderOptions): Promise<Uploader | null> {
+  const log = opts.debugLogger;
+  const sessionTtlMs = opts.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS;
+  const tabId = readOrMintTabId();
+  const sessionHint = readSessionHint(sessionTtlMs);
+  const counterHint = readCounter();
+  const mode = resolveMode(opts.workerMode ?? 'auto');
+
+  log?.(
+    `tab: createUploader mode=${mode} tabId=${tabId} sessionHint=${
+      sessionHint?.id ?? '(none)'
+    } counterHint=${counterHint}`,
+  );
+
+  const port = await openWorkerPort(mode, opts.clientSecret, opts.workerUrl);
+
+  // State accessible to both the message handler (for post-welcome state/dead messages)
+  // and the post-welcome setup code below. Mutable so welcome can populate them.
+  let phase: 'awaiting-welcome' | 'active' | 'dead' = 'awaiting-welcome';
+  let sessionId: string | null = null;
+  let sessionToken: string | null = null;
+  let effectiveTabId: string = tabId;
+  let resolveWelcome!: (msg: WelcomeOrDead) => void;
+  const welcomePromise = new Promise<WelcomeOrDead>(res => {
+    resolveWelcome = res;
+  });
+
+  port.setHandler(data => {
+    const msg = data as IncomingMessage;
+    if (msg.type === 'log') {
+      log?.(`worker: ${msg.msg}`);
+      return;
+    }
+    if (phase === 'awaiting-welcome') {
+      if (msg.type === 'welcome' || msg.type === 'dead') {
+        phase = msg.type === 'welcome' ? 'active' : 'dead';
+        resolveWelcome(msg);
+      }
+      return;
+    }
+    if (msg.type === 'state' && sessionId !== null) {
+      opts.onStateChange?.({
+        sessionId,
+        tabId: effectiveTabId,
+        connected: msg.connected,
+        sessionToken,
+      });
+      return;
+    }
+    if (msg.type === 'dead') {
+      phase = 'dead';
+      if (sessionId !== null) {
+        opts.onStateChange?.({
+          sessionId,
+          tabId: effectiveTabId,
+          connected: false,
+          sessionToken,
+        });
+      }
+      opts.onTerminate?.({ reason: msg.reason });
+    }
+  });
+
+  const autoUA = collectUserAgentContext();
+  const context: ClientContext = {
+    ...(autoUA ? { userAgent: autoUA } : {}),
+    ...(opts.context ?? {}),
+  };
+
+  port.postMessage({
+    type: 'hello',
+    apiUrl: opts.apiUrl,
+    websocketUrl: opts.websocketUrl,
+    clientSecret: opts.clientSecret,
+    targetingKey: opts.targetingKey,
+    context,
+    forceRecord: opts.forceRecord,
+    sessionIdHint: sessionHint?.id,
+    sessionTokenHint: sessionHint?.token,
+    tabId,
+    debugLogs: log !== undefined,
+  });
+  log?.('tab: hello sent, awaiting welcome');
+
+  const welcome = await welcomePromise;
+  log?.(
+    welcome.type === 'welcome'
+      ? `tab: welcome (${'sessionId' in welcome.result ? `sessionId=${welcome.result.sessionId}` : 'skipRecording'})`
+      : `tab: dead reason=${welcome.reason}`,
+  );
+  if (welcome.type === 'dead') {
+    // Worker died before establishing a session — surface the reason instead of swallowing it as `null`.
+    throw new Error(`uploader: ${welcome.reason}`);
+  }
+  if ('skipRecording' in welcome.result) {
+    if (opts.forceRecord) {
+      log?.('tab: forceRecord was set but backend still skipped — backend may not support forceRecord yet');
+    }
+    return null;
+  }
+
+  sessionId = welcome.result.sessionId;
+  sessionToken = welcome.result.sessionToken;
+  writeSession(welcome.result.sessionId, welcome.result.sessionToken);
+
+  // If the worker minted a fresh tabId (we're a duplicate of another live tab), adopt it.
+  if (welcome.newTabId !== undefined) {
+    effectiveTabId = welcome.newTabId;
+    sessionStorage.setItem(STORAGE_TAB_ID, effectiveTabId);
+  }
+
+  let counter = welcome.resetCounter ? 0 : counterHint;
+  let nextAdoptionMeta: Pick<Frame, 'adoptedFromSessionId' | 'adoptedAt'> | undefined =
+    welcome.adoptedFromSessionId !== undefined
+      ? {
+          adoptedFromSessionId: welcome.adoptedFromSessionId,
+          adoptedAt: Date.now(),
+        }
+      : undefined;
+
+  opts.onStateChange?.({
+    sessionId,
+    tabId: effectiveTabId,
+    connected: true,
+    sessionToken,
+  });
+
+  // Persist counter on pagehide; visibilitychange→hidden as a backup for mobile/BFCache.
+  const flush = () => {
+    writeCounter(counter);
+  };
+  window.addEventListener('pagehide', () => {
+    flush();
+    try {
+      port.postMessage({ type: 'bye', reason: 'pagehide' });
+    } catch (_e) {
+      // ignore
+    }
+  });
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') flush();
+  });
+
+  const uploader = ((event: unknown) => {
+    if (phase === 'dead') {
+      throw new Error('uploader: terminated');
+    }
+    const frame: Frame = {
+      tabId: effectiveTabId,
+      eventCounter: counter,
+      data: event,
+      ...(nextAdoptionMeta ?? {}),
+    };
+    counter += 1;
+    nextAdoptionMeta = undefined;
+    port.postMessage({ type: 'frame', frame });
+  }) as Uploader;
+
+  uploader.close = () => {
+    flush();
+    try {
+      port.postMessage({ type: 'bye', reason: 'stop' });
+    } catch (_e) {
+      // ignore
+    }
+  };
+
+  return uploader;
+}
+
+function resolveMode(mode: 'shared' | 'dedicated' | 'auto'): 'shared' | 'dedicated' {
+  if (mode === 'auto') {
+    return typeof SharedWorker !== 'undefined' ? 'shared' : 'dedicated';
+  }
+  return mode;
+}
+
+async function openWorkerPort(
+  mode: 'shared' | 'dedicated',
+  clientSecret: string,
+  workerUrl: string | undefined,
+): Promise<PortLike> {
+  // Default to a content-derived data URL: identical across tabs (so SharedWorker
+  // sharing works) and self-contained (no infrastructure for SDK consumers).
+  const url = workerUrl ?? toDataUrl(workerScript);
+
+  if (mode === 'shared') {
+    const name = await hashSecret(clientSecret);
+    // `extendedLifetime` keeps the SharedWorker alive across top-level navigations on
+    // Chrome 139+. No-op everywhere else. Cast required because the option isn't in the
+    // standard SharedWorker type yet.
+    const options = {
+      name,
+      type: 'module',
+      extendedLifetime: true,
+    } as WorkerOptions;
+    const worker = new SharedWorker(url, options);
+    worker.port.start();
+    return {
+      postMessage: m => worker.port.postMessage(m),
+      setHandler: cb => {
+        worker.port.onmessage = (e: MessageEvent) => cb(e.data);
+      },
+    };
+  }
+
+  const worker = new Worker(url, { type: 'module' });
+  return {
+    postMessage: m => worker.postMessage(m),
+    setHandler: cb => {
+      worker.onmessage = (e: MessageEvent) => cb(e.data);
+    },
+  };
+}
+
+function toDataUrl(script: string): string {
+  // UTF-8-safe base64. The worker bundle is ASCII today but esbuild may emit non-ASCII
+  // identifiers if the source ever contains them; this avoids `btoa` choking.
+  const bytes = new TextEncoder().encode(script);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return `data:application/javascript;base64,${btoa(binary)}`;
+}
+
+async function hashSecret(secret: string): Promise<string> {
+  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(secret));
+  return Array.from(new Uint8Array(buf))
+    .slice(0, 8)
+    .map(b => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+function readOrMintTabId(): string {
+  let id = sessionStorage.getItem(STORAGE_TAB_ID);
+  if (!id) {
+    id = crypto.randomUUID();
+    sessionStorage.setItem(STORAGE_TAB_ID, id);
+  }
+  return id;
+}
+
+function readSessionHint(ttlMs: number): { id: string; token: string } | null {
+  const raw = sessionStorage.getItem(STORAGE_SESSION);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as {
+      id: string;
+      token?: string;
+      ts: number;
+    };
+    if (Date.now() - parsed.ts > ttlMs) return null;
+    if (!parsed.token) return null;
+    return { id: parsed.id, token: parsed.token };
+  } catch (_e) {
+    return null;
+  }
+}
+
+function writeSession(sessionId: string, sessionToken: string): void {
+  sessionStorage.setItem(STORAGE_SESSION, JSON.stringify({ id: sessionId, token: sessionToken, ts: Date.now() }));
+}
+
+function readCounter(): number {
+  const raw = sessionStorage.getItem(STORAGE_COUNTER);
+  if (!raw) return 0;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function writeCounter(counter: number): void {
+  sessionStorage.setItem(STORAGE_COUNTER, String(counter));
+}

package/src/uploader/index.ts

@@ -0,0 +1,15 @@
+export { createUploader } from './create-uploader';
+export { type Uploader, type CreateUploaderOptions } from './types';
+export {
+  collectUserAgentContext,
+  type ClientContext,
+  type UserAgentContext,
+  type ContextValue,
+} from './client-context';
+
+/**
+ * Bundled worker source. Re-exported so consumers can serve it at a stable same-origin
+ * URL and pass that URL via `createUploader({ workerUrl })` — required for cross-tab
+ * SharedWorker sharing (per-document blob URLs defeat sharing).
+ */
+export { workerScript } from './worker/worker-script';

package/src/uploader/types.ts

@@ -0,0 +1,101 @@
+import type { ClientContext } from './client-context';
+
+export interface Uploader {
+  (event: unknown): void;
+  close(): void;
+}
+
+export interface CreateUploaderOptions {
+  /** Base URL of the recording backend (serves `/v1/sessions:initSession` and, by default, the WS ingest endpoint). */
+  apiUrl: string;
+  /**
+   * URL of the WebSocket ingest endpoint, including the path (e.g.
+   * `wss://recording-ws.confidence.dev/sessions/stream`) but **without** any query —
+   * the worker appends `?session_token=…`. Optional: when omitted the worker derives
+   * one from `apiUrl` by swapping `http(s)://` → `ws(s)://` and appending
+   * `/sessions/stream`. Set this when the init endpoint and the WS ingest live on
+   * different hosts (e.g. prod).
+   */
+  websocketUrl?: string;
+  /** Per-tenant secret. Hashed to scope the SharedWorker so different secrets never share a session, and sent in the `initSession` request body. */
+  clientSecret: string;
+  /** End-user identifier (visitor / device ID). Forwarded in the `initSession` body for sampling and eligibility. */
+  targetingKey?: string;
+  /**
+   * Session context sent in the InitSession request. The SDK auto-populates
+   * `userAgent` with browser/OS/screen metadata. Pass any extra keys as
+   * custom dimensions.
+   */
+  context?: ClientContext;
+  /** Force a worker mode for testing. Default `"auto"`. */
+  workerMode?: 'shared' | 'dedicated' | 'auto';
+  /**
+   * Optional override for the worker script URL. By default the bundled worker is loaded
+   * from a `data:` URL — self-contained, no infrastructure setup, works across tabs
+   * (`SharedWorker` is keyed by `(scriptURL, name)` and identical content yields identical
+   * data: URLs). Provide this only if your `worker-src` CSP forbids `data:`; you can serve
+   * the bundled worker yourself by re-exporting `workerScript` from
+   * `csr-common/uploader` and pointing `workerUrl` at the route.
+   */
+  workerUrl?: string;
+  /** Force recording regardless of backend sampling and targeting rules. Included in the `initSession` request body. */
+  forceRecord?: boolean;
+  /** Tab-side hint expiry; cached `sessionId`s older than this are discarded on init. */
+  sessionTtlMs?: number;
+  onStateChange?: (state: {
+    sessionId: string | null;
+    tabId: string | null;
+    connected: boolean;
+    /**
+     * Token issued by `initSession`. Null until the session is established.
+     * Most consumers should ignore this; it's exposed for tooling that needs
+     * to call session-lifecycle endpoints directly (e.g. `closeSession`).
+     */
+    sessionToken: string | null;
+  }) => void;
+  /** Called once when recording is permanently dead. SDK should dismantle the recorder. */
+  onTerminate?: (info: { reason: string }) => void;
+  /**
+   * Optional verbose tracer. Called on key tab- and worker-side events
+   * (hello/welcome, init-session URL, ws connect URL, retries, transitions).
+   * Worker messages are forwarded over the port and tagged so you can tell them apart.
+   */
+  debugLogger?: (msg: string) => void;
+}
+
+// --- Internal types: used across the worker / tab pieces, not part of the public API. ---
+
+/** Internal: backend-protocol adapter inside the worker bundle. */
+export interface Client {
+  initSession(): Promise<{ sessionId: string; sessionToken: string } | { skipRecording: true }>;
+  /** Opens the data-plane connection. Rejects if `sessionToken` is stale/closed. */
+  openTransport(sessionToken: string): Promise<Transport>;
+}
+
+/**
+ * Internal: one backend-protocol connection. Owns its own retry/reconnect policy.
+ * `onClose` fires only when delivery is permanently impossible.
+ * `onStateChange` fires when the underlying connection flaps — e.g. a graceful drain
+ * triggers reconnect (`connected: false` then `connected: true` once reconnected).
+ * Used to surface mid-session state to consumers wiring `onStateChange` for debugging /
+ * tests; production consumers typically only care about `onTerminate` (driven by `onClose`).
+ */
+export interface Transport {
+  send(frame: Frame): void;
+  close(reason?: string): void;
+  onClose(cb: (info: { reason: string }) => void): void;
+  onStateChange(cb: (info: { connected: boolean }) => void): void;
+}
+
+/** Internal: wire-level frame. Session-id is implicit (Transport is session-bound at open). */
+export interface Frame {
+  tabId: string;
+  /** Monotonic, 0-based per Recording. Resets on adoption. */
+  eventCounter: number;
+  /** Opaque payload from the recorder. */
+  data: unknown;
+  /** Set only on the first frame emitted after the tab was adopted into a different session. */
+  adoptedFromSessionId?: string;
+  /** Epoch millis of the adoption event. */
+  adoptedAt?: number;
+}

package/src/uploader/worker/core.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createMockPort, installMockFetch, installMockWsServer, jsonResponse } from '../../test-utils';
+
+const API_URL = 'https://api.example';
+const WS_URL = 'wss://api.example/sessions/stream?session_token=tok-1';
+
+async function loadCore() {
+  vi.resetModules();
+  // .js extension is required by Node16 module resolution for dynamic imports
+  // (static `import` lines work without it because the package is CJS — see package.json).
+  // eslint-disable-next-line es/no-dynamic-import
+  return await import('./core.js');
+}
+
+function helloMessage(overrides: Record<string, unknown> = {}) {
+  return {
+    type: 'hello' as const,
+    apiUrl: API_URL,
+    clientSecret: 'secret',
+    tabId: 'tab-A',
+    ...overrides,
+  };
+}
+
+const isType = (type: string) => (m: unknown) => (m as { type: string }).type === type;
+
+interface WelcomeMessage {
+  type: 'welcome';
+  result: { sessionId: string; sessionToken: string } | { skipRecording: true };
+  newTabId?: string;
+  resetCounter?: boolean;
+  adoptedFromSessionId?: string;
+}
+interface DeadMessage {
+  type: 'dead';
+  reason: string;
+}
+
+describe('worker/core', () => {
+  function setupBackend(initBody: unknown = { sessionId: 'sess-1', sessionToken: 'tok-1' }) {
+    const fetchHarness = installMockFetch(() => jsonResponse(initBody));
+    const wsHarness = installMockWsServer(WS_URL);
+    return { fetchHarness, wsHarness };
+  }
+
+  describe('first hello', () => {
+    it('runs initSession + openTransport, then sends welcome', async () => {
+      const { fetchHarness } = setupBackend();
+      const { registerPort } = await loadCore();
+      const port = createMockPort();
+      registerPort(port.adapter);
+
+      port.tabSends(helloMessage());
+      const welcome = await port.next<WelcomeMessage>(isType('welcome'));
+
+      expect(fetchHarness.calls).toHaveLength(1);
+      expect(fetchHarness.calls[0].url).toBe(`${API_URL}/v1/sessions:initSession`);
+      expect(welcome.result).toEqual({
+        sessionId: 'sess-1',
+        sessionToken: 'tok-1',
+      });
+    });
+
+    it('replies with skipRecording when the backend opts out', async () => {
+      setupBackend({ skipRecording: true });
+      const { registerPort } = await loadCore();
+      const port = createMockPort();
+      registerPort(port.adapter);
+
+      port.tabSends(helloMessage());
+      const welcome = await port.next<WelcomeMessage>(isType('welcome'));
+
+      expect(welcome.result).toEqual({ skipRecording: true });
+    });
+
+    it('transitions to dead when initSession throws', async () => {
+      installMockFetch(() => new Response(null, { status: 500 }));
+
+      const { registerPort } = await loadCore();
+      const port = createMockPort();
+      registerPort(port.adapter);
+
+      port.tabSends(helloMessage());
+      const dead = await port.next<DeadMessage>(isType('dead'));
+
+      expect(dead.reason).toMatch(/init-session-failed/);
+    });
+  });
+
+  describe('multiple ports', () => {
+    it('queues a second hello during initialization and welcomes it after', async () => {
+      setupBackend();
+      const { registerPort } = await loadCore();
+
+      const portA = createMockPort();
+      const portB = createMockPort();
+      registerPort(portA.adapter);
+      registerPort(portB.adapter);
+
+      // Both ports race in before the worker has finished init.
+      portA.tabSends(helloMessage({ tabId: 'tab-A' }));
+      portB.tabSends(helloMessage({ tabId: 'tab-B' }));
+
+      const [aWelcome, bWelcome] = await Promise.all([
+        portA.next<WelcomeMessage>(isType('welcome')),
+        portB.next<WelcomeMessage>(isType('welcome')),
+      ]);
+      expect(aWelcome.result).toEqual({
+        sessionId: 'sess-1',
+        sessionToken: 'tok-1',
+      });
+      expect(bWelcome.result).toEqual({
+        sessionId: 'sess-1',
+        sessionToken: 'tok-1',
+      });
+    });
+
+    it('rejects a second hello with a different clientSecret', async () => {
+      setupBackend();
+      const { registerPort } = await loadCore();
+
+      const portA = createMockPort();
+      const portB = createMockPort();
+      registerPort(portA.adapter);
+      registerPort(portB.adapter);
+
+      portA.tabSends(helloMessage());
+      await portA.next<WelcomeMessage>(isType('welcome'));
+
+      portB.tabSends(helloMessage({ clientSecret: 'different-secret', tabId: 'tab-B' }));
+      const dead = await portB.next<DeadMessage>(isType('dead'));
+
+      expect(dead.reason).toMatch(/incompatible-options/);
+    });
+
+    it('mints a fresh tabId when a duplicate tab connects', async () => {
+      setupBackend();
+      const { registerPort } = await loadCore();
+
+      const portA = createMockPort();
+      const portB = createMockPort();
+      registerPort(portA.adapter);
+      registerPort(portB.adapter);
+
+      portA.tabSends(helloMessage({ tabId: 'shared-tab' }));
+      await portA.next<WelcomeMessage>(isType('welcome'));
+      portB.tabSends(helloMessage({ tabId: 'shared-tab' }));
+      const bWelcome = await portB.next<WelcomeMessage>(isType('welcome'));
+
+      expect(bWelcome.newTabId).toBeDefined();
+      expect(bWelcome.newTabId).not.toBe('shared-tab');
+      expect(bWelcome.resetCounter).toBe(true);
+    });
+  });
+
+  describe('frame routing', () => {
+    it('forwards frames over the open transport once active', async () => {
+      const { wsHarness } = setupBackend();
+      const { registerPort } = await loadCore();
+      const port = createMockPort();
+      registerPort(port.adapter);
+
+      port.tabSends(helloMessage());
+      await port.next<WelcomeMessage>(isType('welcome'));
+
+      port.tabSends({
+        type: 'frame',
+        frame: { tabId: 'tab-A', eventCounter: 0, data: { kind: 'click' } },
+      });
+
+      expect(JSON.parse(await wsHarness.nextMessage())).toEqual({
+        tabId: 'tab-A',
+        eventCounter: 0,
+        data: { kind: 'click' },
+      });
+    });
+
+    it('drops frames received before the worker is active', async () => {
+      const { wsHarness } = setupBackend();
+      const { registerPort } = await loadCore();
+      const port = createMockPort();
+      registerPort(port.adapter);
+
+      // Send a frame before hello — phase is still 'init'. Should be silently dropped.
+      port.tabSends({
+        type: 'frame',
+        frame: { tabId: 'tab-A', eventCounter: 0, data: 'too-early' },
+      });
+
+      // Hello + welcome opens the transport. If the early frame had leaked it'd be
+      // buffered in the transport's pending queue and flushed first on open.
+      port.tabSends(helloMessage());
+      await port.next<WelcomeMessage>(isType('welcome'));
+
+      // Send a real frame and assert it's the *first* message the server sees —
+      // the early one would have been ahead of it in the queue had it leaked.
+      port.tabSends({
+        type: 'frame',
+        frame: { tabId: 'tab-A', eventCounter: 0, data: 'real' },
+      });
+      const message = await wsHarness.nextMessage();
+      expect(JSON.parse(message).data).toBe('real');
+    });
+  });
+
+  describe('debug log forwarding', () => {
+    it('only forwards log messages to ports that opted in', async () => {
+      setupBackend();
+      const { registerPort } = await loadCore();
+
+      const debug = createMockPort();
+      const quiet = createMockPort();
+      registerPort(debug.adapter);
+      registerPort(quiet.adapter);
+
+      debug.tabSends(helloMessage({ debugLogs: true }));
+      quiet.tabSends(helloMessage({ tabId: 'tab-B', debugLogs: false }));
+
+      // Both ports get welcome — wait for that as the synchronization point.
+      await Promise.all([debug.next<WelcomeMessage>(isType('welcome')), quiet.next<WelcomeMessage>(isType('welcome'))]);
+
+      expect(debug.received.some(isType('log'))).toBe(true);
+      expect(quiet.received.some(isType('log'))).toBe(false);
+    });
+  });
+
+  describe('lifecycle after active', () => {
+    it('broadcasts dead to all ports when the transport closes abruptly', async () => {
+      const { wsHarness } = setupBackend();
+      const { registerPort } = await loadCore();
+
+      const portA = createMockPort();
+      const portB = createMockPort();
+      registerPort(portA.adapter);
+      registerPort(portB.adapter);
+
+      portA.tabSends(helloMessage());
+      portB.tabSends(helloMessage({ tabId: 'tab-B' }));
+      await Promise.all([portA.next<WelcomeMessage>(isType('welcome')), portB.next<WelcomeMessage>(isType('welcome'))]);
+
+      const ws = await wsHarness.waitForConnection();
+      ws.close({ code: 1011, reason: 'server crash', wasClean: false });
+
+      await Promise.all([portA.next<DeadMessage>(isType('dead')), portB.next<DeadMessage>(isType('dead'))]);
+    });
+  });
+});