@spotify-confidence/csr-common 0.0.0 → 0.17.2

package/src/uploader/worker/web-socket-transport.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it, vi } from 'vitest';
+import { installMockWsServer } from '../../test-utils';
+import { WebSocketTransport } from './web-socket-transport';
+
+const URL = 'ws://localhost:1234/sessions/stream?session_token=abc';
+
+describe('WebSocketTransport', () => {
+  const setup = () => installMockWsServer(URL);
+
+  it('resolves ready() once the server accepts the connection', async () => {
+    setup();
+    const t = new WebSocketTransport(URL);
+    await expect(t.ready()).resolves.toBeUndefined();
+  });
+
+  it('rejects ready() when no server is reachable', async () => {
+    // Decoy server patches global WebSocket without registering one at URL — mock-socket
+    // fires close(1000) synchronously instead of leaning on the OS to refuse the connect.
+    installMockWsServer('ws://localhost:9999/decoy');
+    const t = new WebSocketTransport(URL);
+    await expect(t.ready()).rejects.toThrow(/initial-failed/);
+  });
+
+  it('sends frames as JSON once open', async () => {
+    const { nextMessage } = setup();
+    const t = new WebSocketTransport(URL);
+    await t.ready();
+
+    t.send({ tabId: 'tab-1', eventCounter: 0, data: { hello: 'world' } });
+
+    expect(JSON.parse(await nextMessage())).toEqual({
+      tabId: 'tab-1',
+      eventCounter: 0,
+      data: { hello: 'world' },
+    });
+  });
+
+  it('buffers frames sent before open and flushes them on connect', async () => {
+    const { nextMessages } = setup();
+    const t = new WebSocketTransport(URL);
+    // Synchronously enqueue before the open event fires.
+    t.send({ tabId: 'a', eventCounter: 0, data: 1 });
+    t.send({ tabId: 'a', eventCounter: 1, data: 2 });
+    await t.ready();
+
+    const [first, second] = await nextMessages(2);
+    expect([JSON.parse(first).eventCounter, JSON.parse(second).eventCounter]).toEqual([0, 1]);
+  });
+
+  it('reconnects on a graceful drain (code 1000) and emits state changes', async () => {
+    const { waitForConnection } = setup();
+    const t = new WebSocketTransport(URL);
+    const states: boolean[] = [];
+    t.onStateChange(({ connected }) => states.push(connected));
+    await t.ready();
+
+    const first = await waitForConnection();
+    first.close({ code: 1000, reason: 'drain', wasClean: true });
+    await waitForConnection(); // reconnect lands
+
+    // First open → no state event (welcome implies connected).
+    // Drain → state(false). Reconnect open → state(true).
+    await vi.waitFor(() => expect(states).toEqual([false, true]));
+  });
+
+  it('fires onClose with reason on abrupt close after open', async () => {
+    const { waitForConnection } = setup();
+    const t = new WebSocketTransport(URL);
+    const closeReasons: string[] = [];
+    t.onClose(({ reason }) => closeReasons.push(reason));
+    await t.ready();
+
+    const ws = await waitForConnection();
+    ws.close({ code: 1011, reason: 'server crash', wasClean: false });
+
+    await vi.waitFor(() => expect(closeReasons).toHaveLength(1));
+    expect(closeReasons[0]).toMatch(/code=1011/);
+  });
+
+  it('drops sends after close()', async () => {
+    const { messages, nextMessage } = setup();
+    const t = new WebSocketTransport(URL);
+    await t.ready();
+
+    // Send a frame before close — should arrive. Use it as a synchronization
+    // point so we know the server has caught up; anything after close() that
+    // had leaked through would already be in `messages` too.
+    t.send({ tabId: 'a', eventCounter: 0, data: 'before' });
+    await nextMessage();
+
+    t.close('test-shutdown');
+    t.send({ tabId: 'a', eventCounter: 99, data: 'after' });
+
+    // Send another marker on a *fresh* transport to the same server. Once it
+    // arrives, the closed transport's bad send (if it had leaked) would have
+    // landed first — assert by counting.
+    const t2 = new WebSocketTransport(URL);
+    await t2.ready();
+    t2.send({ tabId: 'b', eventCounter: 0, data: 'marker' });
+    await vi.waitFor(() => expect(messages).toHaveLength(2));
+    expect(messages.map(m => JSON.parse(m).data)).toEqual(['before', 'marker']);
+  });
+});

package/src/uploader/worker/web-socket-transport.ts

@@ -0,0 +1,113 @@
+import type { Frame, Transport } from '../types';
+
+/**
+ * WebSocket-backed Transport. Internal retry policy: clean server-initiated close after the
+ * first successful open → reconnect and resume; abrupt close (or any close before the first
+ * open) → fire `onClose` and stop. Frames received while a (re)connect is in progress are
+ * buffered and flushed on open.
+ *
+ * `ready()` resolves on the first successful open and rejects on close-before-open. Callers
+ * should await it before treating the Transport as live, so a failure to open can be caught
+ * (e.g. 4404 unknown session) and recovered from.
+ */
+export class WebSocketTransport implements Transport {
+  private ws: WebSocket | null = null;
+  private onCloseCb: ((info: { reason: string }) => void) | null = null;
+  private onStateChangeCb: ((info: { connected: boolean }) => void) | null = null;
+  private intentionallyClosed = false;
+  private dead = false;
+  /** Frames buffered while a (re)connect is in progress. */
+  private pending: Frame[] = [];
+  private readyPromise: Promise<void>;
+
+  constructor(private readonly url: string) {
+    this.readyPromise = new Promise<void>((resolve, reject) => {
+      this.connect(false, resolve, reject);
+    });
+    // Always attach a noop catch so an unawaited failure doesn't surface as an unhandled
+    // rejection; callers that care will await `ready()` themselves.
+    this.readyPromise.catch(() => {});
+  }
+
+  ready(): Promise<void> {
+    return this.readyPromise;
+  }
+
+  send(frame: Frame): void {
+    if (this.dead || this.intentionallyClosed) return;
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(frame));
+    } else {
+      this.pending.push(frame);
+    }
+  }
+
+  close(reason = 'transport-close'): void {
+    this.intentionallyClosed = true;
+    this.ws?.close(1000, reason);
+  }
+
+  onClose(cb: (info: { reason: string }) => void): void {
+    this.onCloseCb = cb;
+  }
+
+  onStateChange(cb: (info: { connected: boolean }) => void): void {
+    this.onStateChangeCb = cb;
+  }
+
+  private connect(isReconnect: boolean, onReady?: () => void, onReadyFail?: (err: Error) => void): void {
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    let opened = false;
+
+    ws.onopen = () => {
+      opened = true;
+      onReady?.();
+      // Emit state on every successful open EXCEPT the very first one (welcome already
+      // implies connected=true). isReconnect distinguishes those.
+      if (isReconnect) {
+        this.onStateChangeCb?.({ connected: true });
+      }
+      while (this.pending.length > 0) {
+        const f = this.pending.shift()!;
+        ws.send(JSON.stringify(f));
+      }
+    };
+
+    ws.onclose = event => {
+      if (this.intentionallyClosed) return;
+      if (!opened) {
+        // Server rejected the connection before it opened (e.g. unknown session).
+        const stage = isReconnect ? 'reconnect' : 'initial';
+        const reason = `${stage}-failed code=${event.code}`;
+        if (onReadyFail) {
+          // First attempt — surface the failure to whoever is awaiting `ready()` so they
+          // can decide whether to recover (e.g. fall back to a fresh initSession).
+          onReadyFail(new Error(reason));
+          this.dead = true;
+        } else {
+          // Reconnect failed; the consumer is past `ready()` and only learns about it via onClose.
+          this.die(reason);
+        }
+        return;
+      }
+      // The WS opened and is now closing. Distinguish graceful drain (retry) from app
+      // rejection (terminal). Both can have wasClean=true at the protocol level, so we have
+      // to inspect the code: 1000/1001 are lifecycle closes ("come back"), 4xxx are
+      // application-level rejections ("don't come back"), anything else (1006 etc.) is
+      // abnormal.
+      const isGracefulDrain = event.wasClean && (event.code === 1000 || event.code === 1001);
+      if (isGracefulDrain) {
+        this.onStateChangeCb?.({ connected: false });
+        this.connect(true);
+      } else {
+        this.die(`close code=${event.code} wasClean=${event.wasClean}`);
+      }
+    };
+  }
+
+  private die(reason: string): void {
+    this.dead = true;
+    this.onCloseCb?.({ reason });
+  }
+}

package/src/uploader/worker/worker-script.ts

@@ -0,0 +1,3 @@
+// Generated by scripts/build-worker.mjs at build time. Do not edit.
+// Run `yarn workspace @spotify-confidence/csr-common build:worker` to regenerate.
+export const workerScript: string = "//#region src/uploader/worker/web-socket-transport.ts\n/**\n* WebSocket-backed Transport. Internal retry policy: clean server-initiated close after the\n* first successful open → reconnect and resume; abrupt close (or any close before the first\n* open) → fire `onClose` and stop. Frames received while a (re)connect is in progress are\n* buffered and flushed on open.\n*\n* `ready()` resolves on the first successful open and rejects on close-before-open. Callers\n* should await it before treating the Transport as live, so a failure to open can be caught\n* (e.g. 4404 unknown session) and recovered from.\n*/\nvar WebSocketTransport = class {\n\turl;\n\tws = null;\n\tonCloseCb = null;\n\tonStateChangeCb = null;\n\tintentionallyClosed = false;\n\tdead = false;\n\t/** Frames buffered while a (re)connect is in progress. */\n\tpending = [];\n\treadyPromise;\n\tconstructor(url) {\n\t\tthis.url = url;\n\t\tthis.readyPromise = new Promise((resolve, reject) => {\n\t\t\tthis.connect(false, resolve, reject);\n\t\t});\n\t\tthis.readyPromise.catch(() => {});\n\t}\n\tready() {\n\t\treturn this.readyPromise;\n\t}\n\tsend(frame) {\n\t\tif (this.dead || this.intentionallyClosed) return;\n\t\tif (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(frame));\n\t\telse this.pending.push(frame);\n\t}\n\tclose(reason = \"transport-close\") {\n\t\tthis.intentionallyClosed = true;\n\t\tthis.ws?.close(1e3, reason);\n\t}\n\tonClose(cb) {\n\t\tthis.onCloseCb = cb;\n\t}\n\tonStateChange(cb) {\n\t\tthis.onStateChangeCb = cb;\n\t}\n\tconnect(isReconnect, onReady, onReadyFail) {\n\t\tconst ws = new WebSocket(this.url);\n\t\tthis.ws = ws;\n\t\tlet opened = false;\n\t\tws.onopen = () => {\n\t\t\topened = true;\n\t\t\tonReady?.();\n\t\t\tif (isReconnect) this.onStateChangeCb?.({ connected: true });\n\t\t\twhile (this.pending.length > 0) {\n\t\t\t\tconst f = this.pending.shift();\n\t\t\t\tws.send(JSON.stringify(f));\n\t\t\t}\n\t\t};\n\t\tws.onclose = (event) => {\n\t\t\tif (this.intentionallyClosed) return;\n\t\t\tif (!opened) {\n\t\t\t\tconst reason = `${isReconnect ? \"reconnect\" : \"initial\"}-failed code=${event.code}`;\n\t\t\t\tif (onReadyFail) {\n\t\t\t\t\tonReadyFail(new Error(reason));\n\t\t\t\t\tthis.dead = true;\n\t\t\t\t} else this.die(reason);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (event.wasClean && (event.code === 1e3 || event.code === 1001)) {\n\t\t\t\tthis.onStateChangeCb?.({ connected: false });\n\t\t\t\tthis.connect(true);\n\t\t\t} else this.die(`close code=${event.code} wasClean=${event.wasClean}`);\n\t\t};\n\t}\n\tdie(reason) {\n\t\tthis.dead = true;\n\t\tthis.onCloseCb?.({ reason });\n\t}\n};\n//#endregion\n//#region src/uploader/worker/csr-client.ts\n/**\n* Single Client implementation that talks to the recording backend's REST + WS protocol.\n* Both dev-server and prod implement the same protocol, so we don't need polymorphism here yet.\n*/\nvar CsrClient = class {\n\tapiUrl;\n\tclientSecret;\n\ttargetingKey;\n\tcontext;\n\twebsocketUrl;\n\tlog;\n\tforceRecord;\n\tconstructor(apiUrl, clientSecret, targetingKey, context, websocketUrl, log = () => {}, forceRecord) {\n\t\tthis.apiUrl = apiUrl;\n\t\tthis.clientSecret = clientSecret;\n\t\tthis.targetingKey = targetingKey;\n\t\tthis.context = context;\n\t\tthis.websocketUrl = websocketUrl;\n\t\tthis.log = log;\n\t\tthis.forceRecord = forceRecord;\n\t}\n\tasync initSession() {\n\t\tconst url = `${this.trimSlash(this.apiUrl)}/v1/sessions:initSession`;\n\t\tthis.log(`fetch POST ${url}`);\n\t\tconst res = await fetch(url, {\n\t\t\tmethod: \"POST\",\n\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\tbody: JSON.stringify({\n\t\t\t\tclientSecret: this.clientSecret,\n\t\t\t\t...this.targetingKey ? { targetingKey: this.targetingKey } : {},\n\t\t\t\t...this.context && Object.keys(this.context).length > 0 ? { context: this.context } : {},\n\t\t\t\t...this.forceRecord ? { forceRecord: true } : {}\n\t\t\t})\n\t\t});\n\t\tif (!res.ok) throw new Error(`init-session failed: HTTP ${res.status}`);\n\t\tconst data = await res.json();\n\t\tif (data.skipRecording) return { skipRecording: true };\n\t\tif (!data.sessionId || !data.sessionToken) throw new Error(\"init-session response missing sessionId or sessionToken\");\n\t\treturn {\n\t\t\tsessionId: data.sessionId,\n\t\t\tsessionToken: data.sessionToken\n\t\t};\n\t}\n\tasync openTransport(sessionToken) {\n\t\tconst wsBase = this.websocketUrl ?? `${this.toWsScheme(this.trimSlash(this.apiUrl))}/sessions/stream`;\n\t\tconst url = `${wsBase}${wsBase.includes(\"?\") ? \"&\" : \"?\"}session_token=${encodeURIComponent(sessionToken)}`;\n\t\tthis.log(`WebSocket connect ${url}`);\n\t\tconst transport = new WebSocketTransport(url);\n\t\tawait transport.ready();\n\t\treturn transport;\n\t}\n\ttrimSlash(s) {\n\t\treturn s.endsWith(\"/\") ? s.slice(0, -1) : s;\n\t}\n\ttoWsScheme(base) {\n\t\tif (base.startsWith(\"https://\")) return `wss://${base.slice(8)}`;\n\t\tif (base.startsWith(\"http://\")) return `ws://${base.slice(7)}`;\n\t\treturn base;\n\t}\n};\n//#endregion\n//#region src/uploader/worker/core.ts\nconst IDLE_GRACE_MS = 5e3;\nlet state = { phase: \"init\" };\nconst ports = [];\nlet idleTimer = null;\nfunction cancelIdleTimer() {\n\tif (idleTimer !== null) {\n\t\tclearTimeout(idleTimer);\n\t\tidleTimer = null;\n\t}\n}\nfunction log(msg) {\n\tfor (const handle of ports) if (handle.debugLogs) handle.port.postMessage({\n\t\ttype: \"log\",\n\t\tmsg\n\t});\n}\n/**\n* The first hello \"locks in\" the session's apiUrl/clientSecret. Any later tab arriving\n* with different values is misconfigured — we reject it rather than silently using the\n* locked values. In SharedWorker mode the `name = hash(clientSecret)` scoping already\n* prevents secret-mismatch from sharing a worker, but this defends against the dedicated\n* path and against future bugs.\n*/\nlet lockedConfig = null;\nfunction registerPort(adapter) {\n\tcancelIdleTimer();\n\tconst handle = {\n\t\tport: adapter,\n\t\thello: null,\n\t\tdebugLogs: false\n\t};\n\tports.push(handle);\n\tadapter.onmessage((data) => {\n\t\thandleMessage(handle, data);\n\t});\n}\nfunction handleMessage(handle, message) {\n\tswitch (message.type) {\n\t\tcase \"hello\":\n\t\t\thandle.hello = message;\n\t\t\thandle.debugLogs = message.debugLogs ?? false;\n\t\t\tif (rejectIfIncompatible(handle)) return;\n\t\t\tif (state.phase !== \"dead\" && state.phase !== \"skipping\") detectDuplicateTab(handle);\n\t\t\tonHello(handle);\n\t\t\treturn;\n\t\tcase \"frame\":\n\t\t\tonFrame(message.frame);\n\t\t\treturn;\n\t\tcase \"bye\":\n\t\t\tonBye(handle);\n\t\t\treturn;\n\t\tdefault: break;\n\t}\n}\n/**\n* Reject hellos whose `apiUrl`/`clientSecret` don't match the values established by the\n* first hello. Returns true if the port was rejected (caller should not continue\n* processing this hello).\n*/\nfunction rejectIfIncompatible(handle) {\n\tif (lockedConfig === null) return false;\n\tconst incoming = handle.hello;\n\tif (incoming.apiUrl === lockedConfig.apiUrl && incoming.websocketUrl === lockedConfig.websocketUrl && incoming.clientSecret === lockedConfig.clientSecret) return false;\n\thandle.port.postMessage({\n\t\ttype: \"dead\",\n\t\treason: \"incompatible-options: apiUrl/websocketUrl/clientSecret differ from the worker session\"\n\t});\n\tconst idx = ports.indexOf(handle);\n\tif (idx >= 0) ports.splice(idx, 1);\n\treturn true;\n}\n/**\n* If another already-connected port has the same `tabId`, this hello is from a duplicate\n* tab (browser \"Duplicate\" command clones sessionStorage). Mint a fresh `tabId` so the two\n* tabs don't collide on the same `(sessionId, tabId)` Recording. The new tabId is returned\n* to the tab in `welcome` so it can update its own state and sessionStorage.\n*/\nfunction detectDuplicateTab(handle) {\n\tconst tabId = handle.hello.tabId;\n\tif (!ports.some((p) => p !== handle && p.hello?.tabId === tabId)) return;\n\tconst fresh = crypto.randomUUID();\n\thandle.newTabId = fresh;\n\thandle.hello.tabId = fresh;\n}\nfunction onHello(handle) {\n\tswitch (state.phase) {\n\t\tcase \"init\":\n\t\t\tlockedConfig = {\n\t\t\t\tapiUrl: handle.hello.apiUrl,\n\t\t\t\twebsocketUrl: handle.hello.websocketUrl,\n\t\t\t\tclientSecret: handle.hello.clientSecret\n\t\t\t};\n\t\t\tlog(`hello received apiUrl=${handle.hello.apiUrl} websocketUrl=${handle.hello.websocketUrl ?? \"(derive)\"} sessionIdHint=${handle.hello.sessionIdHint ?? \"(none)\"}`);\n\t\t\tstate = { phase: \"initializing\" };\n\t\t\tinitializeSession(handle.hello).then(flushPendingWelcomes);\n\t\t\treturn;\n\t\tcase \"initializing\": return;\n\t\tcase \"active\":\n\t\t\tsendActiveWelcome(handle, state.sessionId, state.sessionToken);\n\t\t\treturn;\n\t\tcase \"idle\": {\n\t\t\tconst { client, sessionId, sessionToken } = state;\n\t\t\tstate = { phase: \"initializing\" };\n\t\t\tresumeTransport(client, sessionId, sessionToken).then(flushPendingWelcomes);\n\t\t\treturn;\n\t\t}\n\t\tcase \"skipping\":\n\t\t\tif (handle.hello.forceRecord) {\n\t\t\t\tlog(\"forceRecord set; re-initializing from skipping state\");\n\t\t\t\tstate = { phase: \"initializing\" };\n\t\t\t\tinitializeSession(handle.hello).then(flushPendingWelcomes);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\thandle.port.postMessage({\n\t\t\t\ttype: \"welcome\",\n\t\t\t\tresult: { skipRecording: true }\n\t\t\t});\n\t\t\treturn;\n\t\tcase \"dead\":\n\t\t\thandle.port.postMessage({\n\t\t\t\ttype: \"dead\",\n\t\t\t\treason: state.reason\n\t\t\t});\n\t\t\treturn;\n\t\tdefault: break;\n\t}\n}\nasync function initializeSession(firstHello) {\n\tconst client = new CsrClient(firstHello.apiUrl, firstHello.clientSecret, firstHello.targetingKey, firstHello.context, firstHello.websocketUrl, log, firstHello.forceRecord);\n\tif (firstHello.sessionIdHint && firstHello.sessionTokenHint) {\n\t\tlog(`adopting sessionIdHint=${firstHello.sessionIdHint}`);\n\t\ttry {\n\t\t\tconst transport = await client.openTransport(firstHello.sessionTokenHint);\n\t\t\twireTransport(transport);\n\t\t\tstate = {\n\t\t\t\tphase: \"active\",\n\t\t\t\tclient,\n\t\t\t\ttransport,\n\t\t\t\tsessionId: firstHello.sessionIdHint,\n\t\t\t\tsessionToken: firstHello.sessionTokenHint\n\t\t\t};\n\t\t\tlog(\"hint adopted; transport open\");\n\t\t\tif (ports.length === 0) idleTimer = setTimeout(enterIdle, IDLE_GRACE_MS);\n\t\t\treturn;\n\t\t} catch (err) {\n\t\t\tlog(`hint rejected (${String(err)}); falling back to fresh init`);\n\t\t}\n\t}\n\tlet result;\n\ttry {\n\t\tresult = await client.initSession();\n\t} catch (err) {\n\t\tlog(`init-session threw: ${String(err)}`);\n\t\ttransitionToDead(`init-session-failed: ${String(err)}`);\n\t\treturn;\n\t}\n\tif (\"skipRecording\" in result) {\n\t\tlog(\"init-session: skipRecording\");\n\t\tstate = { phase: \"skipping\" };\n\t\treturn;\n\t}\n\tlog(`init-session ok sessionId=${result.sessionId}`);\n\tlet transport;\n\ttry {\n\t\ttransport = await client.openTransport(result.sessionToken);\n\t} catch (err) {\n\t\tlog(`openTransport threw: ${String(err)}`);\n\t\ttransitionToDead(`open-transport-failed: ${String(err)}`);\n\t\treturn;\n\t}\n\twireTransport(transport);\n\tlog(\"transport open; session active\");\n\tstate = {\n\t\tphase: \"active\",\n\t\tclient,\n\t\ttransport,\n\t\tsessionId: result.sessionId,\n\t\tsessionToken: result.sessionToken\n\t};\n\tif (ports.length === 0) idleTimer = setTimeout(enterIdle, IDLE_GRACE_MS);\n}\nasync function resumeTransport(client, sessionId, sessionToken) {\n\tlog(\"resuming transport from idle\");\n\tlet transport;\n\ttry {\n\t\ttransport = await client.openTransport(sessionToken);\n\t} catch (err) {\n\t\tlog(`resume-transport threw: ${String(err)}`);\n\t\ttransitionToDead(`resume-transport-failed: ${String(err)}`);\n\t\treturn;\n\t}\n\twireTransport(transport);\n\tlog(\"transport resumed\");\n\tstate = {\n\t\tphase: \"active\",\n\t\tclient,\n\t\ttransport,\n\t\tsessionId,\n\t\tsessionToken\n\t};\n\tif (ports.length === 0) idleTimer = setTimeout(enterIdle, IDLE_GRACE_MS);\n}\nfunction wireTransport(transport) {\n\ttransport.onClose((info) => {\n\t\tif (state.phase !== \"active\") return;\n\t\ttransitionToDead(info.reason);\n\t});\n\ttransport.onStateChange((info) => {\n\t\tif (state.phase !== \"active\") return;\n\t\tfor (const handle of ports) handle.port.postMessage({\n\t\t\ttype: \"state\",\n\t\t\tconnected: info.connected\n\t\t});\n\t});\n}\nfunction transitionToDead(reason) {\n\tstate = {\n\t\tphase: \"dead\",\n\t\treason\n\t};\n\tfor (const handle of ports) handle.port.postMessage({\n\t\ttype: \"dead\",\n\t\treason\n\t});\n}\nfunction flushPendingWelcomes() {\n\tfor (const handle of ports) {\n\t\tif (handle.hello === null) continue;\n\t\tif (state.phase === \"active\") sendActiveWelcome(handle, state.sessionId, state.sessionToken);\n\t\telse if (state.phase === \"skipping\") handle.port.postMessage({\n\t\t\ttype: \"welcome\",\n\t\t\tresult: { skipRecording: true }\n\t\t});\n\t\telse if (state.phase === \"dead\") handle.port.postMessage({\n\t\t\ttype: \"dead\",\n\t\t\treason: state.reason\n\t\t});\n\t}\n}\nfunction sendActiveWelcome(handle, currentSessionId, currentSessionToken) {\n\tconst hint = handle.hello?.sessionIdHint;\n\tconst adopted = hint !== void 0 && hint !== currentSessionId;\n\tconst newTabId = handle.newTabId;\n\thandle.port.postMessage({\n\t\ttype: \"welcome\",\n\t\tresult: {\n\t\t\tsessionId: currentSessionId,\n\t\t\tsessionToken: currentSessionToken\n\t\t},\n\t\tadoptedFromSessionId: adopted ? hint : void 0,\n\t\tnewTabId,\n\t\tresetCounter: adopted || newTabId !== void 0\n\t});\n}\nfunction onFrame(frame) {\n\tif (state.phase !== \"active\") return;\n\tstate.transport.send(frame);\n}\nfunction onBye(handle) {\n\tconst idx = ports.indexOf(handle);\n\tif (idx >= 0) ports.splice(idx, 1);\n\tif (ports.length === 0 && state.phase === \"active\") {\n\t\tlog(`last tab disconnected; closing transport in ${IDLE_GRACE_MS}ms`);\n\t\tidleTimer = setTimeout(enterIdle, IDLE_GRACE_MS);\n\t}\n}\nfunction enterIdle() {\n\tidleTimer = null;\n\tif (state.phase !== \"active\" || ports.length > 0) return;\n\tlog(\"idle timeout; closing transport\");\n\tstate.transport.close(\"idle\");\n\tstate = {\n\t\tphase: \"idle\",\n\t\tclient: state.client,\n\t\tsessionId: state.sessionId,\n\t\tsessionToken: state.sessionToken\n\t};\n}\n//#endregion\n//#region src/uploader/worker/entry.ts\nconst SharedWorkerScopeCtor = globalThis.SharedWorkerGlobalScope;\nif (typeof SharedWorkerScopeCtor === \"function\" && self instanceof SharedWorkerScopeCtor) self.onconnect = (event) => {\n\tconst port = event.ports[0];\n\tport.start();\n\tregisterPort(adaptMessagePort(port));\n};\nelse registerPort(adaptDedicatedSelf());\nfunction adaptMessagePort(port) {\n\treturn {\n\t\tpostMessage: (message) => port.postMessage(message),\n\t\tonmessage: (cb) => {\n\t\t\tport.onmessage = (e) => cb(e.data);\n\t\t}\n\t};\n}\nfunction adaptDedicatedSelf() {\n\tconst ws = self;\n\treturn {\n\t\tpostMessage: (message) => ws.postMessage(message),\n\t\tonmessage: (cb) => {\n\t\t\tws.onmessage = (e) => cb(e.data);\n\t\t}\n\t};\n}\n//#endregion\n";

package/src/url.ts

@@ -0,0 +1,11 @@
+/**
+ * Extract only the pathname from a URL, stripping origin, query string, and
+ * hash. Used across recorder and analyzer to avoid capturing PII in route data.
+ */
+export function stripUrl(url: string): string {
+  try {
+    return new URL(url).pathname;
+  } catch (_e) {
+    return url;
+  }
+}