@alwaysmeticulous/backend-recorder-workerd 2.315.0 → 2.321.0

package/dist/virtual-random.js

@@ -0,0 +1,238 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3821aa29-b3ba-551f-957d-45a05bdc02bf")}catch(e){}}();
+import { requestCaptureContext } from "./context.js";
+import { warnOnce } from "./log.js";
+//#region src/virtual-random.ts
+/**
+* Per-session randomness virtualization for replay mode.
+*
+* Mocking every outbound `fetch` is not enough to make a replay deterministic: a Worker that
+* mints an id (`crypto.randomUUID()` for a guest id, `getRandomValues` for a token) produces
+* a different value in the base replay than in the head replay, so the rendered HTML differs
+* and any screenshot showing that value diffs forever. This replaces the worker's sources of
+* randomness with seeded generators while serving a replayed request, so two replays of the
+* same recorded session render identically.
+*
+* Deliberately a *generator*, not a recording: like the browser replayer we do not capture
+* the numbers the original session produced, we produce fresh ones from a fixed seed. The
+* app still sees plausible random values, and two replays see the same ones.
+*
+* Ported from the Node backend recorder's `replay/virtual-random.ts`, which in turn mirrors
+* the browser replayer's `mockOutRandomNumberGeneration`, including its butterfly-effect
+* containment: a separate sequence per call stack, seeded from a per-call-site counter, so a
+* change in one part of the app does not shift the numbers another part gets, and a shared
+* helper called from two places does not return the same value twice. Two differences from
+* the Node version, both forced by the runtime:
+*
+*   - the session comes from the request context rather than a session resolver with a
+*     process-wide fallback, because workerd's AsyncLocalStorage propagates reliably from the
+*     inbound handler;
+*   - only the globals workerd actually has are patched — there is no `node:crypto` module to
+*     mutate.
+*
+* Reads outside a replayed request — module evaluation, a recording, a deployed production
+* worker — fall through to the native generators untouched.
+*/
+const nativeMathRandom = Math.random.bind(Math);
+const nativeRandomUUID = globalThis.crypto?.randomUUID?.bind(globalThis.crypto);
+const nativeGetRandomValues = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);
+/**
+* Frames of the stack that belong to this module and must be skipped to reach the app's call
+* site, counted from the `new Error()` inside {@link getCallStack}.
+*
+* Getting this wrong degrades gracefully rather than breaking: a call site that resolves to
+* one of our own frames merges sequences that should have been separate, which costs
+* butterfly-effect isolation but is still perfectly deterministic.
+*/
+const FRAMES_TO_APP = 3;
+/** How much of the stack identifies a sequence. Ten frames tells call paths apart cheaply. */
+const STACK_FRAMES = 10;
+/** Stack captures per session, after which sequences are keyed by call site alone. */
+const MAX_STACK_CAPTURES = 1e4;
+/** Bounds the state a stream of unrecognised session ids can accumulate in one isolate. */
+const MAX_TRACKED_SESSIONS = 50;
+const UNKNOWN_CALL_SITE = "unknown";
+const stateBySession = /* @__PURE__ */ new Map();
+/**
+* Alea, the same algorithm the browser replayer gets from `seedrandom`. Inlined because this
+* package is published to npm and ships no runtime dependencies — a customer's Worker bundle
+* should not grow for this.
+*/
+const createSeededRandom = (seed) => {
+	let n = 4022871197;
+	const mash = (data) => {
+		for (let i = 0; i < data.length; i++) {
+			n += data.charCodeAt(i);
+			let h = .02519603282416938 * n;
+			n = h >>> 0;
+			h -= n;
+			h *= n;
+			n = h >>> 0;
+			h -= n;
+			n += h * 4294967296;
+		}
+		return (n >>> 0) * 23283064365386963e-26;
+	};
+	let s0 = mash(" ");
+	let s1 = mash(" ");
+	let s2 = mash(" ");
+	let c = 1;
+	s0 -= mash(seed);
+	if (s0 < 0) s0 += 1;
+	s1 -= mash(seed);
+	if (s1 < 0) s1 += 1;
+	s2 -= mash(seed);
+	if (s2 < 0) s2 += 1;
+	return () => {
+		const t = 2091639 * s0 + c * 23283064365386963e-26;
+		s0 = s1;
+		s1 = s2;
+		c = t | 0;
+		s2 = t - c;
+		return s2;
+	};
+};
+const getCallStack = () => {
+	const originalLimit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = FRAMES_TO_APP + STACK_FRAMES;
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		if (stack == null) return {
+			stack: UNKNOWN_CALL_SITE,
+			site: UNKNOWN_CALL_SITE
+		};
+		const lines = stack.split("\n").slice(FRAMES_TO_APP + 1);
+		return {
+			stack: lines.join("\n") || UNKNOWN_CALL_SITE,
+			site: lines[0] ?? UNKNOWN_CALL_SITE
+		};
+	} catch {
+		return {
+			stack: UNKNOWN_CALL_SITE,
+			site: UNKNOWN_CALL_SITE
+		};
+	} finally {
+		Error.stackTraceLimit = originalLimit;
+	}
+};
+const getSessionState = () => {
+	const ctx = requestCaptureContext.getStore();
+	if (ctx === void 0 || ctx.mode !== "replay") return;
+	const existing = stateBySession.get(ctx.frontendSessionId);
+	if (existing !== void 0) return existing;
+	if (stateBySession.size >= MAX_TRACKED_SESSIONS) {
+		const oldest = stateBySession.keys().next();
+		if (!oldest.done) stateBySession.delete(oldest.value);
+	}
+	const created = {
+		frontendSessionId: ctx.frontendSessionId,
+		generatorBySequenceKey: /* @__PURE__ */ new Map(),
+		nextCallerIdByCallSite: /* @__PURE__ */ new Map(),
+		stackCaptures: 0
+	};
+	stateBySession.set(ctx.frontendSessionId, created);
+	return created;
+};
+/**
+* The generator for the sequence the current call belongs to, or undefined outside a
+* replayed request.
+*
+* Sequences are keyed by the whole call stack, so a second call down the same path continues
+* the same sequence and gets a different value. The *seed* comes from a counter kept per
+* immediate call site, which is what keeps a shared id helper honest: two call paths through
+* the same `generateId()` share a call site, so they are seeded 0 and 1 and return different
+* ids.
+*
+* Note what the seed deliberately does NOT contain: any part of the stack. Base and head are
+* different builds of the app, so the same logical call site has a different string in each —
+* a seed built from it would change on every rebuild. The consequence, which the browser
+* replayer shares, is that two *distinct* call sites each seen for the first time both seed at
+* 0 and hand out the same first value. That is the accepted trade: an alternative that
+* separated them (say, an ordinal per call site) would shift every later site's values as soon
+* as a PR added one randomness call, which is the butterfly effect this whole scheme exists to
+* avoid.
+*/
+const openSequence = () => {
+	const state = getSessionState();
+	if (state === void 0) return;
+	let sequenceKey = UNKNOWN_CALL_SITE;
+	let callSite = UNKNOWN_CALL_SITE;
+	if (state.stackCaptures < MAX_STACK_CAPTURES) {
+		state.stackCaptures++;
+		const captured = getCallStack();
+		sequenceKey = captured.stack;
+		callSite = captured.site;
+	}
+	const existing = state.generatorBySequenceKey.get(sequenceKey);
+	if (existing !== void 0) return existing;
+	const callerId = state.nextCallerIdByCallSite.get(callSite) ?? 0;
+	const generator = createSeededRandom(`meticulous-random-${state.frontendSessionId}-${callerId}`);
+	state.generatorBySequenceKey.set(sequenceKey, generator);
+	state.nextCallerIdByCallSite.set(callSite, callerId + 1);
+	return generator;
+};
+const HEX = "0123456789abcdef";
+/** The two bits of a v4 UUID's variant field are fixed, leaving these four values. */
+const VARIANT = "89ab";
+const buildUuid = (draw) => {
+	let uuid = "";
+	for (let i = 0; i < 36; i++) if (i === 8 || i === 13 || i === 18 || i === 23) uuid += "-";
+	else if (i === 14) uuid += "4";
+	else if (i === 19) uuid += VARIANT[Math.floor(draw() * 4)];
+	else uuid += HEX[Math.floor(draw() * 16)];
+	return uuid;
+};
+/**
+* Fills the view's bytes rather than its elements, so every typed array — including the
+* BigInt ones, whose elements cannot be assigned a number — is handled by one path.
+*/
+const fillBytes = (view, draw) => {
+	const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(draw() * 256);
+};
+let installed = false;
+/**
+* Replaces the worker's sources of randomness with per-session seeded generators. Idempotent,
+* and a no-op failure: a worker that will not let them be replaced still replays, just
+* without randomness virtualisation.
+*
+* Called lazily from the replay branch of the request wrapper rather than at module scope,
+* for the same reasons as the virtual clock: record mode and deployed production workers then
+* pay nothing, and the package declares no `sideEffects`, so a module-scope side effect could
+* legitimately be tree-shaken away by a customer's bundler.
+*/
+const installVirtualRandom = () => {
+	if (installed) return;
+	installed = true;
+	try {
+		Math.random = () => openSequence()?.() ?? nativeMathRandom();
+		if (globalThis.crypto != null) {
+			Object.defineProperty(globalThis.crypto, "randomUUID", {
+				value: () => {
+					const draw = openSequence();
+					if (draw !== void 0) return buildUuid(draw);
+					return nativeRandomUUID?.() ?? buildUuid(nativeMathRandom);
+				},
+				configurable: true,
+				writable: true
+			});
+			Object.defineProperty(globalThis.crypto, "getRandomValues", {
+				value: (array) => {
+					const draw = openSequence();
+					if (draw === void 0) return nativeGetRandomValues?.(array) ?? array;
+					fillBytes(array, draw);
+					return array;
+				},
+				configurable: true,
+				writable: true
+			});
+		}
+	} catch (error) {
+		warnOnce("virtual-random", "Could not install the Meticulous replay random-number generators — ids minted by the app will differ between replays.", error);
+	}
+};
+//#endregion
+export { installVirtualRandom };
+
+//# sourceMappingURL=virtual-random.js.map
+//# debugId=3821aa29-b3ba-551f-957d-45a05bdc02bf

package/dist/virtual-random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-random.js","sources":["../src/virtual-random.ts"],"sourcesContent":["import { requestCaptureContext } from \"./context\";\nimport { warnOnce } from \"./log\";\n\n/**\n * Per-session randomness virtualization for replay mode.\n *\n * Mocking every outbound `fetch` is not enough to make a replay deterministic: a Worker that\n * mints an id (`crypto.randomUUID()` for a guest id, `getRandomValues` for a token) produces\n * a different value in the base replay than in the head replay, so the rendered HTML differs\n * and any screenshot showing that value diffs forever. This replaces the worker's sources of\n * randomness with seeded generators while serving a replayed request, so two replays of the\n * same recorded session render identically.\n *\n * Deliberately a *generator*, not a recording: like the browser replayer we do not capture\n * the numbers the original session produced, we produce fresh ones from a fixed seed. The\n * app still sees plausible random values, and two replays see the same ones.\n *\n * Ported from the Node backend recorder's `replay/virtual-random.ts`, which in turn mirrors\n * the browser replayer's `mockOutRandomNumberGeneration`, including its butterfly-effect\n * containment: a separate sequence per call stack, seeded from a per-call-site counter, so a\n * change in one part of the app does not shift the numbers another part gets, and a shared\n * helper called from two places does not return the same value twice. Two differences from\n * the Node version, both forced by the runtime:\n *\n *   - the session comes from the request context rather than a session resolver with a\n *     process-wide fallback, because workerd's AsyncLocalStorage propagates reliably from the\n *     inbound handler;\n *   - only the globals workerd actually has are patched — there is no `node:crypto` module to\n *     mutate.\n *\n * Reads outside a replayed request — module evaluation, a recording, a deployed production\n * worker — fall through to the native generators untouched.\n */\n\nconst nativeMathRandom = Math.random.bind(Math);\nconst nativeRandomUUID = globalThis.crypto?.randomUUID?.bind(globalThis.crypto);\nconst nativeGetRandomValues = globalThis.crypto?.getRandomValues?.bind(\n  globalThis.crypto,\n);\n\n/**\n * Frames of the stack that belong to this module and must be skipped to reach the app's call\n * site, counted from the `new Error()` inside {@link getCallStack}.\n *\n * Getting this wrong degrades gracefully rather than breaking: a call site that resolves to\n * one of our own frames merges sequences that should have been separate, which costs\n * butterfly-effect isolation but is still perfectly deterministic.\n */\nconst FRAMES_TO_APP = 3; // getCallStack ← openSequence ← patched global ← app\n\n/** How much of the stack identifies a sequence. Ten frames tells call paths apart cheaply. */\nconst STACK_FRAMES = 10;\n\n/** Stack captures per session, after which sequences are keyed by call site alone. */\nconst MAX_STACK_CAPTURES = 10_000;\n\n/** Bounds the state a stream of unrecognised session ids can accumulate in one isolate. */\nconst MAX_TRACKED_SESSIONS = 50;\n\nconst UNKNOWN_CALL_SITE = \"unknown\";\n\ninterface SessionRandomState {\n  frontendSessionId: string;\n  generatorBySequenceKey: Map<string, () => number>;\n  nextCallerIdByCallSite: Map<string, number>;\n  stackCaptures: number;\n}\n\nconst stateBySession = new Map<string, SessionRandomState>();\n\n// ---------------------------------------------------------------------------\n// Seeded PRNG (Alea)\n// ---------------------------------------------------------------------------\n\n/**\n * Alea, the same algorithm the browser replayer gets from `seedrandom`. Inlined because this\n * package is published to npm and ships no runtime dependencies — a customer's Worker bundle\n * should not grow for this.\n */\nexport const createSeededRandom = (seed: string): (() => number) => {\n  let n = 0xefc8249d;\n  const mash = (data: string): number => {\n    for (let i = 0; i < data.length; i++) {\n      n += data.charCodeAt(i);\n      let h = 0.02519603282416938 * n;\n      n = h >>> 0;\n      h -= n;\n      h *= n;\n      n = h >>> 0;\n      h -= n;\n      n += h * 0x100000000;\n    }\n    return (n >>> 0) * 2.3283064365386963e-10;\n  };\n\n  let s0 = mash(\" \");\n  let s1 = mash(\" \");\n  let s2 = mash(\" \");\n  let c = 1;\n  s0 -= mash(seed);\n  if (s0 < 0) {\n    s0 += 1;\n  }\n  s1 -= mash(seed);\n  if (s1 < 0) {\n    s1 += 1;\n  }\n  s2 -= mash(seed);\n  if (s2 < 0) {\n    s2 += 1;\n  }\n\n  return () => {\n    const t = 2091639 * s0 + c * 2.3283064365386963e-10;\n    s0 = s1;\n    s1 = s2;\n    c = t | 0;\n    s2 = t - c;\n    return s2;\n  };\n};\n\n// ---------------------------------------------------------------------------\n// Sequence resolution\n// ---------------------------------------------------------------------------\n\nconst getCallStack = (): { stack: string; site: string } => {\n  const originalLimit = Error.stackTraceLimit;\n  try {\n    Error.stackTraceLimit = FRAMES_TO_APP + STACK_FRAMES;\n    const stack = new Error().stack;\n    if (stack == null) {\n      return { stack: UNKNOWN_CALL_SITE, site: UNKNOWN_CALL_SITE };\n    }\n    // Line 0 is the \"Error\" header; frame lines follow, innermost first, and the first\n    // FRAMES_TO_APP of them are ours.\n    const lines = stack.split(\"\\n\").slice(FRAMES_TO_APP + 1);\n    return {\n      stack: lines.join(\"\\n\") || UNKNOWN_CALL_SITE,\n      site: lines[0] ?? UNKNOWN_CALL_SITE,\n    };\n  } catch {\n    return { stack: UNKNOWN_CALL_SITE, site: UNKNOWN_CALL_SITE };\n  } finally {\n    Error.stackTraceLimit = originalLimit;\n  }\n};\n\nconst getSessionState = (): SessionRandomState | undefined => {\n  const ctx = requestCaptureContext.getStore();\n  if (ctx === undefined || ctx.mode !== \"replay\") {\n    return undefined;\n  }\n  const existing = stateBySession.get(ctx.frontendSessionId);\n  if (existing !== undefined) {\n    return existing;\n  }\n  if (stateBySession.size >= MAX_TRACKED_SESSIONS) {\n    const oldest = stateBySession.keys().next();\n    if (!oldest.done) {\n      stateBySession.delete(oldest.value);\n    }\n  }\n  const created: SessionRandomState = {\n    frontendSessionId: ctx.frontendSessionId,\n    generatorBySequenceKey: new Map(),\n    nextCallerIdByCallSite: new Map(),\n    stackCaptures: 0,\n  };\n  stateBySession.set(ctx.frontendSessionId, created);\n  return created;\n};\n\n/**\n * The generator for the sequence the current call belongs to, or undefined outside a\n * replayed request.\n *\n * Sequences are keyed by the whole call stack, so a second call down the same path continues\n * the same sequence and gets a different value. The *seed* comes from a counter kept per\n * immediate call site, which is what keeps a shared id helper honest: two call paths through\n * the same `generateId()` share a call site, so they are seeded 0 and 1 and return different\n * ids.\n *\n * Note what the seed deliberately does NOT contain: any part of the stack. Base and head are\n * different builds of the app, so the same logical call site has a different string in each —\n * a seed built from it would change on every rebuild. The consequence, which the browser\n * replayer shares, is that two *distinct* call sites each seen for the first time both seed at\n * 0 and hand out the same first value. That is the accepted trade: an alternative that\n * separated them (say, an ordinal per call site) would shift every later site's values as soon\n * as a PR added one randomness call, which is the butterfly effect this whole scheme exists to\n * avoid.\n */\nconst openSequence = (): (() => number) | undefined => {\n  const state = getSessionState();\n  if (state === undefined) {\n    return undefined;\n  }\n\n  let sequenceKey = UNKNOWN_CALL_SITE;\n  let callSite = UNKNOWN_CALL_SITE;\n  if (state.stackCaptures < MAX_STACK_CAPTURES) {\n    state.stackCaptures++;\n    const captured = getCallStack();\n    sequenceKey = captured.stack;\n    callSite = captured.site;\n  }\n\n  const existing = state.generatorBySequenceKey.get(sequenceKey);\n  if (existing !== undefined) {\n    return existing;\n  }\n  const callerId = state.nextCallerIdByCallSite.get(callSite) ?? 0;\n  // Seeded from the counter only — never from the call-site or stack string itself. Those embed\n  // bundle filenames and line numbers, which differ between the base build and the head build\n  // of the very same code, so putting one in the seed would reseed every sequence on any\n  // rebuild and bring back exactly the diffs this exists to remove. The strings are grouping\n  // keys, nothing more.\n  const generator = createSeededRandom(\n    `meticulous-random-${state.frontendSessionId}-${callerId}`,\n  );\n  state.generatorBySequenceKey.set(sequenceKey, generator);\n  state.nextCallerIdByCallSite.set(callSite, callerId + 1);\n  return generator;\n};\n\n// ---------------------------------------------------------------------------\n// Derived primitives\n// ---------------------------------------------------------------------------\n\nconst HEX = \"0123456789abcdef\";\n/** The two bits of a v4 UUID's variant field are fixed, leaving these four values. */\nconst VARIANT = \"89ab\";\n\nconst buildUuid = (draw: () => number): string => {\n  let uuid = \"\";\n  for (let i = 0; i < 36; i++) {\n    if (i === 8 || i === 13 || i === 18 || i === 23) {\n      uuid += \"-\";\n    } else if (i === 14) {\n      uuid += \"4\";\n    } else if (i === 19) {\n      uuid += VARIANT[Math.floor(draw() * VARIANT.length)];\n    } else {\n      uuid += HEX[Math.floor(draw() * HEX.length)];\n    }\n  }\n  return uuid;\n};\n\n/**\n * Fills the view's bytes rather than its elements, so every typed array — including the\n * BigInt ones, whose elements cannot be assigned a number — is handled by one path.\n */\nconst fillBytes = (view: ArrayBufferView, draw: () => number): void => {\n  const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Math.floor(draw() * 256);\n  }\n};\n\n// ---------------------------------------------------------------------------\n// Install\n// ---------------------------------------------------------------------------\n\nlet installed = false;\n\n/**\n * Replaces the worker's sources of randomness with per-session seeded generators. Idempotent,\n * and a no-op failure: a worker that will not let them be replaced still replays, just\n * without randomness virtualisation.\n *\n * Called lazily from the replay branch of the request wrapper rather than at module scope,\n * for the same reasons as the virtual clock: record mode and deployed production workers then\n * pay nothing, and the package declares no `sideEffects`, so a module-scope side effect could\n * legitimately be tree-shaken away by a customer's bundler.\n */\nexport const installVirtualRandom = (): void => {\n  if (installed) {\n    return;\n  }\n  installed = true;\n  try {\n    Math.random = () => openSequence()?.() ?? nativeMathRandom();\n\n    if (globalThis.crypto != null) {\n      Object.defineProperty(globalThis.crypto, \"randomUUID\", {\n        value: (): string => {\n          const draw = openSequence();\n          if (draw !== undefined) {\n            return buildUuid(draw);\n          }\n          return nativeRandomUUID?.() ?? buildUuid(nativeMathRandom);\n        },\n        configurable: true,\n        writable: true,\n      });\n\n      Object.defineProperty(globalThis.crypto, \"getRandomValues\", {\n        value: <T extends ArrayBufferView>(array: T): T => {\n          const draw = openSequence();\n          if (draw === undefined) {\n            return nativeGetRandomValues?.(array) ?? array;\n          }\n          fillBytes(array, draw);\n          return array;\n        },\n        configurable: true,\n        writable: true,\n      });\n    }\n  } catch (error) {\n    warnOnce(\n      \"virtual-random\",\n      \"Could not install the Meticulous replay random-number generators — ids minted by the app will differ between replays.\",\n      error,\n    );\n  }\n};\n"],"names":[],"mappings":"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","debugId":"3821aa29-b3ba-551f-957d-45a05bdc02bf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwaysmeticulous/backend-recorder-workerd",
-  "version": "2.315.0",
+  "version": "2.321.0",
   "type": "module",
   "description": "Meticulous backend recorder shim for Cloudflare Workers (workerd). Reports inbound and outbound HTTP capture events to a local Meticulous recorder sidecar during development recording.",
   "license": "ISC",