@alwaysmeticulous/backend-recorder-workerd 2.315.0 → 2.321.0

package/dist/protocol.js

@@ -5,7 +5,7 @@
 * is the single source of truth for the shape of capture events.
 */
 
-!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]="f28d3e21-60a1-55c4-8586-5db3a0ec194b")}catch(e){}}();
+!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]="532e3e0d-6b1c-51c2-8086-a05de2625e79")}catch(e){}}();
 const SIDECAR_PROTOCOL_VERSION = "1";
 /** Header carrying {@link SIDECAR_PROTOCOL_VERSION} on every shim → sidecar request. */
 const SIDECAR_PROTOCOL_VERSION_HEADER = "x-meticulous-sidecar-protocol-version";
@@ -16,6 +16,22 @@ const SIDECAR_PROTOCOL_VERSION_HEADER = "x-meticulous-sidecar-protocol-version";
 const FRONTEND_SESSION_ID_HEADER = "x-meticulous-session-id";
 const SIDECAR_EVENTS_PATH = "/v1/events";
 /**
+* Replay routes. A sidecar started in record mode answers 404 on both, which the shim
+* treats as "replay unavailable" and falls back to plain pass-through — so a new shim
+* keeps working against an older, record-only sidecar.
+*/
+const SIDECAR_REPLAY_SESSION_PATH = "/v1/replay/session";
+const SIDECAR_REPLAY_OUTBOUND_FETCH_PATH = "/v1/replay/outbound-fetch";
+/**
+* Header carrying the replay sidecar's origin, injected by the Meticulous replay runner
+* on requests to the app under test. Workerd cannot see container environment variables,
+* so an inbound header is the only way per-replay config can reach the shim.
+*
+* The shim validates the value before using it and only honours a loopback /
+* `host.docker.internal` / private-network `http:` origin — see `replay-sidecar-url.ts`.
+*/
+const REPLAY_SIDECAR_URL_HEADER = "x-meticulous-backend-replay-sidecar-url";
+/**
 * The only headers persisted on capture events. Everything else — notably
 * authorization, cookie/set-cookie, and API-key headers — is dropped at
 * capture time, before it ever leaves the worker. Mirrors the Node backend
@@ -24,7 +40,7 @@ const SIDECAR_EVENTS_PATH = "/v1/events";
 */
 const CAPTURED_HEADERS = ["content-type", FRONTEND_SESSION_ID_HEADER];
 //#endregion
-export { CAPTURED_HEADERS, FRONTEND_SESSION_ID_HEADER, SIDECAR_EVENTS_PATH, SIDECAR_PROTOCOL_VERSION, SIDECAR_PROTOCOL_VERSION_HEADER };
+export { CAPTURED_HEADERS, FRONTEND_SESSION_ID_HEADER, REPLAY_SIDECAR_URL_HEADER, SIDECAR_EVENTS_PATH, SIDECAR_PROTOCOL_VERSION, SIDECAR_PROTOCOL_VERSION_HEADER, SIDECAR_REPLAY_OUTBOUND_FETCH_PATH, SIDECAR_REPLAY_SESSION_PATH };
 
 //# sourceMappingURL=protocol.js.map
-//# debugId=f28d3e21-60a1-55c4-8586-5db3a0ec194b
+//# debugId=532e3e0d-6b1c-51c2-8086-a05de2625e79

package/dist/protocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.js","sources":["../src/protocol.ts"],"sourcesContent":["/**\n * Wire protocol between the in-worker shim and the Meticulous backend\n * recorder sidecar. The sidecar imports these types (type-only), so this file\n * is the single source of truth for the shape of capture events.\n */\n\nexport const SIDECAR_PROTOCOL_VERSION = \"1\";\n\n/** Header carrying {@link SIDECAR_PROTOCOL_VERSION} on every shim → sidecar request. */\nexport const SIDECAR_PROTOCOL_VERSION_HEADER =\n  \"x-meticulous-sidecar-protocol-version\";\n\n/**\n * Header the Meticulous frontend recorder stamps on requests made by the app\n * under recording; its value ties backend spans to the frontend session.\n */\nexport const FRONTEND_SESSION_ID_HEADER = \"x-meticulous-session-id\";\n\nexport const SIDECAR_EVENTS_PATH = \"/v1/events\";\n\n/**\n * The only headers persisted on capture events. Everything else — notably\n * authorization, cookie/set-cookie, and API-key headers — is dropped at\n * capture time, before it ever leaves the worker. Mirrors the Node backend\n * recorder, which persists only content-type plus the Meticulous session\n * header.\n */\nexport const CAPTURED_HEADERS = [\n  \"content-type\",\n  FRONTEND_SESSION_ID_HEADER,\n] as const;\n\nexport interface CapturedBody {\n  /** UTF-8 decoded body, truncated to the capture cap. */\n  body: string;\n  /** True when the body exceeded the capture cap or the read was cut short. */\n  truncated: boolean;\n}\n\ninterface BaseRequestEvent {\n  /** Correlates outbound events to the inbound request being handled. */\n  requestId: string;\n  /** Value of {@link FRONTEND_SESSION_ID_HEADER} on the inbound request, if any. */\n  frontendSessionId?: string;\n  method: string;\n  /** Full URL including query string. */\n  url: string;\n  /** Lower-cased header name → values. */\n  requestHeaders: Record<string, string[]>;\n  responseHeaders?: Record<string, string[]>;\n  statusCode?: number;\n  startTimeMs: number;\n  endTimeMs: number;\n  /** Set when the request failed before a response was produced. */\n  error?: string;\n}\n\n/**\n * The worker's own inbound request (becomes a SERVER span). Bodies are not\n * captured, matching the Node backend recorder's SERVER-span contract.\n */\nexport interface InboundRequestEvent extends BaseRequestEvent {\n  kind: \"inbound\";\n}\n\n/**\n * An outgoing `fetch` call made while handling an inbound request (becomes a\n * CLIENT span).\n */\nexport interface OutboundRequestEvent extends BaseRequestEvent {\n  kind: \"outbound\";\n  requestBody?: CapturedBody;\n  responseBody?: CapturedBody;\n}\n\nexport type CaptureEvent = InboundRequestEvent | OutboundRequestEvent;\n\nexport interface CaptureEventsPayload {\n  events: CaptureEvent[];\n}\n"],"names":[],"mappings":";;;;;;;;AAMA,MAAa,2BAA2B;;AAGxC,MAAa,kCACX;;;;;AAMF,MAAa,6BAA6B;AAE1C,MAAa,sBAAsB;;;;;;;;AASnC,MAAa,mBAAmB,CAC9B,gBACA,2BACD","debugId":"f28d3e21-60a1-55c4-8586-5db3a0ec194b"}
+{"version":3,"file":"protocol.js","sources":["../src/protocol.ts"],"sourcesContent":["/**\n * Wire protocol between the in-worker shim and the Meticulous backend\n * recorder sidecar. The sidecar imports these types (type-only), so this file\n * is the single source of truth for the shape of capture events.\n */\n\nexport const SIDECAR_PROTOCOL_VERSION = \"1\";\n\n/** Header carrying {@link SIDECAR_PROTOCOL_VERSION} on every shim → sidecar request. */\nexport const SIDECAR_PROTOCOL_VERSION_HEADER =\n  \"x-meticulous-sidecar-protocol-version\";\n\n/**\n * Header the Meticulous frontend recorder stamps on requests made by the app\n * under recording; its value ties backend spans to the frontend session.\n */\nexport const FRONTEND_SESSION_ID_HEADER = \"x-meticulous-session-id\";\n\nexport const SIDECAR_EVENTS_PATH = \"/v1/events\";\n\n/**\n * Replay routes. A sidecar started in record mode answers 404 on both, which the shim\n * treats as \"replay unavailable\" and falls back to plain pass-through — so a new shim\n * keeps working against an older, record-only sidecar.\n */\nexport const SIDECAR_REPLAY_SESSION_PATH = \"/v1/replay/session\";\nexport const SIDECAR_REPLAY_OUTBOUND_FETCH_PATH = \"/v1/replay/outbound-fetch\";\n\n/**\n * Header carrying the replay sidecar's origin, injected by the Meticulous replay runner\n * on requests to the app under test. Workerd cannot see container environment variables,\n * so an inbound header is the only way per-replay config can reach the shim.\n *\n * The shim validates the value before using it and only honours a loopback /\n * `host.docker.internal` / private-network `http:` origin — see `replay-sidecar-url.ts`.\n */\nexport const REPLAY_SIDECAR_URL_HEADER =\n  \"x-meticulous-backend-replay-sidecar-url\";\n\n/**\n * The only headers persisted on capture events. Everything else — notably\n * authorization, cookie/set-cookie, and API-key headers — is dropped at\n * capture time, before it ever leaves the worker. Mirrors the Node backend\n * recorder, which persists only content-type plus the Meticulous session\n * header.\n */\nexport const CAPTURED_HEADERS = [\n  \"content-type\",\n  FRONTEND_SESSION_ID_HEADER,\n] as const;\n\nexport interface CapturedBody {\n  /** UTF-8 decoded body, truncated to the capture cap. */\n  body: string;\n  /** True when the body exceeded the capture cap or the read was cut short. */\n  truncated: boolean;\n}\n\ninterface BaseRequestEvent {\n  /** Correlates outbound events to the inbound request being handled. */\n  requestId: string;\n  /** Value of {@link FRONTEND_SESSION_ID_HEADER} on the inbound request, if any. */\n  frontendSessionId?: string;\n  method: string;\n  /** Full URL including query string. */\n  url: string;\n  /** Lower-cased header name → values. */\n  requestHeaders: Record<string, string[]>;\n  responseHeaders?: Record<string, string[]>;\n  statusCode?: number;\n  startTimeMs: number;\n  endTimeMs: number;\n  /** Set when the request failed before a response was produced. */\n  error?: string;\n}\n\n/**\n * The worker's own inbound request (becomes a SERVER span). Bodies are not\n * captured, matching the Node backend recorder's SERVER-span contract.\n */\nexport interface InboundRequestEvent extends BaseRequestEvent {\n  kind: \"inbound\";\n}\n\n/**\n * An outgoing `fetch` call made while handling an inbound request (becomes a\n * CLIENT span).\n */\nexport interface OutboundRequestEvent extends BaseRequestEvent {\n  kind: \"outbound\";\n  requestBody?: CapturedBody;\n  responseBody?: CapturedBody;\n}\n\n/**\n * A `fetch` through a Cloudflare binding — a service binding, an assets binding, or a\n * Durable Object stub — made while handling an inbound request (becomes a CLIENT span).\n *\n * Request/Response-shaped like {@link OutboundRequestEvent}, but a distinct kind because the\n * call never leaves the isolate and its URL is whatever the caller invented. Keeping the two\n * apart means a binding call and real egress can never be confused for one another when\n * these spans are eventually mocked.\n */\nexport interface BindingRequestEvent extends BaseRequestEvent {\n  kind: \"binding\";\n  /**\n   * The `env` key the binding was found under. Absent when the instance was never seen on\n   * `env` — most commonly a Durable Object stub, which `namespace.get()` produces rather\n   * than being a binding in its own right.\n   */\n  bindingName?: string;\n  requestBody?: CapturedBody;\n  responseBody?: CapturedBody;\n}\n\n/** KV namespace methods the shim records. */\nexport type KvOperation = \"get\" | \"getWithMetadata\" | \"put\" | \"delete\" | \"list\";\n\n/**\n * Why a KV value is absent from an event: workerd handed it over in a form that cannot be\n * persisted as text. A `\"stream\"` value must not even be read — consuming it would take the\n * bytes away from the app — and binary values are skipped deliberately, since KV blobs are\n * large and would both bloat the recording and be mangled by UTF-8 capture.\n */\nexport type KvOmittedReason = \"binary\" | \"stream\";\n\n/**\n * An operation on a Cloudflare KV namespace binding, made while handling an inbound request\n * (becomes a CLIENT span).\n *\n * KV is not HTTP: there is no method, URL or status code, so this event shares nothing with\n * {@link BaseRequestEvent} beyond correlation and timing. Values are JSON so that a single\n * `JSON.parse` reconstructs exactly what the app saw, whichever `type` the read asked for.\n */\nexport interface KvOperationEvent {\n  kind: \"kv\";\n  /** Correlates the operation to the inbound request being handled. */\n  requestId: string;\n  frontendSessionId?: string;\n  /**\n   * The `env` key the KV namespace was found under. Always present, unlike on a binding\n   * event: a namespace has no factory equivalent to `DurableObjectNamespace.get()`, so one\n   * that was never seen on `env` is not recorded at all.\n   */\n  bindingName: string;\n  operation: KvOperation;\n  /**\n   * The key operated on, when it is a single string. Absent for `list` (which spans keys) and\n   * for a bulk `get` (which takes an array) — both keep their arguments in {@link args}.\n   */\n  key?: string;\n  /**\n   * JSON of the call's arguments: the read `type`, the `put` options, the `list` selector.\n   * A `put` value appears as `null` here — it is captured in {@link value} instead, so that\n   * redaction applies to it.\n   */\n  args?: CapturedBody;\n  /** JSON of the value a `put` wrote, with secret-looking fields redacted. */\n  value?: CapturedBody;\n  /**\n   * JSON of what the operation returned: the value for `get`, `{value, metadata}` for\n   * `getWithMetadata`, the key page for `list`. Absent for `put`/`delete`, which return\n   * nothing, and for a value that could not be captured (see {@link omitted}).\n   */\n  result?: CapturedBody;\n  /**\n   * Why the operation's value is missing. Refers to the written value for `put` and to the\n   * read value otherwise — a `put` has no result, so this is never ambiguous.\n   */\n  omitted?: KvOmittedReason;\n  startTimeMs: number;\n  endTimeMs: number;\n  /** Set when the operation threw. */\n  error?: string;\n}\n\nexport type CaptureEvent =\n  | InboundRequestEvent\n  | OutboundRequestEvent\n  | BindingRequestEvent\n  | KvOperationEvent;\n\nexport interface CaptureEventsPayload {\n  events: CaptureEvent[];\n}\n\n/**\n * Answer to `GET {SIDECAR_REPLAY_SESSION_PATH}?sessionId=<id>`: whether the sidecar holds\n * mocks for a session, and the virtual clock anchor to freeze `Date` at while serving it.\n */\nexport interface ReplaySessionInfoResponse {\n  found: boolean;\n  /**\n   * Epoch ms of the session's last recorded activity. The worker freezes its clock here so\n   * that credentials minted during the recording are already issued but not yet expired.\n   */\n  clockAnchorMs?: number;\n}\n\n/** Lookup for a single outbound `fetch`, sent to {@link SIDECAR_REPLAY_OUTBOUND_FETCH_PATH}. */\nexport interface OutboundFetchLookupRequest {\n  frontendSessionId: string;\n  method: string;\n  /** Full URL including query string. */\n  url: string;\n  /**\n   * Request body as captured by `readBodyWithCap`. The sidecar hashes this itself, so the\n   * hash it compares against a recording is derived from byte-identical input on both the\n   * record and replay sides.\n   */\n  requestBody?: CapturedBody;\n}\n\n/**\n * Either a recorded response to serve, or an instruction to let the real call through.\n * An unrecognised `outcome` must be treated as `passthrough`, so an older shim keeps\n * working against a newer sidecar.\n */\nexport type OutboundFetchLookupResponse =\n  | {\n      outcome: \"mock\";\n      statusCode: number;\n      body: string;\n      headers: Record<string, string>;\n    }\n  | { outcome: \"passthrough\" };\n"],"names":[],"mappings":";;;;;;;;AAMA,MAAa,2BAA2B;;AAGxC,MAAa,kCACX;;;;;AAMF,MAAa,6BAA6B;AAE1C,MAAa,sBAAsB;;;;;;AAOnC,MAAa,8BAA8B;AAC3C,MAAa,qCAAqC;;;;;;;;;AAUlD,MAAa,4BACX;;;;;;;;AASF,MAAa,mBAAmB,CAC9B,gBACA,2BACD","debugId":"532e3e0d-6b1c-51c2-8086-a05de2625e79"}

package/dist/redact-body.d.ts

@@ -0,0 +1,19 @@
+//#region src/redact-body.d.ts
+/** Replacement for a redacted value. Matches the Node recorder's redaction marker. */
+declare const STR_REDACTED = "REDACTED";
+/**
+ * Redacts secret-looking fields from a captured request body, returning the body unchanged
+ * if it is not JSON.
+ *
+ * Applied to request bodies only. Response bodies must stay byte-exact: replay serves them
+ * back to the app, so redacting one would corrupt what the app receives. Request bodies are
+ * only ever used to key a lookup, and because the same function runs on both the record and
+ * the replay side the keys still agree.
+ *
+ * Never throws — a body that cannot be parsed or re-serialized is returned as-is, which is
+ * no worse than today's behaviour.
+ */
+declare const redactRequestBody: (body: string) => string;
+//#endregion
+export { STR_REDACTED, redactRequestBody };
+//# sourceMappingURL=redact-body.d.ts.map

package/dist/redact-body.js

@@ -0,0 +1,53 @@
+//#region src/redact-body.ts
+/** Replacement for a redacted value. Matches the Node recorder's redaction marker. */
+
+!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]="36ac86ad-0c78-5b5e-87b8-88acca7728a4")}catch(e){}}();
+const STR_REDACTED = "REDACTED";
+const secretKeys = new Set([
+	"accesstoken",
+	"apikey",
+	"authorization",
+	"clientsecret",
+	"credential",
+	"idtoken",
+	"password",
+	"privatekey",
+	"refreshtoken",
+	"secret",
+	"token"
+]);
+const normalizeKey = (key) => key.toLowerCase().replace(/[_-]/g, "");
+const isSecretKey = (key) => secretKeys.has(normalizeKey(key));
+/**
+* Redacts secret-looking fields from a captured request body, returning the body unchanged
+* if it is not JSON.
+*
+* Applied to request bodies only. Response bodies must stay byte-exact: replay serves them
+* back to the app, so redacting one would corrupt what the app receives. Request bodies are
+* only ever used to key a lookup, and because the same function runs on both the record and
+* the replay side the keys still agree.
+*
+* Never throws — a body that cannot be parsed or re-serialized is returned as-is, which is
+* no worse than today's behaviour.
+*/
+const redactRequestBody = (body) => {
+	if (body.length === 0) return body;
+	try {
+		const redacted = redactValue(JSON.parse(body));
+		return JSON.stringify(redacted) ?? body;
+	} catch {
+		return body;
+	}
+};
+const redactValue = (value) => {
+	if (Array.isArray(value)) return value.map(redactValue);
+	if (value === null || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, nested] of Object.entries(value)) result[key] = isSecretKey(key) ? STR_REDACTED : redactValue(nested);
+	return result;
+};
+//#endregion
+export { STR_REDACTED, redactRequestBody };
+
+//# sourceMappingURL=redact-body.js.map
+//# debugId=36ac86ad-0c78-5b5e-87b8-88acca7728a4

package/dist/redact-body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact-body.js","sources":["../src/redact-body.ts"],"sourcesContent":["/** Replacement for a redacted value. Matches the Node recorder's redaction marker. */\nexport const STR_REDACTED = \"REDACTED\";\n\n/**\n * Object keys whose values are replaced before a captured request body leaves the worker.\n *\n * Request bodies are captured verbatim, and plenty of APIs carry a credential in the body\n * rather than a header — an OAuth2 token exchange, or a feature-flag resolver that takes its\n * client secret as a JSON field. Header redaction (an allow-list of two) does nothing for\n * those, so without this the credential would be persisted in the recorded span.\n *\n * Compared case-insensitively, ignoring `_` and `-`, so `clientSecret`, `client_secret` and\n * `CLIENT-SECRET` all match one entry.\n */\nconst SECRET_KEYS = [\n  \"accesstoken\",\n  \"apikey\",\n  \"authorization\",\n  \"clientsecret\",\n  \"credential\",\n  \"idtoken\",\n  \"password\",\n  \"privatekey\",\n  \"refreshtoken\",\n  \"secret\",\n  \"token\",\n] as const;\n\nconst secretKeys = new Set<string>(SECRET_KEYS);\n\nconst normalizeKey = (key: string): string =>\n  key.toLowerCase().replace(/[_-]/g, \"\");\n\nconst isSecretKey = (key: string): boolean => secretKeys.has(normalizeKey(key));\n\n/**\n * Redacts secret-looking fields from a captured request body, returning the body unchanged\n * if it is not JSON.\n *\n * Applied to request bodies only. Response bodies must stay byte-exact: replay serves them\n * back to the app, so redacting one would corrupt what the app receives. Request bodies are\n * only ever used to key a lookup, and because the same function runs on both the record and\n * the replay side the keys still agree.\n *\n * Never throws — a body that cannot be parsed or re-serialized is returned as-is, which is\n * no worse than today's behaviour.\n */\nexport const redactRequestBody = (body: string): string => {\n  if (body.length === 0) {\n    return body;\n  }\n  try {\n    const parsed: unknown = JSON.parse(body);\n    const redacted = redactValue(parsed);\n    const serialized = JSON.stringify(redacted);\n    return serialized ?? body;\n  } catch {\n    // Not JSON (form-encoded, protobuf, plain text) — left alone rather than mangled.\n    return body;\n  }\n};\n\nconst redactValue = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    return value.map(redactValue);\n  }\n  if (value === null || typeof value !== \"object\") {\n    return value;\n  }\n  const result: Record<string, unknown> = {};\n  for (const [key, nested] of Object.entries(value)) {\n    result[key] = isSecretKey(key) ? STR_REDACTED : redactValue(nested);\n  }\n  return result;\n};\n"],"names":[],"mappings":";;;;AACA,MAAa,eAAe;AA2B5B,MAAM,aAAa,IAAI,IAAY;CAbjC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAG4C,CAAC;AAE/C,MAAM,gBAAgB,QACpB,IAAI,aAAa,CAAC,QAAQ,SAAS,GAAG;AAExC,MAAM,eAAe,QAAyB,WAAW,IAAI,aAAa,IAAI,CAAC;;;;;;;;;;;;;AAc/E,MAAa,qBAAqB,SAAyB;AACzD,KAAI,KAAK,WAAW,EAClB,QAAO;AAET,KAAI;EAEF,MAAM,WAAW,YADO,KAAK,MAAM,KACA,CAAC;AAEpC,SADmB,KAAK,UAAU,SACjB,IAAI;SACf;AAEN,SAAO;;;AAIX,MAAM,eAAe,UAA4B;AAC/C,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,IAAI,YAAY;AAE/B,KAAI,UAAU,QAAQ,OAAO,UAAU,SACrC,QAAO;CAET,MAAM,SAAkC,EAAE;AAC1C,MAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,MAAM,CAC/C,QAAO,OAAO,YAAY,IAAI,GAAG,eAAe,YAAY,OAAO;AAErE,QAAO","debugId":"36ac86ad-0c78-5b5e-87b8-88acca7728a4"}

package/dist/replay-fetch.js

@@ -0,0 +1,81 @@
+
+!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]="378556a4-8a50-5671-a66d-eda7ae1c0626")}catch(e){}}();
+import { warnOnce } from "./log.js";
+import { readRequestBodyWithCap } from "./body-capture.js";
+import { getOriginalFetch } from "./original-fetch.js";
+import { postOutboundFetchLookup } from "./sidecar-client.js";
+//#region src/replay-fetch.ts
+/**
+* Serves a recorded response for an outbound call, or lets the real one through.
+*
+* The mirror image of `captureOutboundCall`: recording tees a call that happens anyway,
+* whereas replay decides first and only then calls — so the sidecar sits in the request
+* path here, and every failure mode below falls back to `invoke`.
+*
+* A miss always falls through to the real service rather than erroring. Recordings are
+* legitimately incomplete — anything the app cached during recording (e.g. public JWKs held
+* in a KV namespace) is never captured, and is fetched for real when replay starts with a
+* cold cache.
+*/
+const replayOutboundCall = async (ctx, request, invoke) => {
+	let lookup;
+	try {
+		const requestBody = request.body ? await readRequestBodyWithCap(request.clone().body).catch(() => void 0) : void 0;
+		lookup = {
+			frontendSessionId: ctx.frontendSessionId,
+			method: request.method,
+			url: request.url,
+			...requestBody !== void 0 ? { requestBody } : {}
+		};
+	} catch (error) {
+		warnOnce("replay-lookup-build", "Failed to prepare a mock lookup — letting the real call through.", error);
+		return invoke(request);
+	}
+	const result = await postOutboundFetchLookup(getOriginalFetch(), ctx.sidecarUrl, lookup);
+	if (result?.outcome !== "mock") return invoke(request);
+	return buildMockResponse(result) ?? invoke(request);
+};
+const HEADERS_TO_DROP = new Set([
+	"content-encoding",
+	"content-length",
+	"transfer-encoding"
+]);
+const NULL_BODY_STATUSES = new Set([
+	101,
+	204,
+	205,
+	304
+]);
+/**
+* Turns a recorded response into a real one, or undefined if it cannot be represented (the
+* constructor throws a RangeError on an out-of-range status, or a body on a null-body
+* status), in which case the caller passes through.
+*
+* Note recorded headers are limited to CAPTURED_HEADERS, so a mocked response carries
+* essentially just content-type. In particular it can never set cookies — fine for the API
+* calls this path serves, but a real limitation for a backend that authenticates that way.
+*/
+const buildMockResponse = (mock) => {
+	try {
+		const headers = new Headers();
+		for (const [name, value] of Object.entries(mock.headers)) {
+			if (HEADERS_TO_DROP.has(name.toLowerCase())) continue;
+			try {
+				headers.set(name, value);
+			} catch {}
+		}
+		const body = NULL_BODY_STATUSES.has(mock.statusCode) ? null : mock.body;
+		return new Response(body, {
+			status: mock.statusCode,
+			headers
+		});
+	} catch (error) {
+		warnOnce("replay-mock-response", "Could not construct a mocked response — letting the real call through.", error);
+		return;
+	}
+};
+//#endregion
+export { replayOutboundCall };
+
+//# sourceMappingURL=replay-fetch.js.map
+//# debugId=378556a4-8a50-5671-a66d-eda7ae1c0626

package/dist/replay-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-fetch.js","sources":["../src/replay-fetch.ts"],"sourcesContent":["import { readRequestBodyWithCap } from \"./body-capture\";\nimport type { RequestReplayContext } from \"./context\";\nimport { warnOnce } from \"./log\";\nimport { getOriginalFetch } from \"./original-fetch\";\nimport type { OutboundFetchLookupRequest } from \"./protocol\";\nimport { postOutboundFetchLookup } from \"./sidecar-client\";\n\n/**\n * Serves a recorded response for an outbound call, or lets the real one through.\n *\n * The mirror image of `captureOutboundCall`: recording tees a call that happens anyway,\n * whereas replay decides first and only then calls — so the sidecar sits in the request\n * path here, and every failure mode below falls back to `invoke`.\n *\n * A miss always falls through to the real service rather than erroring. Recordings are\n * legitimately incomplete — anything the app cached during recording (e.g. public JWKs held\n * in a KV namespace) is never captured, and is fetched for real when replay starts with a\n * cold cache.\n */\nexport const replayOutboundCall = async (\n  ctx: RequestReplayContext,\n  request: Request,\n  invoke: (request: Request) => Promise<Response>,\n): Promise<Response> => {\n  let lookup: OutboundFetchLookupRequest;\n  try {\n    // Read the clone and pass the original through untouched, mirroring the record path —\n    // so the miss branch needs no body rebuild. The sidecar hashes what we send here, and\n    // it was captured by the same readRequestBodyWithCap the recorder used (redaction\n    // included), so the hashes on both sides derive from byte-identical input.\n    const requestBody = request.body\n      ? await readRequestBodyWithCap(request.clone().body).catch(\n          () => undefined,\n        )\n      : undefined;\n    lookup = {\n      frontendSessionId: ctx.frontendSessionId,\n      method: request.method,\n      url: request.url,\n      ...(requestBody !== undefined ? { requestBody } : {}),\n    };\n  } catch (error) {\n    warnOnce(\n      \"replay-lookup-build\",\n      \"Failed to prepare a mock lookup — letting the real call through.\",\n      error,\n    );\n    return invoke(request);\n  }\n\n  const result = await postOutboundFetchLookup(\n    getOriginalFetch(),\n    ctx.sidecarUrl,\n    lookup,\n  );\n  // Also covers an unrecognised `outcome` from a newer sidecar.\n  if (result?.outcome !== \"mock\") {\n    return invoke(request);\n  }\n  return buildMockResponse(result) ?? invoke(request);\n};\n\n// Recorded bodies are already decoded and may have been truncated, so the recorded framing\n// headers no longer describe them; the Response constructor recomputes what it needs.\nconst HEADERS_TO_DROP = new Set([\n  \"content-encoding\",\n  \"content-length\",\n  \"transfer-encoding\",\n]);\n\n// Statuses the Response constructor refuses to pair with a body.\nconst NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);\n\n/**\n * Turns a recorded response into a real one, or undefined if it cannot be represented (the\n * constructor throws a RangeError on an out-of-range status, or a body on a null-body\n * status), in which case the caller passes through.\n *\n * Note recorded headers are limited to CAPTURED_HEADERS, so a mocked response carries\n * essentially just content-type. In particular it can never set cookies — fine for the API\n * calls this path serves, but a real limitation for a backend that authenticates that way.\n */\nconst buildMockResponse = (mock: {\n  statusCode: number;\n  body: string;\n  headers: Record<string, string>;\n}): Response | undefined => {\n  try {\n    const headers = new Headers();\n    for (const [name, value] of Object.entries(mock.headers)) {\n      if (HEADERS_TO_DROP.has(name.toLowerCase())) {\n        continue;\n      }\n      try {\n        headers.set(name, value);\n      } catch {\n        // Skip a header name/value the runtime rejects rather than losing the whole mock.\n      }\n    }\n    const body = NULL_BODY_STATUSES.has(mock.statusCode) ? null : mock.body;\n    return new Response(body, { status: mock.statusCode, headers });\n  } catch (error) {\n    warnOnce(\n      \"replay-mock-response\",\n      \"Could not construct a mocked response — letting the real call through.\",\n      error,\n    );\n    return undefined;\n  }\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAa,qBAAqB,OAChC,KACA,SACA,WACsB;CACtB,IAAI;AACJ,KAAI;EAKF,MAAM,cAAc,QAAQ,OACxB,MAAM,uBAAuB,QAAQ,OAAO,CAAC,KAAK,CAAC,YAC3C,KAAA,EACP,GACD,KAAA;AACJ,WAAS;GACP,mBAAmB,IAAI;GACvB,QAAQ,QAAQ;GAChB,KAAK,QAAQ;GACb,GAAI,gBAAgB,KAAA,IAAY,EAAE,aAAa,GAAG,EAAE;GACrD;UACM,OAAO;AACd,WACE,uBACA,oEACA,MACD;AACD,SAAO,OAAO,QAAQ;;CAGxB,MAAM,SAAS,MAAM,wBACnB,kBAAkB,EAClB,IAAI,YACJ,OACD;AAED,KAAI,QAAQ,YAAY,OACtB,QAAO,OAAO,QAAQ;AAExB,QAAO,kBAAkB,OAAO,IAAI,OAAO,QAAQ;;AAKrD,MAAM,kBAAkB,IAAI,IAAI;CAC9B;CACA;CACA;CACD,CAAC;AAGF,MAAM,qBAAqB,IAAI,IAAI;CAAC;CAAK;CAAK;CAAK;CAAI,CAAC;;;;;;;;;;AAWxD,MAAM,qBAAqB,SAIC;AAC1B,KAAI;EACF,MAAM,UAAU,IAAI,SAAS;AAC7B,OAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,QAAQ,EAAE;AACxD,OAAI,gBAAgB,IAAI,KAAK,aAAa,CAAC,CACzC;AAEF,OAAI;AACF,YAAQ,IAAI,MAAM,MAAM;WAClB;;EAIV,MAAM,OAAO,mBAAmB,IAAI,KAAK,WAAW,GAAG,OAAO,KAAK;AACnE,SAAO,IAAI,SAAS,MAAM;GAAE,QAAQ,KAAK;GAAY;GAAS,CAAC;UACxD,OAAO;AACd,WACE,wBACA,0EACA,MACD;AACD","debugId":"378556a4-8a50-5671-a66d-eda7ae1c0626"}

package/dist/replay-sidecar-url.js

@@ -0,0 +1,62 @@
+
+!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]="94547b8a-bd87-50d7-ac87-204a0a65c1b7")}catch(e){}}();
+import { warnOnce } from "./log.js";
+//#region src/replay-sidecar-url.ts
+/**
+* Validation for the replay sidecar origin carried on inbound requests.
+*
+* The value arrives in a request header, so in principle anything that can reach the worker
+* can propose one — and the shim POSTs outbound request bodies to whatever it accepts. The
+* guard therefore only honours an origin that could plausibly be a Meticulous replay
+* sidecar running alongside the app: plaintext HTTP on a loopback, docker-gateway or
+* private-network host.
+*
+* `https:` is rejected deliberately. A sidecar reachable over loopback or a pod network has
+* no TLS to offer, so permitting `https:` would buy nothing except a way for a forged header
+* to exfiltrate request bodies to an arbitrary internet host.
+*/
+const MAX_URL_LENGTH = 2048;
+const ALLOWED_HOSTNAMES = new Set([
+	"localhost",
+	"host.docker.internal",
+	"host.containers.internal"
+]);
+const parseReplaySidecarUrl = (raw) => {
+	if (typeof raw !== "string" || raw.length === 0) return;
+	if (raw.length > MAX_URL_LENGTH) {
+		warnOnce("replay-sidecar-url", "Ignoring an implausibly long Meticulous replay sidecar URL.");
+		return;
+	}
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		warnOnce("replay-sidecar-url", "Ignoring an unparseable Meticulous replay sidecar URL.");
+		return;
+	}
+	if (!(url.protocol === "http:" && url.username === "" && url.password === "" && (url.pathname === "" || url.pathname === "/") && url.search === "" && url.hash === "" && isLocalHostname(url.hostname))) {
+		warnOnce("replay-sidecar-url", `Ignoring the Meticulous replay sidecar URL "${raw}" — only a plain http:// origin on a loopback, docker-gateway or private-network host is honoured.`);
+		return;
+	}
+	return url.origin;
+};
+const isLocalHostname = (hostname) => {
+	const lower = hostname.toLowerCase();
+	if (ALLOWED_HOSTNAMES.has(lower)) return true;
+	const unbracketed = lower.startsWith("[") && lower.endsWith("]") ? lower.slice(1, -1) : void 0;
+	if (unbracketed !== void 0) return unbracketed === "::1";
+	return isPrivateIpv4(lower);
+};
+const isPrivateIpv4 = (hostname) => {
+	const parts = hostname.split(".");
+	if (parts.length !== 4) return false;
+	const octets = parts.map((part) => /^\d{1,3}$/.test(part) ? Number(part) : NaN);
+	if (octets.some((octet) => Number.isNaN(octet) || octet > 255)) return false;
+	const [first, second] = octets;
+	return first === 127 || first === 10 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168;
+};
+//#endregion
+export { parseReplaySidecarUrl };
+
+//# sourceMappingURL=replay-sidecar-url.js.map
+//# debugId=94547b8a-bd87-50d7-ac87-204a0a65c1b7

package/dist/replay-sidecar-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-sidecar-url.js","sources":["../src/replay-sidecar-url.ts"],"sourcesContent":["import { warnOnce } from \"./log\";\n\n/**\n * Validation for the replay sidecar origin carried on inbound requests.\n *\n * The value arrives in a request header, so in principle anything that can reach the worker\n * can propose one — and the shim POSTs outbound request bodies to whatever it accepts. The\n * guard therefore only honours an origin that could plausibly be a Meticulous replay\n * sidecar running alongside the app: plaintext HTTP on a loopback, docker-gateway or\n * private-network host.\n *\n * `https:` is rejected deliberately. A sidecar reachable over loopback or a pod network has\n * no TLS to offer, so permitting `https:` would buy nothing except a way for a forged header\n * to exfiltrate request bodies to an arbitrary internet host.\n */\n\nconst MAX_URL_LENGTH = 2048;\n\nconst ALLOWED_HOSTNAMES = new Set([\n  \"localhost\",\n  // Docker Desktop and Podman expose the host to containers under these names.\n  \"host.docker.internal\",\n  \"host.containers.internal\",\n]);\n\nexport const parseReplaySidecarUrl = (\n  raw: string | null | undefined,\n): string | undefined => {\n  if (typeof raw !== \"string\" || raw.length === 0) {\n    return undefined;\n  }\n  if (raw.length > MAX_URL_LENGTH) {\n    warnOnce(\n      \"replay-sidecar-url\",\n      \"Ignoring an implausibly long Meticulous replay sidecar URL.\",\n    );\n    return undefined;\n  }\n\n  let url: URL;\n  try {\n    url = new URL(raw);\n  } catch {\n    warnOnce(\n      \"replay-sidecar-url\",\n      \"Ignoring an unparseable Meticulous replay sidecar URL.\",\n    );\n    return undefined;\n  }\n\n  const isAcceptable =\n    url.protocol === \"http:\" &&\n    url.username === \"\" &&\n    url.password === \"\" &&\n    (url.pathname === \"\" || url.pathname === \"/\") &&\n    url.search === \"\" &&\n    url.hash === \"\" &&\n    isLocalHostname(url.hostname);\n\n  if (!isAcceptable) {\n    warnOnce(\n      \"replay-sidecar-url\",\n      `Ignoring the Meticulous replay sidecar URL \"${raw}\" — only a plain http:// origin on a loopback, docker-gateway or private-network host is honoured.`,\n    );\n    return undefined;\n  }\n\n  // Return the parsed origin rather than the raw string: it is what `fetch` would resolve\n  // the value to anyway, so the host that was validated is exactly the host that gets\n  // called (alternative IPv4 spellings like \"0177.0.0.1\" normalize here, rather than being\n  // checked in one form and dialled in another). Carries no trailing slash, matching\n  // resolveSidecarUrl's normalization so the self-capture prefix check lines up.\n  return url.origin;\n};\n\nconst isLocalHostname = (hostname: string): boolean => {\n  const lower = hostname.toLowerCase();\n  if (ALLOWED_HOSTNAMES.has(lower)) {\n    return true;\n  }\n  // URL keeps IPv6 literals bracketed.\n  const unbracketed =\n    lower.startsWith(\"[\") && lower.endsWith(\"]\")\n      ? lower.slice(1, -1)\n      : undefined;\n  if (unbracketed !== undefined) {\n    return unbracketed === \"::1\";\n  }\n  return isPrivateIpv4(lower);\n};\n\nconst isPrivateIpv4 = (hostname: string): boolean => {\n  const parts = hostname.split(\".\");\n  if (parts.length !== 4) {\n    return false;\n  }\n  const octets = parts.map((part) =>\n    // Reject anything that is not a plain decimal octet: \"010\" and \"0x7f\" are parsed\n    // inconsistently across resolvers, and \"1e2\" would pass a bare Number() check.\n    /^\\d{1,3}$/.test(part) ? Number(part) : Number.NaN,\n  );\n  if (octets.some((octet) => Number.isNaN(octet) || octet > 255)) {\n    return false;\n  }\n  const [first, second] = octets;\n  // Deliberately excludes link-local (169.254.0.0/16): no sidecar is ever reachable there,\n  // but the cloud metadata endpoints are (169.254.169.254), so allowing it would only widen\n  // the SSRF surface. The rest of the codebase blocks that range for the same reason — see\n  // `staging-backend-url.ts` and `assets-app-server.ts`.\n  return (\n    first === 127 || // loopback\n    first === 10 || // RFC1918\n    (first === 172 && second >= 16 && second <= 31) || // RFC1918\n    (first === 192 && second === 168) // RFC1918\n  );\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,iBAAiB;AAEvB,MAAM,oBAAoB,IAAI,IAAI;CAChC;CAEA;CACA;CACD,CAAC;AAEF,MAAa,yBACX,QACuB;AACvB,KAAI,OAAO,QAAQ,YAAY,IAAI,WAAW,EAC5C;AAEF,KAAI,IAAI,SAAS,gBAAgB;AAC/B,WACE,sBACA,8DACD;AACD;;CAGF,IAAI;AACJ,KAAI;AACF,QAAM,IAAI,IAAI,IAAI;SACZ;AACN,WACE,sBACA,yDACD;AACD;;AAYF,KAAI,EARF,IAAI,aAAa,WACjB,IAAI,aAAa,MACjB,IAAI,aAAa,OAChB,IAAI,aAAa,MAAM,IAAI,aAAa,QACzC,IAAI,WAAW,MACf,IAAI,SAAS,MACb,gBAAgB,IAAI,SAAS,GAEZ;AACjB,WACE,sBACA,+CAA+C,IAAI,oGACpD;AACD;;AAQF,QAAO,IAAI;;AAGb,MAAM,mBAAmB,aAA8B;CACrD,MAAM,QAAQ,SAAS,aAAa;AACpC,KAAI,kBAAkB,IAAI,MAAM,CAC9B,QAAO;CAGT,MAAM,cACJ,MAAM,WAAW,IAAI,IAAI,MAAM,SAAS,IAAI,GACxC,MAAM,MAAM,GAAG,GAAG,GAClB,KAAA;AACN,KAAI,gBAAgB,KAAA,EAClB,QAAO,gBAAgB;AAEzB,QAAO,cAAc,MAAM;;AAG7B,MAAM,iBAAiB,aAA8B;CACnD,MAAM,QAAQ,SAAS,MAAM,IAAI;AACjC,KAAI,MAAM,WAAW,EACnB,QAAO;CAET,MAAM,SAAS,MAAM,KAAK,SAGxB,YAAY,KAAK,KAAK,GAAG,OAAO,KAAK,GAAG,IACzC;AACD,KAAI,OAAO,MAAM,UAAU,OAAO,MAAM,MAAM,IAAI,QAAQ,IAAI,CAC5D,QAAO;CAET,MAAM,CAAC,OAAO,UAAU;AAKxB,QACE,UAAU,OACV,UAAU,MACT,UAAU,OAAO,UAAU,MAAM,UAAU,MAC3C,UAAU,OAAO,WAAW","debugId":"94547b8a-bd87-50d7-ac87-204a0a65c1b7"}

package/dist/sidecar-client.js

@@ -1,8 +1,15 @@
 
-!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]="4fd3fc64-97ce-5a60-ae98-b07904e43cf9")}catch(e){}}();
+!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]="81b6dfa3-bea2-53e3-a6be-f23b3b050e4c")}catch(e){}}();
 import { warnOnce } from "./log.js";
-import { SIDECAR_EVENTS_PATH, SIDECAR_PROTOCOL_VERSION_HEADER } from "./protocol.js";
+import { SIDECAR_EVENTS_PATH, SIDECAR_PROTOCOL_VERSION_HEADER, SIDECAR_REPLAY_OUTBOUND_FETCH_PATH, SIDECAR_REPLAY_SESSION_PATH } from "./protocol.js";
 //#region src/sidecar-client.ts
+/**
+* Replay calls sit in the request path, unlike record mode's fire-and-forget reporting, so
+* they must be bounded: without a timeout a wedged sidecar would hang every outbound fetch
+* the app makes, and therefore the whole replay, with nothing to look at.
+*/
+const SESSION_INFO_TIMEOUT_MS = 1e4;
+const LOOKUP_TIMEOUT_MS = 5e3;
 /** POSTs capture events to the sidecar. Never rejects — reporting failures only warn (once). */
 const postCaptureEvents = async (fetchFn, sidecarUrl, events) => {
 	try {
@@ -21,8 +28,80 @@ const postCaptureEvents = async (fetchFn, sidecarUrl, events) => {
 		warnOnce("sidecar-unreachable", "Could not reach the Meticulous backend recorder sidecar — backend session events are not being recorded.", error);
 	}
 };
+/**
+* Asks whether the sidecar holds mocks for a session, and at what instant to freeze the
+* clock while serving it.
+*
+* A 404 is how a record-only sidecar answers, so it counts as a settled `unavailable` and
+* the shim degrades to pass-through against an older sidecar rather than failing.
+*/
+const getReplaySessionInfo = async (fetchFn, sidecarUrl, frontendSessionId) => {
+	const url = `${sidecarUrl}${SIDECAR_REPLAY_SESSION_PATH}?sessionId=${encodeURIComponent(frontendSessionId)}`;
+	try {
+		const response = await fetchFn(url, {
+			headers: { [SIDECAR_PROTOCOL_VERSION_HEADER]: "1" },
+			signal: timeoutSignal(SESSION_INFO_TIMEOUT_MS)
+		});
+		if (!response.ok) {
+			await response.arrayBuffer().catch(() => void 0);
+			if (response.status >= 500) {
+				warnOnce("replay-session-unreachable", `Meticulous replay sidecar failed the replay session handshake (HTTP ${response.status}) — will retry on the next request.`);
+				return { outcome: "unreachable" };
+			}
+			warnOnce("replay-session-unavailable", `Meticulous replay sidecar did not recognise the replay session route (HTTP ${response.status}) — outbound calls will not be mocked.`);
+			return { outcome: "unavailable" };
+		}
+		const info = await response.json();
+		if (info.found !== true) {
+			warnOnce("replay-session-unknown", "Meticulous replay sidecar holds no mocks for this session — outbound calls will not be mocked.");
+			return { outcome: "unavailable" };
+		}
+		return {
+			outcome: "found",
+			clockAnchorMs: typeof info.clockAnchorMs === "number" ? info.clockAnchorMs : void 0
+		};
+	} catch (error) {
+		warnOnce("replay-session-unreachable", "Could not reach the Meticulous replay sidecar — will retry on the next request.", error);
+		return { outcome: "unreachable" };
+	}
+};
+/**
+* Looks up a recorded response for one outbound call. Never rejects; returns undefined when
+* the sidecar could not be consulted, which callers treat the same as a miss (let the real
+* call through).
+*/
+const postOutboundFetchLookup = async (fetchFn, sidecarUrl, payload) => {
+	try {
+		const response = await fetchFn(`${sidecarUrl}${SIDECAR_REPLAY_OUTBOUND_FETCH_PATH}`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				[SIDECAR_PROTOCOL_VERSION_HEADER]: "1"
+			},
+			body: JSON.stringify(payload),
+			signal: timeoutSignal(LOOKUP_TIMEOUT_MS)
+		});
+		if (!response.ok) {
+			warnOnce("replay-lookup-rejected", `Meticulous replay sidecar rejected a mock lookup (HTTP ${response.status}).`);
+			await response.arrayBuffer().catch(() => void 0);
+			return;
+		}
+		return await response.json();
+	} catch (error) {
+		warnOnce("replay-lookup-unreachable", "Could not reach the Meticulous replay sidecar for a mock lookup — letting the real call through.", error);
+		return;
+	}
+};
+/** AbortSignal.timeout, or undefined where it is unavailable. */
+const timeoutSignal = (ms) => {
+	try {
+		return AbortSignal.timeout(ms);
+	} catch {
+		return;
+	}
+};
 //#endregion
-export { postCaptureEvents };
+export { getReplaySessionInfo, postCaptureEvents, postOutboundFetchLookup };
 
 //# sourceMappingURL=sidecar-client.js.map
-//# debugId=4fd3fc64-97ce-5a60-ae98-b07904e43cf9
+//# debugId=81b6dfa3-bea2-53e3-a6be-f23b3b050e4c

package/dist/sidecar-client.js.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-client.js","sources":["../src/sidecar-client.ts"],"sourcesContent":["import { warnOnce } from \"./log\";\nimport {\n  type CaptureEvent,\n  type CaptureEventsPayload,\n  SIDECAR_EVENTS_PATH,\n  SIDECAR_PROTOCOL_VERSION,\n  SIDECAR_PROTOCOL_VERSION_HEADER,\n} from \"./protocol\";\n\ntype FetchFn = typeof globalThis.fetch;\n\n/** POSTs capture events to the sidecar. Never rejects — reporting failures only warn (once). */\nexport const postCaptureEvents = async (\n  fetchFn: FetchFn,\n  sidecarUrl: string,\n  events: CaptureEvent[],\n): Promise<void> => {\n  try {\n    const payload: CaptureEventsPayload = { events };\n    const response = await fetchFn(`${sidecarUrl}${SIDECAR_EVENTS_PATH}`, {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        [SIDECAR_PROTOCOL_VERSION_HEADER]: SIDECAR_PROTOCOL_VERSION,\n      },\n      body: JSON.stringify(payload),\n    });\n    if (!response.ok) {\n      warnOnce(\n        \"sidecar-rejected\",\n        `Meticulous sidecar rejected capture events (HTTP ${response.status}).`,\n      );\n    }\n    await response.arrayBuffer().catch(() => undefined);\n  } catch (error) {\n    warnOnce(\n      \"sidecar-unreachable\",\n      \"Could not reach the Meticulous backend recorder sidecar — backend session events are not being recorded.\",\n      error,\n    );\n  }\n};\n"],"names":[],"mappings":";;;;;;AAYA,MAAa,oBAAoB,OAC/B,SACA,YACA,WACkB;AAClB,KAAI;EACF,MAAM,UAAgC,EAAE,QAAQ;EAChD,MAAM,WAAW,MAAM,QAAQ,GAAG,aAAa,uBAAuB;GACpE,QAAQ;GACR,SAAS;IACP,gBAAgB;KACf,kCAAA;IACF;GACD,MAAM,KAAK,UAAU,QAAQ;GAC9B,CAAC;AACF,MAAI,CAAC,SAAS,GACZ,UACE,oBACA,oDAAoD,SAAS,OAAO,IACrE;AAEH,QAAM,SAAS,aAAa,CAAC,YAAY,KAAA,EAAU;UAC5C,OAAO;AACd,WACE,uBACA,4GACA,MACD","debugId":"4fd3fc64-97ce-5a60-ae98-b07904e43cf9"}
+{"version":3,"file":"sidecar-client.js","sources":["../src/sidecar-client.ts"],"sourcesContent":["import { warnOnce } from \"./log\";\nimport {\n  type CaptureEvent,\n  type CaptureEventsPayload,\n  type OutboundFetchLookupRequest,\n  type OutboundFetchLookupResponse,\n  type ReplaySessionInfoResponse,\n  SIDECAR_EVENTS_PATH,\n  SIDECAR_PROTOCOL_VERSION,\n  SIDECAR_PROTOCOL_VERSION_HEADER,\n  SIDECAR_REPLAY_OUTBOUND_FETCH_PATH,\n  SIDECAR_REPLAY_SESSION_PATH,\n} from \"./protocol\";\n\ntype FetchFn = typeof globalThis.fetch;\n\n/**\n * Replay calls sit in the request path, unlike record mode's fire-and-forget reporting, so\n * they must be bounded: without a timeout a wedged sidecar would hang every outbound fetch\n * the app makes, and therefore the whole replay, with nothing to look at.\n */\nconst SESSION_INFO_TIMEOUT_MS = 10_000;\nconst LOOKUP_TIMEOUT_MS = 5_000;\n\n/** POSTs capture events to the sidecar. Never rejects — reporting failures only warn (once). */\nexport const postCaptureEvents = async (\n  fetchFn: FetchFn,\n  sidecarUrl: string,\n  events: CaptureEvent[],\n): Promise<void> => {\n  try {\n    const payload: CaptureEventsPayload = { events };\n    const response = await fetchFn(`${sidecarUrl}${SIDECAR_EVENTS_PATH}`, {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        [SIDECAR_PROTOCOL_VERSION_HEADER]: SIDECAR_PROTOCOL_VERSION,\n      },\n      body: JSON.stringify(payload),\n    });\n    if (!response.ok) {\n      warnOnce(\n        \"sidecar-rejected\",\n        `Meticulous sidecar rejected capture events (HTTP ${response.status}).`,\n      );\n    }\n    await response.arrayBuffer().catch(() => undefined);\n  } catch (error) {\n    warnOnce(\n      \"sidecar-unreachable\",\n      \"Could not reach the Meticulous backend recorder sidecar — backend session events are not being recorded.\",\n      error,\n    );\n  }\n};\n\n/**\n * Outcome of the session handshake.\n *\n * `unavailable` and `unreachable` both mean \"do not replay\", but they are kept apart\n * because only the first is a settled answer. The caller caches per isolate, and caching a\n * one-off network blip would disable mocking for the rest of the session — silently sending\n * every later outbound call to the real service.\n */\nexport type ReplaySessionInfoResult =\n  /** The sidecar holds mocks for this session. */\n  | { outcome: \"found\"; clockAnchorMs: number | undefined }\n  /** The sidecar answered and will never serve this session: no mocks, or no such route. */\n  | { outcome: \"unavailable\" }\n  /** Could not get an answer — timeout, transport error, 5xx. May succeed later. */\n  | { outcome: \"unreachable\" };\n\n/**\n * Asks whether the sidecar holds mocks for a session, and at what instant to freeze the\n * clock while serving it.\n *\n * A 404 is how a record-only sidecar answers, so it counts as a settled `unavailable` and\n * the shim degrades to pass-through against an older sidecar rather than failing.\n */\nexport const getReplaySessionInfo = async (\n  fetchFn: FetchFn,\n  sidecarUrl: string,\n  frontendSessionId: string,\n): Promise<ReplaySessionInfoResult> => {\n  const url = `${sidecarUrl}${SIDECAR_REPLAY_SESSION_PATH}?sessionId=${encodeURIComponent(\n    frontendSessionId,\n  )}`;\n  try {\n    const response = await fetchFn(url, {\n      headers: {\n        [SIDECAR_PROTOCOL_VERSION_HEADER]: SIDECAR_PROTOCOL_VERSION,\n      },\n      signal: timeoutSignal(SESSION_INFO_TIMEOUT_MS),\n    });\n    if (!response.ok) {\n      await response.arrayBuffer().catch(() => undefined);\n      // 4xx is the sidecar telling us something definitive — no such route (a record-only\n      // sidecar), or a protocol version it will not speak. Retrying cannot change either.\n      // 5xx may well be a sidecar still finding its feet, so leave it retryable.\n      if (response.status >= 500) {\n        warnOnce(\n          \"replay-session-unreachable\",\n          `Meticulous replay sidecar failed the replay session handshake (HTTP ${response.status}) — will retry on the next request.`,\n        );\n        return { outcome: \"unreachable\" };\n      }\n      warnOnce(\n        \"replay-session-unavailable\",\n        `Meticulous replay sidecar did not recognise the replay session route (HTTP ${response.status}) — outbound calls will not be mocked.`,\n      );\n      return { outcome: \"unavailable\" };\n    }\n    const info = (await response.json()) as ReplaySessionInfoResponse;\n    if (info.found !== true) {\n      warnOnce(\n        \"replay-session-unknown\",\n        \"Meticulous replay sidecar holds no mocks for this session — outbound calls will not be mocked.\",\n      );\n      return { outcome: \"unavailable\" };\n    }\n    return {\n      outcome: \"found\",\n      clockAnchorMs:\n        typeof info.clockAnchorMs === \"number\" ? info.clockAnchorMs : undefined,\n    };\n  } catch (error) {\n    warnOnce(\n      \"replay-session-unreachable\",\n      \"Could not reach the Meticulous replay sidecar — will retry on the next request.\",\n      error,\n    );\n    return { outcome: \"unreachable\" };\n  }\n};\n\n/**\n * Looks up a recorded response for one outbound call. Never rejects; returns undefined when\n * the sidecar could not be consulted, which callers treat the same as a miss (let the real\n * call through).\n */\nexport const postOutboundFetchLookup = async (\n  fetchFn: FetchFn,\n  sidecarUrl: string,\n  payload: OutboundFetchLookupRequest,\n): Promise<OutboundFetchLookupResponse | undefined> => {\n  try {\n    const response = await fetchFn(\n      `${sidecarUrl}${SIDECAR_REPLAY_OUTBOUND_FETCH_PATH}`,\n      {\n        method: \"POST\",\n        headers: {\n          \"content-type\": \"application/json\",\n          [SIDECAR_PROTOCOL_VERSION_HEADER]: SIDECAR_PROTOCOL_VERSION,\n        },\n        body: JSON.stringify(payload),\n        signal: timeoutSignal(LOOKUP_TIMEOUT_MS),\n      },\n    );\n    if (!response.ok) {\n      warnOnce(\n        \"replay-lookup-rejected\",\n        `Meticulous replay sidecar rejected a mock lookup (HTTP ${response.status}).`,\n      );\n      await response.arrayBuffer().catch(() => undefined);\n      return undefined;\n    }\n    return (await response.json()) as OutboundFetchLookupResponse;\n  } catch (error) {\n    warnOnce(\n      \"replay-lookup-unreachable\",\n      \"Could not reach the Meticulous replay sidecar for a mock lookup — letting the real call through.\",\n      error,\n    );\n    return undefined;\n  }\n};\n\n/** AbortSignal.timeout, or undefined where it is unavailable. */\nconst timeoutSignal = (ms: number): AbortSignal | undefined => {\n  try {\n    return AbortSignal.timeout(ms);\n  } catch {\n    return undefined;\n  }\n};\n"],"names":[],"mappings":";;;;;;;;;;AAqBA,MAAM,0BAA0B;AAChC,MAAM,oBAAoB;;AAG1B,MAAa,oBAAoB,OAC/B,SACA,YACA,WACkB;AAClB,KAAI;EACF,MAAM,UAAgC,EAAE,QAAQ;EAChD,MAAM,WAAW,MAAM,QAAQ,GAAG,aAAa,uBAAuB;GACpE,QAAQ;GACR,SAAS;IACP,gBAAgB;KACf,kCAAA;IACF;GACD,MAAM,KAAK,UAAU,QAAQ;GAC9B,CAAC;AACF,MAAI,CAAC,SAAS,GACZ,UACE,oBACA,oDAAoD,SAAS,OAAO,IACrE;AAEH,QAAM,SAAS,aAAa,CAAC,YAAY,KAAA,EAAU;UAC5C,OAAO;AACd,WACE,uBACA,4GACA,MACD;;;;;;;;;;AA2BL,MAAa,uBAAuB,OAClC,SACA,YACA,sBACqC;CACrC,MAAM,MAAM,GAAG,aAAa,4BAA4B,aAAa,mBACnE,kBACD;AACD,KAAI;EACF,MAAM,WAAW,MAAM,QAAQ,KAAK;GAClC,SAAS,GACN,kCAAA,KACF;GACD,QAAQ,cAAc,wBAAwB;GAC/C,CAAC;AACF,MAAI,CAAC,SAAS,IAAI;AAChB,SAAM,SAAS,aAAa,CAAC,YAAY,KAAA,EAAU;AAInD,OAAI,SAAS,UAAU,KAAK;AAC1B,aACE,8BACA,uEAAuE,SAAS,OAAO,qCACxF;AACD,WAAO,EAAE,SAAS,eAAe;;AAEnC,YACE,8BACA,8EAA8E,SAAS,OAAO,wCAC/F;AACD,UAAO,EAAE,SAAS,eAAe;;EAEnC,MAAM,OAAQ,MAAM,SAAS,MAAM;AACnC,MAAI,KAAK,UAAU,MAAM;AACvB,YACE,0BACA,iGACD;AACD,UAAO,EAAE,SAAS,eAAe;;AAEnC,SAAO;GACL,SAAS;GACT,eACE,OAAO,KAAK,kBAAkB,WAAW,KAAK,gBAAgB,KAAA;GACjE;UACM,OAAO;AACd,WACE,8BACA,mFACA,MACD;AACD,SAAO,EAAE,SAAS,eAAe;;;;;;;;AASrC,MAAa,0BAA0B,OACrC,SACA,YACA,YACqD;AACrD,KAAI;EACF,MAAM,WAAW,MAAM,QACrB,GAAG,aAAa,sCAChB;GACE,QAAQ;GACR,SAAS;IACP,gBAAgB;KACf,kCAAA;IACF;GACD,MAAM,KAAK,UAAU,QAAQ;GAC7B,QAAQ,cAAc,kBAAkB;GACzC,CACF;AACD,MAAI,CAAC,SAAS,IAAI;AAChB,YACE,0BACA,0DAA0D,SAAS,OAAO,IAC3E;AACD,SAAM,SAAS,aAAa,CAAC,YAAY,KAAA,EAAU;AACnD;;AAEF,SAAQ,MAAM,SAAS,MAAM;UACtB,OAAO;AACd,WACE,6BACA,oGACA,MACD;AACD;;;;AAKJ,MAAM,iBAAiB,OAAwC;AAC7D,KAAI;AACF,SAAO,YAAY,QAAQ,GAAG;SACxB;AACN","debugId":"81b6dfa3-bea2-53e3-a6be-f23b3b050e4c"}

package/dist/virtual-clock.js

@@ -0,0 +1,122 @@
+
+!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]="ef892b9a-fcab-5f5d-baed-592098a17dd5")}catch(e){}}();
+import { requestCaptureContext } from "./context.js";
+import { warnOnce } from "./log.js";
+//#region src/virtual-clock.ts
+/**
+* Freezes the worker's wall clock at the replayed session's last recorded activity.
+*
+* Without this, replay fails even when every outbound call is mocked correctly: credentials
+* minted during the recording (Firebase session cookies, OAuth access tokens) carry
+* short expiries, so by replay time the app rejects its own recorded credentials as stale.
+* Anchoring at the *end* of the recording means everything minted mid-session is already
+* issued but not yet expired.
+*
+* Ported from the Node backend recorder's replay clock, with two differences:
+*   - the anchor comes from the request context rather than a session→anchor map, because
+*     workerd's AsyncLocalStorage propagates reliably from the inbound handler. The Node
+*     version needs a process-wide "most recently seen session" fallback, which can
+*     resolve the wrong session on a replica serving several at once;
+*   - the busy-wait breaker schedules on `setTimeout` — workerd has no `setImmediate`.
+*
+* Only `Date` is patched, matching the Node implementation's scope (no `Intl`, no
+* `Temporal`, no timer virtualisation).
+*/
+const OriginalDate = globalThis.Date;
+const BREAK_AFTER = 2e4;
+let lastLoopBreakBaseMs = 0;
+let sameKeyCount = 0;
+let loopBreakResetScheduled = false;
+const applyLoopBreak = (baseMs) => {
+	if (!loopBreakResetScheduled) {
+		loopBreakResetScheduled = true;
+		try {
+			setTimeout(() => {
+				sameKeyCount = 0;
+				loopBreakResetScheduled = false;
+			}, 0);
+		} catch {
+			loopBreakResetScheduled = false;
+		}
+	}
+	if (baseMs === lastLoopBreakBaseMs) sameKeyCount++;
+	else {
+		lastLoopBreakBaseMs = baseMs;
+		sameKeyCount = 0;
+	}
+	return sameKeyCount <= BREAK_AFTER ? baseMs : baseMs + (sameKeyCount - BREAK_AFTER);
+};
+/**
+* The virtual "now" for the request currently executing, or null when it is not a replay or
+* carries no anchor — in which case callers use the real clock. Reads outside any request
+* (module evaluation, background work) always get the real clock.
+*/
+const resolveVirtualNow = () => {
+	const ctx = requestCaptureContext.getStore();
+	if (ctx === void 0 || ctx.mode !== "replay") return null;
+	return ctx.clockAnchorMs === void 0 ? null : applyLoopBreak(ctx.clockAnchorMs);
+};
+/**
+* What `Date.now()` reports. A standalone function rather than only a class static, so the
+* callable shim below can reuse it without referencing an unbound method — it touches no
+* `this`, so there is nothing to lose.
+*/
+const virtualDateNow = () => {
+	const virtualNow = resolveVirtualNow();
+	return virtualNow === null ? OriginalDate.now() : virtualNow;
+};
+var VirtualDateClass = class extends OriginalDate {
+	constructor(...args) {
+		if (args.length > 0) {
+			super(...args);
+			return;
+		}
+		const virtualNow = resolveVirtualNow();
+		if (virtualNow === null) {
+			super();
+			return;
+		}
+		super(virtualNow);
+	}
+	static now() {
+		return virtualDateNow();
+	}
+};
+function VirtualDate(...args) {
+	if (!(this instanceof VirtualDate)) return new VirtualDateClass().toString();
+	return new VirtualDateClass(...args);
+}
+VirtualDate.now = virtualDateNow;
+VirtualDate.parse = OriginalDate.parse;
+VirtualDate.UTC = OriginalDate.UTC;
+Object.defineProperty(VirtualDate, "prototype", {
+	value: VirtualDateClass.prototype,
+	writable: false,
+	configurable: false
+});
+VirtualDateClass.prototype.constructor = VirtualDate;
+let installed = false;
+/**
+* Replaces the global `Date` with the per-request virtual clock. Idempotent, and a no-op
+* failure: a worker that will not let its `Date` be replaced still replays, just without
+* clock virtualisation.
+*
+* Called lazily from the replay branch of the request wrapper rather than at module scope:
+* 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 installVirtualClock = () => {
+	if (installed) return;
+	installed = true;
+	try {
+		globalThis.Date = VirtualDate;
+	} catch (error) {
+		warnOnce("virtual-clock", "Could not install the Meticulous replay clock — recorded credentials may be treated as expired.", error);
+	}
+};
+//#endregion
+export { installVirtualClock };
+
+//# sourceMappingURL=virtual-clock.js.map
+//# debugId=ef892b9a-fcab-5f5d-baed-592098a17dd5

package/dist/virtual-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-clock.js","sources":["../src/virtual-clock.ts"],"sourcesContent":["import { requestCaptureContext } from \"./context\";\nimport { warnOnce } from \"./log\";\n\n/**\n * Freezes the worker's wall clock at the replayed session's last recorded activity.\n *\n * Without this, replay fails even when every outbound call is mocked correctly: credentials\n * minted during the recording (Firebase session cookies, OAuth access tokens) carry\n * short expiries, so by replay time the app rejects its own recorded credentials as stale.\n * Anchoring at the *end* of the recording means everything minted mid-session is already\n * issued but not yet expired.\n *\n * Ported from the Node backend recorder's replay clock, with two differences:\n *   - the anchor comes from the request context rather than a session→anchor map, because\n *     workerd's AsyncLocalStorage propagates reliably from the inbound handler. The Node\n *     version needs a process-wide \"most recently seen session\" fallback, which can\n *     resolve the wrong session on a replica serving several at once;\n *   - the busy-wait breaker schedules on `setTimeout` — workerd has no `setImmediate`.\n *\n * Only `Date` is patched, matching the Node implementation's scope (no `Intl`, no\n * `Temporal`, no timer virtualisation).\n */\n\nconst OriginalDate = globalThis.Date;\n\n/** Real wall clock, immune to the patch below. */\nexport const nativeDateNow = (): number => OriginalDate.now();\n\n// ---------------------------------------------------------------------------\n// Busy-wait loop breaker\n// ---------------------------------------------------------------------------\n\n// A frozen clock makes `while (Date.now() < deadline) {}` spin forever. Count reads that\n// return the same frozen value and, past the threshold, nudge the result forward 1ms per\n// extra read until the loop's deadline is met. The nudge is a pure function of the repeat\n// count, so a base and head replay break an identical loop identically.\nconst BREAK_AFTER = 20_000;\n\nlet lastLoopBreakBaseMs = 0;\nlet sameKeyCount = 0;\nlet loopBreakResetScheduled = false;\n\nconst applyLoopBreak = (baseMs: number): number => {\n  // Reset at the end of the current macrotask. A synchronous busy-wait blocks the loop so\n  // this cannot fire, letting the counter accumulate until it breaks the spin; once the\n  // turn yields, the reset runs and the next turn starts fresh.\n  if (!loopBreakResetScheduled) {\n    loopBreakResetScheduled = true;\n    try {\n      setTimeout(() => {\n        sameKeyCount = 0;\n        loopBreakResetScheduled = false;\n      }, 0);\n    } catch {\n      // Timers throw outside a request context in workerd. Nothing to reset in that case,\n      // since clock reads there fall through to the real clock anyway.\n      loopBreakResetScheduled = false;\n    }\n  }\n\n  if (baseMs === lastLoopBreakBaseMs) {\n    sameKeyCount++;\n  } else {\n    lastLoopBreakBaseMs = baseMs;\n    sameKeyCount = 0;\n  }\n  return sameKeyCount <= BREAK_AFTER\n    ? baseMs\n    : baseMs + (sameKeyCount - BREAK_AFTER);\n};\n\n// ---------------------------------------------------------------------------\n// Resolver\n// ---------------------------------------------------------------------------\n\n/**\n * The virtual \"now\" for the request currently executing, or null when it is not a replay or\n * carries no anchor — in which case callers use the real clock. Reads outside any request\n * (module evaluation, background work) always get the real clock.\n */\nconst resolveVirtualNow = (): number | null => {\n  const ctx = requestCaptureContext.getStore();\n  if (ctx === undefined || ctx.mode !== \"replay\") {\n    return null;\n  }\n  return ctx.clockAnchorMs === undefined\n    ? null\n    : applyLoopBreak(ctx.clockAnchorMs);\n};\n\n// ---------------------------------------------------------------------------\n// Date shim\n// ---------------------------------------------------------------------------\n\n/**\n * What `Date.now()` reports. A standalone function rather than only a class static, so the\n * callable shim below can reuse it without referencing an unbound method — it touches no\n * `this`, so there is nothing to lose.\n */\nconst virtualDateNow = (): number => {\n  const virtualNow = resolveVirtualNow();\n  return virtualNow === null ? OriginalDate.now() : virtualNow;\n};\n\n// `Date` is heavily overloaded; capture args loosely and forward every explicit form\n// unchanged. Only the zero-arg form reads \"now\" and is virtualized.\nclass VirtualDateClass extends OriginalDate {\n  constructor(...args: unknown[]) {\n    if (args.length > 0) {\n      super(...(args as ConstructorParameters<typeof OriginalDate>));\n      return;\n    }\n    const virtualNow = resolveVirtualNow();\n    if (virtualNow === null) {\n      super();\n      return;\n    }\n    super(virtualNow);\n  }\n\n  static override now(): number {\n    return virtualDateNow();\n  }\n}\n\n// Classes cannot be called without `new`, but native `Date()` can be (returning a string),\n// so wrap the class in a plain function supporting both.\nfunction VirtualDate(this: unknown, ...args: unknown[]): Date | string {\n  if (!(this instanceof VirtualDate)) {\n    return new VirtualDateClass().toString();\n  }\n  return new VirtualDateClass(...args);\n}\n\nVirtualDate.now = virtualDateNow;\nVirtualDate.parse = OriginalDate.parse;\nVirtualDate.UTC = OriginalDate.UTC;\n\n// Share the prototype so `new Date() instanceof Date` holds and every Date.prototype\n// method resolves on instances.\nObject.defineProperty(VirtualDate, \"prototype\", {\n  value: VirtualDateClass.prototype,\n  writable: false,\n  configurable: false,\n});\n(VirtualDateClass.prototype as { constructor: unknown }).constructor =\n  VirtualDate;\n\n// ---------------------------------------------------------------------------\n// Install\n// ---------------------------------------------------------------------------\n\nlet installed = false;\n\n/**\n * Replaces the global `Date` with the per-request virtual clock. Idempotent, and a no-op\n * failure: a worker that will not let its `Date` be replaced still replays, just without\n * clock virtualisation.\n *\n * Called lazily from the replay branch of the request wrapper rather than at module scope:\n * record mode and deployed production workers then pay nothing, and the package declares no\n * `sideEffects`, so a module-scope side effect could legitimately be tree-shaken away by a\n * customer's bundler.\n */\nexport const installVirtualClock = (): void => {\n  if (installed) {\n    return;\n  }\n  installed = true;\n  try {\n    globalThis.Date = VirtualDate as unknown as DateConstructor;\n  } catch (error) {\n    warnOnce(\n      \"virtual-clock\",\n      \"Could not install the Meticulous replay clock — recorded credentials may be treated as expired.\",\n      error,\n    );\n  }\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,eAAe,WAAW;AAahC,MAAM,cAAc;AAEpB,IAAI,sBAAsB;AAC1B,IAAI,eAAe;AACnB,IAAI,0BAA0B;AAE9B,MAAM,kBAAkB,WAA2B;AAIjD,KAAI,CAAC,yBAAyB;AAC5B,4BAA0B;AAC1B,MAAI;AACF,oBAAiB;AACf,mBAAe;AACf,8BAA0B;MACzB,EAAE;UACC;AAGN,6BAA0B;;;AAI9B,KAAI,WAAW,oBACb;MACK;AACL,wBAAsB;AACtB,iBAAe;;AAEjB,QAAO,gBAAgB,cACnB,SACA,UAAU,eAAe;;;;;;;AAY/B,MAAM,0BAAyC;CAC7C,MAAM,MAAM,sBAAsB,UAAU;AAC5C,KAAI,QAAQ,KAAA,KAAa,IAAI,SAAS,SACpC,QAAO;AAET,QAAO,IAAI,kBAAkB,KAAA,IACzB,OACA,eAAe,IAAI,cAAc;;;;;;;AAYvC,MAAM,uBAA+B;CACnC,MAAM,aAAa,mBAAmB;AACtC,QAAO,eAAe,OAAO,aAAa,KAAK,GAAG;;AAKpD,IAAM,mBAAN,cAA+B,aAAa;CAC1C,YAAY,GAAG,MAAiB;AAC9B,MAAI,KAAK,SAAS,GAAG;AACnB,SAAM,GAAI,KAAoD;AAC9D;;EAEF,MAAM,aAAa,mBAAmB;AACtC,MAAI,eAAe,MAAM;AACvB,UAAO;AACP;;AAEF,QAAM,WAAW;;CAGnB,OAAgB,MAAc;AAC5B,SAAO,gBAAgB;;;AAM3B,SAAS,YAA2B,GAAG,MAAgC;AACrE,KAAI,EAAE,gBAAgB,aACpB,QAAO,IAAI,kBAAkB,CAAC,UAAU;AAE1C,QAAO,IAAI,iBAAiB,GAAG,KAAK;;AAGtC,YAAY,MAAM;AAClB,YAAY,QAAQ,aAAa;AACjC,YAAY,MAAM,aAAa;AAI/B,OAAO,eAAe,aAAa,aAAa;CAC9C,OAAO,iBAAiB;CACxB,UAAU;CACV,cAAc;CACf,CAAC;AACF,iBAAkB,UAAuC,cACvD;AAMF,IAAI,YAAY;;;;;;;;;;;AAYhB,MAAa,4BAAkC;AAC7C,KAAI,UACF;AAEF,aAAY;AACZ,KAAI;AACF,aAAW,OAAO;UACX,OAAO;AACd,WACE,iBACA,mGACA,MACD","debugId":"ef892b9a-fcab-5f5d-baed-592098a17dd5"}