@reproapp/node-sdk 0.0.51 → 0.0.52

package/README.md

@@ -304,8 +304,8 @@ await initRepro({
   privacy: {
     environment: process.env.REPRO_PRIVACY_ENV ?? "dev",
     apiBase: process.env.REPRO_PRIVACY_API_BASE ?? process.env.REPRO_API_BASE,
-    fetchTimeoutMs: 2500,
-    startupMaxWaitMs: 10000,
+    fetchTimeoutMs: 10000,
+    startupMaxWaitMs: 15000,
     startupRetryDelayMs: 500,
   },
 });
@@ -313,6 +313,21 @@ await initRepro({
 
 Use `privacy.captureRaw: true` only in controlled local development.
 
+The default policy fetch timeout is 10 seconds, including reading the response
+body. The startup retry budget defaults to 15 seconds. Large approved policies
+are loaded in full; a timeout does not permit uploading unredacted values.
+
+Trace value materialization uses a restartable background worker in both live and
+staging modes. Worker messages are processed in bounded batches without dropping
+events. When worker execution is unavailable, asynchronous capture traversal
+yields to the event loop. Observation snapshots still have a synchronous cost,
+so measure overhead against your own payloads and traffic before production use.
+
+Run `npm run test:latency` with Docker running to test real MongoDB queries and
+HTTP traffic with recording disabled, raw capture, approved policies, worker
+fallback, and a worker-side policy failure. The test checks unrelated HTTP
+responsiveness, captured values and mutations, privacy, and request manifests.
+
 ## Verify
 
 With the React SDK, record a browser session in `live` mode or start a manual QA

package/dist/capture-work-budget.d.ts

@@ -0,0 +1 @@
+export declare function yieldCaptureWork(): Promise<void> | null;

package/dist/capture-work-budget.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yieldCaptureWork = void 0;
+// Promise-only recursion never yields to HTTP sockets. Share a small time slice
+// across asynchronous capture walkers, including the worker-unavailable fallback.
+let deadline = 0;
+let pendingYield = null;
+function yieldCaptureWork() {
+    if (pendingYield)
+        return pendingYield;
+    const now = performance.now();
+    if (now < deadline)
+        return null;
+    if (deadline === 0) {
+        deadline = now + 4;
+        return null;
+    }
+    pendingYield = new Promise(resolve => setImmediate(() => {
+        deadline = performance.now() + 4;
+        pendingYield = null;
+        resolve();
+    }));
+    return pendingYield;
+}
+exports.yieldCaptureWork = yieldCaptureWork;

package/dist/index.js

@@ -7,9 +7,11 @@ const crypto_1 = require("crypto");
 const module_1 = require("module");
 const path_1 = require("path");
 const url_1 = require("url");
+const node_v8_1 = require("node:v8");
 const client_1 = require("./ingest/client");
 const privacy_1 = require("./privacy");
 const semantic_serialization_1 = require("./semantic-serialization");
+const capture_work_budget_1 = require("./capture-work-budget");
 const live_capture_limits_1 = require("./live-capture-limits");
 /**
  * ============================= IMPORTANT =============================
@@ -1170,6 +1172,7 @@ function scheduleTraceMaterializerIdleShutdown() {
         const worker = traceMaterializerWorker;
         traceMaterializerWorker = null;
         if (worker) {
+            traceMaterializerExpectedTerminations.add(worker);
             try {
                 void worker.terminate?.();
             }
@@ -1195,7 +1198,17 @@ function handleTraceMaterializerMessage(message) {
     traceMaterializerPending.delete(message.taskId);
     clearTraceMaterializerTaskTimeout(message.taskId);
     if (message.ok) {
-        pending.resolve(Array.isArray(message.events) ? message.events : []);
+        const events = Array.isArray(message.events) ? message.events : [];
+        for (const event of events) {
+            // Symbols do not cross worker messages. Restore internal attachments
+            // before transport, otherwise each occurrence embeds its full value.
+            const entries = event.__reproTraceValueEntries;
+            if (entries)
+                for (const entry of entries)
+                    attachTraceValueEntry(event, entry);
+            delete event.__reproTraceValueEntries;
+        }
+        pending.resolve(events);
         scheduleTraceMaterializerIdleShutdown();
         return;
     }
@@ -1256,9 +1269,15 @@ function getTraceMaterializerWorker() {
         catch { }
         worker.on('message', handleTraceMaterializerMessage);
         worker.on('error', (err) => {
+            if (worker !== traceMaterializerWorker || traceMaterializerExpectedTerminations.has(worker))
+                return;
             disableTraceMaterializerWorker(err instanceof Error ? err : new Error(String(err)));
         });
         worker.on('exit', (code) => {
+            // Idle/timeout shutdown can finish after a replacement worker starts.
+            // An old worker must never clear or disable its replacement.
+            if (worker !== traceMaterializerWorker)
+                return;
             const hadPending = traceMaterializerPending.size > 0;
             const expectedTermination = traceMaterializerExpectedTerminations.has(worker);
             clearTraceMaterializerIdleTimer();
@@ -1340,18 +1359,12 @@ function shouldOffloadPendingTraceEvents(events) {
         if (!pending)
             continue;
         if (pending.argsRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.argsRaw))
-                return false;
             pendingValueCount += 1;
         }
         if (pending.returnValueRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.returnValueRaw))
-                return false;
             pendingValueCount += 1;
         }
         if (pending.errorRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.errorRaw))
-                return false;
             pendingValueCount += 1;
         }
         if (pendingValueCount >= TRACE_MATERIALIZE_OFFTHREAD_MIN_VALUES) {
@@ -2820,9 +2833,16 @@ function internTraceObservationSnapshot(snapshot, captureScope) {
     if (!captureScope || snapshot === null || typeof snapshot !== 'object') {
         return snapshot;
     }
-    const serialized = stableSerializeTraceValue(snapshot);
-    if (serialized === null)
+    // These are already detached data snapshots. Binary serialization avoids
+    // sorting and cloning the whole graph again on the application's call stack,
+    // while preserving undefined, NaN, and other non-JSON primitive distinctions.
+    let serialized;
+    try {
+        serialized = (0, node_v8_1.serialize)(snapshot);
+    }
+    catch {
         return snapshot;
+    } // Interning is optional; the snapshot is not.
     const digest = (0, crypto_1.createHash)('sha256')
         .update('repro-trace-observation-v1\0')
         .update(serialized)
@@ -3002,6 +3022,16 @@ async function materializePendingTraceEventsAsync(events, params) {
     if (!events.some((evt) => evt.__reproPending)) {
         return events;
     }
+    // Bound work per worker message and timeout, not the captured data itself.
+    // A long request must not become one enormous structured-clone operation.
+    if (events.length > 64) {
+        const materialized = [];
+        for (let offset = 0; offset < events.length; offset += 64) {
+            materialized.push(...await materializePendingTraceEventsAsync(events.slice(offset, offset + 64), params));
+            await new Promise(resolve => setImmediate(resolve));
+        }
+        return materialized;
+    }
     const privacy = params.resolvePrivacy();
     if (!shouldOffloadPendingTraceEvents(events)) {
         try {
@@ -3016,7 +3046,7 @@ async function materializePendingTraceEventsAsync(events, params) {
         }
     }
     try {
-        return await materializePendingTraceEventsOffThread(events, {
+        const materialized = await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
                 tenantId: params.cfg.tenantId,
@@ -3032,6 +3062,14 @@ async function materializePendingTraceEventsAsync(events, params) {
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
             valueNamespace: params.valueNamespace,
         });
+        for (const event of materialized) {
+            for (const [field, captureField] of [['args', 'argsValueCapture'], ['returnValue', 'returnValueCapture'], ['error', 'errorValueCapture']]) {
+                if (event[captureField]?.status === 'failed-policy') {
+                    recordRequestCaptureFailure(params.captureScope ?? getCtx().captureScope, 'privacy.full_value', `trace.${field}`, 'worker_value_materialization_failed');
+                }
+            }
+        }
+        return materialized;
     }
     catch (err) {
         try {
@@ -3059,10 +3097,15 @@ async function __materializePendingTraceEventsForWorker(payload) {
             resolvePrivacy: () => payload.privacy,
             valueNamespace: payload.valueNamespace,
         });
+        const values = new Map();
         return materialized.map((event) => {
             const entries = getEventTraceValueEntries(event);
             if (entries?.length) {
-                event.__reproTraceValueEntries = entries.map((entry) => ({ ...entry }));
+                event.__reproTraceValueEntries = entries.map((entry) => {
+                    if (!values.has(entry.id))
+                        values.set(entry.id, entry.value);
+                    return { ...entry, value: values.get(entry.id) };
+                });
             }
             return event;
         });
@@ -3188,7 +3231,7 @@ function sanitizeHeaders(headers, rawCfg) {
 }
 const RUNTIME_PRIVACY_STATE_SYMBOL = Symbol('repro.runtimePrivacyState');
 const RUNTIME_PRIVACY_RETRY_COOLDOWN_MS = 5000;
-const DEFAULT_RUNTIME_PRIVACY_STARTUP_MAX_WAIT_MS = 6000;
+const DEFAULT_RUNTIME_PRIVACY_STARTUP_MAX_WAIT_MS = 15000;
 const DEFAULT_RUNTIME_PRIVACY_STARTUP_RETRY_DELAY_MS = 150;
 function normalizeMaskTargets(target) {
     const out = Array.isArray(target) ? target : [target];
@@ -3334,7 +3377,7 @@ function handleRuntimePrivacyFetchResult(cfg, state, apiBase, result) {
         state.nextRetryAt = Date.now() + RUNTIME_PRIVACY_RETRY_COOLDOWN_MS;
         return null;
     }
-    reportRuntimePrivacyOutcome(cfg, state, `network:${result.error}:${apiBase ?? 'no-api-base'}`, `privacy policy fetch failed while contacting ${apiBase}`);
+    reportRuntimePrivacyOutcome(cfg, state, `network:${result.error}:${apiBase ?? 'no-api-base'}`, `privacy policy fetch failed while contacting ${apiBase}: ${result.error}`);
     state.nextRetryAt = Date.now() + RUNTIME_PRIVACY_RETRY_COOLDOWN_MS;
     return null;
 }
@@ -4196,6 +4239,9 @@ function cloneFullValueCandidate(value, ctx, limits, depth = 0, seen = new WeakM
     return out;
 }
 async function cloneFullValueCandidateAsync(value, ctx, limits, depth = 0, seen = new WeakMap(), valuePath = '$') {
+    const pause = (0, capture_work_budget_1.yieldCaptureWork)();
+    if (pause)
+        await pause;
     if (value === undefined)
         return undefined;
     if (value === null || typeof value === 'number' || typeof value === 'boolean')

package/dist/privacy.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyRuntimePrivacyPolicyAsync = exports.applyRuntimePrivacyPolicy = exports.normalizeRuntimePrivacyPolicy = exports.fetchApprovedRuntimePrivacyPolicy = exports.resolvePrivacyApiBase = exports.normalizePrivacyEnvironment = exports.clearRuntimePrivacyProvenance = void 0;
 const crypto_1 = require("crypto");
+const capture_work_budget_1 = require("./capture-work-budget");
 const privacy_fallback_1 = require("./privacy-fallback");
 const privacy_redaction_1 = require("./privacy-redaction");
 const EMPTY_RUNTIME_PRIVACY_POLICY = {
@@ -89,7 +90,7 @@ function resolvePrivacyApiBase(cfg) {
     return String(value).replace(/\/+$/, '');
 }
 exports.resolvePrivacyApiBase = resolvePrivacyApiBase;
-const DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS = 2500;
+const DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS = 10000;
 function resolveRuntimePrivacyFetchTimeoutMs(value) {
     if (!Number.isFinite(value)) {
         return DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS;
@@ -671,6 +672,9 @@ function transformValue(policy, surface, value, context, path, fallbackInput = n
     return transformChildrenExact(policy, surface, currentValue, context, path, fallback);
 }
 async function transformValueAsync(policy, surface, value, context, path, fallbackInput = null) {
+    const pause = (0, capture_work_budget_1.yieldCaptureWork)();
+    if (pause)
+        await pause;
     const fallback = resolveTransformFallback(value, fallbackInput);
     const objectId = coercePrivacyObjectId(value);
     if (objectId !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.51",
+  "version": "0.0.52",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
     "node": ">=18"
   },
   "scripts": {
+    "test:latency": "npm run build && node test/privacy-fetch-timeout.test.js && node test/capture-latency.testcontainers.test.js",
     "test:live-capture": "npm run build && node test/live-capture-limits.test.js && node test/ingest-throttle-retention.test.js && node test/live-capture-limits.testcontainers.test.js",
     "test:live-brokers": "npm run build && node test/live-broker-limits.testcontainers.test.js",
     "build": "tsc -p tsconfig.json",

package/src/capture-work-budget.ts

@@ -0,0 +1,16 @@
+// Promise-only recursion never yields to HTTP sockets. Share a small time slice
+// across asynchronous capture walkers, including the worker-unavailable fallback.
+let deadline = 0;
+let pendingYield: Promise<void> | null = null;
+export function yieldCaptureWork(): Promise<void> | null {
+    if (pendingYield) return pendingYield;
+    const now = performance.now();
+    if (now < deadline) return null;
+    if (deadline === 0) { deadline = now + 4; return null; }
+    pendingYield = new Promise<void>(resolve => setImmediate(() => {
+        deadline = performance.now() + 4;
+        pendingYield = null;
+        resolve();
+    }));
+    return pendingYield;
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import { createHash, createHmac, randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
+import { serialize as serializeSnapshot } from 'node:v8';
 import {
     configureIngestQueueDrain,
     enqueueIngestEntries,
@@ -29,6 +30,7 @@ import {
     type RuntimePrivacyTraceContext,
 } from './privacy';
 import { projectSemanticInfrastructureValue } from './semantic-serialization';
+import { yieldCaptureWork } from './capture-work-budget';
 import { limitLiveCapture, limitLiveArguments, collectCaptureOmissions, type CaptureOmission } from './live-capture-limits';
 
 /**
@@ -1625,6 +1627,7 @@ function scheduleTraceMaterializerIdleShutdown(): void {
         const worker = traceMaterializerWorker;
         traceMaterializerWorker = null;
         if (worker) {
+            traceMaterializerExpectedTerminations.add(worker);
             try { void worker.terminate?.(); } catch {}
         }
     }, TRACE_MATERIALIZE_WORKER_IDLE_SHUTDOWN_MS);
@@ -1649,7 +1652,15 @@ function handleTraceMaterializerMessage(message: TraceMaterializationWorkerRespo
     traceMaterializerPending.delete(message.taskId);
     clearTraceMaterializerTaskTimeout(message.taskId);
     if (message.ok) {
-        pending.resolve(Array.isArray(message.events) ? message.events : []);
+        const events = Array.isArray(message.events) ? message.events : [];
+        for (const event of events) {
+            // Symbols do not cross worker messages. Restore internal attachments
+            // before transport, otherwise each occurrence embeds its full value.
+            const entries = event.__reproTraceValueEntries;
+            if (entries) for (const entry of entries) attachTraceValueEntry(event, entry);
+            delete event.__reproTraceValueEntries;
+        }
+        pending.resolve(events);
         scheduleTraceMaterializerIdleShutdown();
         return;
     }
@@ -1700,9 +1711,13 @@ function getTraceMaterializerWorker(): any | null {
         try { worker.unref?.(); } catch {}
         worker.on('message', handleTraceMaterializerMessage);
         worker.on('error', (err: Error) => {
+            if (worker !== traceMaterializerWorker || traceMaterializerExpectedTerminations.has(worker)) return;
             disableTraceMaterializerWorker(err instanceof Error ? err : new Error(String(err)));
         });
         worker.on('exit', (code: number) => {
+            // Idle/timeout shutdown can finish after a replacement worker starts.
+            // An old worker must never clear or disable its replacement.
+            if (worker !== traceMaterializerWorker) return;
             const hadPending = traceMaterializerPending.size > 0;
             const expectedTermination = traceMaterializerExpectedTerminations.has(worker);
             clearTraceMaterializerIdleTimer();
@@ -1779,15 +1794,12 @@ function shouldOffloadPendingTraceEvents(events: PendingTraceEventRecord[]): boo
         const pending = event.__reproPending;
         if (!pending) continue;
         if (pending.argsRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.argsRaw)) return false;
             pendingValueCount += 1;
         }
         if (pending.returnValueRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.returnValueRaw)) return false;
             pendingValueCount += 1;
         }
         if (pending.errorRaw !== undefined) {
-            if (traceInlineValueExceedsLimit(pending.errorRaw)) return false;
             pendingValueCount += 1;
         }
         if (pendingValueCount >= TRACE_MATERIALIZE_OFFTHREAD_MIN_VALUES) {
@@ -3430,8 +3442,12 @@ function internTraceObservationSnapshot(
         return snapshot;
     }
 
-    const serialized = stableSerializeTraceValue(snapshot);
-    if (serialized === null) return snapshot;
+    // These are already detached data snapshots. Binary serialization avoids
+    // sorting and cloning the whole graph again on the application's call stack,
+    // while preserving undefined, NaN, and other non-JSON primitive distinctions.
+    let serialized: Buffer;
+    try { serialized = serializeSnapshot(snapshot); }
+    catch { return snapshot; } // Interning is optional; the snapshot is not.
 
     const digest = createHash('sha256')
         .update('repro-trace-observation-v1\0')
@@ -3705,6 +3721,17 @@ async function materializePendingTraceEventsAsync(
         return events;
     }
 
+    // Bound work per worker message and timeout, not the captured data itself.
+    // A long request must not become one enormous structured-clone operation.
+    if (events.length > 64) {
+        const materialized: TraceEventRecord[] = [];
+        for (let offset = 0; offset < events.length; offset += 64) {
+            materialized.push(...await materializePendingTraceEventsAsync(events.slice(offset, offset + 64), params));
+            await new Promise<void>(resolve => setImmediate(resolve));
+        }
+        return materialized;
+    }
+
     const privacy = params.resolvePrivacy();
     if (!shouldOffloadPendingTraceEvents(events)) {
         try {
@@ -3723,7 +3750,7 @@ async function materializePendingTraceEventsAsync(
         }
     }
     try {
-        return await materializePendingTraceEventsOffThread(events, {
+        const materialized = await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
                 tenantId: params.cfg.tenantId,
@@ -3739,6 +3766,15 @@ async function materializePendingTraceEventsAsync(
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
             valueNamespace: params.valueNamespace,
         });
+        for (const event of materialized) {
+            for (const [field, captureField] of [['args', 'argsValueCapture'], ['returnValue', 'returnValueCapture'], ['error', 'errorValueCapture']] as const) {
+                if (event[captureField]?.status === 'failed-policy') {
+                    recordRequestCaptureFailure(params.captureScope ?? getCtx().captureScope,
+                        'privacy.full_value', `trace.${field}`, 'worker_value_materialization_failed');
+                }
+            }
+        }
+        return materialized;
     } catch (err) {
         try {
             return await materializePendingTraceEvents(events, {
@@ -3775,10 +3811,14 @@ export async function __materializePendingTraceEventsForWorker(
             resolvePrivacy: () => payload.privacy,
             valueNamespace: payload.valueNamespace,
         });
+        const values = new Map<string, any>();
         return materialized.map((event) => {
             const entries = getEventTraceValueEntries(event);
             if (entries?.length) {
-                (event as PendingTraceEventRecord).__reproTraceValueEntries = entries.map((entry) => ({ ...entry }));
+                (event as PendingTraceEventRecord).__reproTraceValueEntries = entries.map((entry) => {
+                    if (!values.has(entry.id)) values.set(entry.id, entry.value);
+                    return { ...entry, value: values.get(entry.id) };
+                });
             }
             return event as PendingTraceEventRecord;
         });
@@ -3925,7 +3965,7 @@ type RuntimePrivacyState = {
 
 const RUNTIME_PRIVACY_STATE_SYMBOL = Symbol('repro.runtimePrivacyState');
 const RUNTIME_PRIVACY_RETRY_COOLDOWN_MS = 5000;
-const DEFAULT_RUNTIME_PRIVACY_STARTUP_MAX_WAIT_MS = 6000;
+const DEFAULT_RUNTIME_PRIVACY_STARTUP_MAX_WAIT_MS = 15000;
 const DEFAULT_RUNTIME_PRIVACY_STARTUP_RETRY_DELAY_MS = 150;
 
 function normalizeMaskTargets(target: ReproMaskTarget | ReproMaskTarget[]): ReproMaskTarget[] {
@@ -4104,7 +4144,7 @@ function handleRuntimePrivacyFetchResult(
         cfg,
         state,
         `network:${result.error}:${apiBase ?? 'no-api-base'}`,
-        `privacy policy fetch failed while contacting ${apiBase}`,
+        `privacy policy fetch failed while contacting ${apiBase}: ${result.error}`,
     );
     state.nextRetryAt = Date.now() + RUNTIME_PRIVACY_RETRY_COOLDOWN_MS;
     return null;
@@ -5142,6 +5182,8 @@ async function cloneFullValueCandidateAsync(
     seen: WeakMap<object, string> = new WeakMap(),
     valuePath = '$',
 ): Promise<any> {
+    const pause = yieldCaptureWork();
+    if (pause) await pause;
     if (value === undefined) return undefined;
     if (value === null || typeof value === 'number' || typeof value === 'boolean') return value;
     if (typeof value === 'string') {

package/src/privacy.ts

@@ -1,4 +1,5 @@
 import { createHash } from 'crypto';
+import { yieldCaptureWork } from './capture-work-budget';
 import { sanitizeUnknownBoundaryTextWithDetectors } from './privacy-fallback';
 import { redactEmailDeterministic, redactEmailsInText } from './privacy-redaction';
 
@@ -236,7 +237,7 @@ export function resolvePrivacyApiBase(cfg?: RuntimePrivacyConfig | null): string
     return String(value).replace(/\/+$/, '');
 }
 
-const DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS = 2500;
+const DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS = 10000;
 
 function resolveRuntimePrivacyFetchTimeoutMs(value?: number | null): number {
     if (!Number.isFinite(value)) {
@@ -971,6 +972,8 @@ async function transformValueAsync(
     path: string[],
     fallbackInput: RuntimePrivacyAction | TransformFallback = null,
 ): Promise<any> {
+    const pause = yieldCaptureWork();
+    if (pause) await pause;
     const fallback = resolveTransformFallback(value, fallbackInput);
     const objectId = coercePrivacyObjectId(value);
     if (objectId !== null) {

package/test/capture-latency.testcontainers.test.js

@@ -0,0 +1,123 @@
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { fork } = require('node:child_process');
+const { once } = require('node:events');
+const { performance } = require('node:perf_hooks');
+const { GenericContainer, Wait } = require('testcontainers');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const policy = { environment: 'dev', statements: [
+    ...Array.from({ length: 5000 }, (_, i) => ({ sid: `f${i}`, when: { scope: 'FUNCTION', selector: `Service${i}.method`, target: 'trace.args|trace.returnValue' }, apply: { action: 'KEEP_EXACT' } })),
+    { sid: 'secret', when: { scope: 'FIELD', selector: 'field:internalSecret' }, apply: { action: 'DROP' } },
+] };
+async function main() {
+    const events = [];
+    const sink = http.createServer((req, res) => {
+        const chunks = [];
+        req.on('data', chunk => chunks.push(chunk));
+        req.on('end', () => {
+            const body = JSON.parse(Buffer.concat(chunks));
+            events.push(...(body.events || []));
+            res.writeHead(202); res.end('{}');
+        });
+    });
+    let mongo, child;
+    await new Promise(resolve => sink.listen(0, '127.0.0.1', resolve));
+    const results = [];
+    try {
+        mongo = await new GenericContainer('mongo:7').withExposedPorts(27017).withWaitStrategy(Wait.forListeningPorts()).start();
+        for (const variant of ['off', 'live-raw', 'staging-raw', 'live-policy', 'staging-policy', 'live-policy-fallback', 'staging-policy-fallback', 'staging-policy-fault']) {
+            const mode = variant.split('-')[0];
+            child = fork(require.resolve('./fixtures/capture-latency-server'), [], {
+                env: { ...process.env, CAPTURE_TEST_MODE: mode,
+                    CAPTURE_TEST_MONGO: `mongodb://${mongo.getHost()}:${mongo.getMappedPort(27017)}/latency_${variant}`,
+                    CAPTURE_TEST_SINK: `http://127.0.0.1:${sink.address().port}`,
+                    CAPTURE_TEST_POLICY: variant.includes('-policy') ? JSON.stringify(policy) : '',
+                    REPRO_TRACE_MATERIALIZE_OFFTHREAD: variant.endsWith('fallback') ? 'false' : 'true',
+                    CAPTURE_TEST_WORKER_FAULT: variant.endsWith('fault') ? 'true' : '',
+                    REPRO_SDK_BACKGROUND_IDLE_DELAY_MS: '0', REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS: '0',
+                    REPRO_SDK_BACKGROUND_MAX_DEFER_MS: '0', TRACE_IDLE_FLUSH_MS: '10', TRACE_LINGER_AFTER_FINISH_MS: '0',
+                }, stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+            });
+            let stderr = '';
+            child.stderr.on('data', chunk => { stderr += chunk; });
+            const ready = await Promise.race([once(child, 'message').then(([value]) => value), once(child, 'exit').then(() => { throw new Error(stderr); })]);
+            const base = `http://127.0.0.1:${ready.port}`;
+            const healthTimes = [], requestTimes = [];
+            let stop = false;
+            const polling = (async () => {
+                while (!stop) {
+                    const start = performance.now();
+                    await (await fetch(`${base}/health`)).json();
+                    healthTimes.push(performance.now() - start);
+                    await sleep(10);
+                }
+            })();
+            try {
+                // Both startup-idle and between-wave idle must permit a fresh worker.
+                for (let wave = 0; wave < 2; wave++) {
+                    await sleep(800);
+                    const sid = `S_latency_${variant}_${wave}`;
+                    const start = performance.now();
+                    const body = await (await fetch(`${base}/names${mode === 'off' ? '' : `?__repro_sid=${sid}&__repro_aid=A_${wave}&__repro_mode=${mode}`}`)).json();
+                    requestTimes.push(performance.now() - start);
+                    assert.equal(body.rows.length, 120);
+                    assert.equal(body.rows[119].internalSecret, 'secret-119', 'business responses must not be redacted or limited');
+                    assert.equal(body.phase, 11);
+                    if (mode !== 'off') {
+                        const deadline = Date.now() + 60000;
+                        const scoped = () => events.filter(e => e.session_id === sid);
+                        const complete = () => {
+                            const capture = scoped();
+                            const manifest = capture.find(e => e.event_type === 'request_capture_manifest')?.payload.requestCaptureManifest;
+                            return manifest && ['backend_request', 'db_change'].every(t => capture.some(e => e.event_type === t))
+                                && capture.filter(e => e.event_type === 'trace_batch').length >= manifest.expected.traceBatch;
+                        };
+                        while (!complete() && Date.now() < deadline) await sleep(25);
+                        assert(complete(), `incomplete ${variant}: ${stderr.slice(-2000)}`);
+                        const captured = scoped();
+                        assert(!JSON.stringify(captured).includes('__reproTraceValueEntries'), 'worker-only attachments must never be serialized into each occurrence');
+                        const values = new Map(captured.flatMap(e => [...(e.payload.traceValues || []), ...(e.payload.requestValues || []), ...(e.payload.dbValues || [])]).map(v => [v.id, v.value]));
+                        const trace = captured.flatMap(e => e.payload.trace || []);
+                        // The tracer also emits the function-body entry; verify the twelve callsites.
+                        const observations = [...new Map(trace.filter(e => e.fn === 'observeRows' && e.line === 6 && e.type === 'enter' && (e.args || e.argsValueCapture))
+                            .map(e => [e.spanId, e])).values()];
+                        const resolve = (e, field) => values.get(e[`${field}ValueCapture`]?.valueId) ?? e[field];
+                        assert.equal(observations.length, 12, JSON.stringify(observations.map(e => ({spanId:e.spanId, file:e.file, line:e.line, phase:resolve(e,'args')?.[0]?.phase}))));
+                        if (variant.endsWith('fault')) {
+                            assert(observations.some(e => e.argsValueCapture?.status === 'failed-policy'));
+                            const manifest = captured.find(e => e.event_type === 'request_capture_manifest').payload.requestCaptureManifest;
+                            assert.equal(manifest.privacy.status, 'failed', 'worker errors must not falsely attest applied privacy');
+                            assert(manifest.captureFailures.some(f => f.reason === 'worker_value_materialization_failed'));
+                            assert(!JSON.stringify(captured).includes('secret-0'), 'failed policy capture must never fall back to raw');
+                            continue;
+                        }
+                        assert.deepEqual(observations.map(e => resolve(e, 'args')[0].phase), Array.from({ length: 12 }, (_, i) => i));
+                        const document = resolve(observations[0], 'args')[0];
+                        assert.equal(document.rows.length, mode === 'live' ? 101 : 120);
+                        if (mode === 'live') assert.equal(document.rows[100].reason, 'max-entries');
+                        assert.equal(document.rows[0].internalSecret, variant.includes('-policy') ? '[dropped]' : 'secret-0');
+                        const manifest = captured.find(e => e.event_type === 'request_capture_manifest').payload.requestCaptureManifest;
+                        assert(!manifest.captureFailures?.length, JSON.stringify(manifest.captureFailures));
+                        assert.equal(manifest.privacy.status, variant.includes('-policy') ? 'applied' : 'bypassed');
+                        const stats = await (await fetch(`${base}/health`)).json();
+                        if (variant.endsWith('fallback')) assert.equal(stats.tasks, 0);
+                        else if (!process.env.REPRO_BENCHMARK_ONLY) assert(stats.tasks >= wave + 1, `${variant}: trace worker stopped accepting large captures after idle: ${JSON.stringify(stats)}`);
+                    }
+                }
+                const stats = await (await fetch(`${base}/health`)).json();
+                results.push({ variant, requestMs: requestTimes.map(Math.round), maxHealthMs: Math.round(Math.max(...healthTimes)), workers: stats.workers, tasks: stats.tasks });
+                console.log(JSON.stringify(results.at(-1)));
+            } finally { stop = true; await polling; }
+            const exited = once(child, 'exit'); child.send('stop'); await exited; child = null;
+        }
+        if (!process.env.REPRO_BENCHMARK_ONLY) {
+            for (const result of results.slice(1)) assert(result.maxHealthMs < 250, `capture stalled unrelated HTTP: ${JSON.stringify(result)}`);
+        }
+        console.log('live/staging capture latency and exact evidence testcontainers OK');
+    } finally {
+        if (child) { const exited = once(child, 'exit'); child.kill(); await exited; }
+        await new Promise(resolve => sink.close(resolve));
+        if (mongo) await mongo.stop();
+    }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/content-addressed-trace-values.test.js

@@ -118,15 +118,19 @@ async function runRequest(config, sessionId, repeatedPayload, changedPayload = m
             });
         });
 
-        const deadline = Date.now() + 5000;
+        const deadline = Date.now() + 30000;
+        let completed = false;
         while (Date.now() < deadline) {
             const events = posts.flatMap((post) => post.events || []);
-            if (events.some((event) => event.event_type === 'backend_request') &&
-                events.some((event) => event.event_type === 'trace_batch')) {
+            const manifest = events.find(event => event.event_type === 'request_capture_manifest')?.payload.requestCaptureManifest;
+            if (manifest && events.some(event => event.event_type === 'backend_request') &&
+                events.filter(event => event.event_type === 'trace_batch').length === manifest.expected.traceBatch) {
+                completed = true;
                 break;
             }
             await sleep(20);
         }
+        assert(completed, `capture did not finish for ${sessionId}`);
         await __reproTestHooks.drainSdkBackgroundQueueForTest();
         await flushIngestQueue();
         return posts;
@@ -228,7 +232,11 @@ async function main() {
         makePayload(false, 'policy-secret-alpha'),
         makePayload(false, 'policy-secret-beta'),
     ));
-    assert.equal(policyCapture.refs.length, 122);
+    assert.equal(policyCapture.refs.length, 122, JSON.stringify({
+        eventTypes: policyCapture.ingestEvents.map(event => event.event_type),
+        observations: policyCapture.observedEvents.slice(0, 2),
+        manifests: policyCapture.ingestEvents.filter(event => event.event_type === 'request_capture_manifest'),
+    }));
     assert.equal(new Set(policyCapture.refs).size, 1);
     assert.equal(policyCapture.definitions.length, 1);
     const policySerialized = JSON.stringify(policyCapture.definitions);

package/test/fixtures/capture-latency-business.js

@@ -0,0 +1,10 @@
+function observeRows(document) { return document; }
+async function loadRows(Model) {
+    const document = await Model.findOne({ reference: 'LATENCY' }).lean().exec();
+    for (let i = 0; i < 12; i++) {
+        document.phase = i;
+        if (observeRows(document) !== document) throw new Error('return identity changed');
+    }
+    return document;
+}
+module.exports = { loadRows };

package/test/fixtures/capture-latency-server.js

@@ -0,0 +1,54 @@
+const workerThreads = require('node:worker_threads');
+const metrics = { workers: 0, tasks: 0 };
+const RealWorker = workerThreads.Worker;
+workerThreads.Worker = class extends RealWorker {
+    constructor(...args) {
+        if (process.env.CAPTURE_TEST_WORKER_FAULT && String(args[0]).includes('trace-materializer-worker')) {
+            args[1] = { ...args[1], execArgv: ['--require', require.resolve('./worker-value-failure')] };
+        }
+        super(...args);
+        if (String(args[0]).includes('trace-materializer-worker')) {
+            metrics.workers++;
+            const post = this.postMessage.bind(this);
+            this.postMessage = (...messages) => { metrics.tasks++; return post(...messages); };
+        }
+    }
+};
+const http = require('node:http');
+const mode = process.env.CAPTURE_TEST_MODE;
+const { initRepro, reproMongoosePlugin } = require(process.env.CAPTURE_TEST_SDK || '../../dist');
+async function main() {
+    const config = {
+        tenantId: 'TENANT_latency', appId: 'APP_latency', appSecret: 'test-only',
+        appName: 'latency-test', serviceName: 'Latency API', liveMode: false,
+        tracing: { include: [/capture-latency-business\.js$/], disableFunctionTypes: ['constructor'], logFunctionCalls: false },
+        privacy: { environment: 'dev', captureRaw: !process.env.CAPTURE_TEST_POLICY,
+            ...(process.env.CAPTURE_TEST_POLICY ? { policy: JSON.parse(process.env.CAPTURE_TEST_POLICY) } : {}) },
+        ingestBase: process.env.CAPTURE_TEST_SINK,
+    };
+    if (mode !== 'off') await initRepro(config);
+    const mongoose = require('mongoose');
+    const express = require('express');
+    const connection = await mongoose.createConnection(process.env.CAPTURE_TEST_MONGO).asPromise();
+    const schema = new mongoose.Schema({ reference: String, phase: Number, rows: [Object] });
+    if (mode !== 'off') schema.plugin(reproMongoosePlugin, config);
+    const Model = connection.model('Latency', schema);
+    await Model.create({ reference: 'LATENCY', phase: -1, rows: Array.from({ length: 120 }, (_, id) => ({
+        id, status: 'available', internalSecret: `secret-${id}`, description: 'Operational depot description '.repeat(32),
+    })) });
+    const { loadRows } = require('./capture-latency-business');
+    const app = express();
+    app.get('/health', (_req, res) => res.json({ ok: true, ...metrics }));
+    app.get('/names', async (_req, res, next) => {
+        try { res.json(await loadRows(Model)); } catch (e) { next(e); }
+    });
+    const server = http.createServer(app);
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    process.send({ port: server.address().port });
+    process.once('message', async () => {
+        await new Promise(resolve => server.close(resolve));
+        await connection.close();
+        process.exit(0);
+    });
+}
+main().catch(error => { console.error(error); process.exit(1); });

package/test/fixtures/worker-value-failure.js

@@ -0,0 +1,11 @@
+// Fault injection inside a real worker: preview succeeds, full-value policy
+// transformation fails. The parent must not publish a successful attestation.
+const privacy = require('../../dist/privacy');
+const apply = privacy.applyRuntimePrivacyPolicyAsync;
+let calls = 0;
+privacy.applyRuntimePrivacyPolicyAsync = async (...args) => {
+    if (args[1] === 'trace.args' && args[2]?.[0]?.rows?.length === 120 && ++calls % 2 === 0) {
+        throw new Error('injected full-value policy failure');
+    }
+    return apply(...args);
+};

package/test/privacy-fetch-timeout.test.js

@@ -0,0 +1,25 @@
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { fetchApprovedRuntimePrivacyPolicy } = require('../dist/privacy');
+const policy = { environment: 'dev', statements: [{ sid: 'secret', when: { scope: 'FIELD', selector: 'field:internalSecret' }, apply: { action: 'DROP' } }], notes: 'policy-analysis '.repeat(140000) };
+async function main() {
+    const server = http.createServer((req, res) => {
+        const service = new URL(req.url, 'http://local').searchParams.get('serviceName');
+        if (service === 'forbidden') { res.writeHead(403); res.end('{}'); return; }
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.flushHeaders();
+        const timer = setTimeout(() => res.end(JSON.stringify({ enabled: true, policy })), 2800);
+        res.once('close', () => clearTimeout(timer));
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    const params = { appId: 'APP_test', appSecret: 'test-only', environment: 'dev', apiBase: `http://127.0.0.1:${server.address().port}` };
+    try {
+        const result = await fetchApprovedRuntimePrivacyPolicy(params);
+        assert.equal(result.status, 'ok', 'a valid multi-megabyte policy must survive the observed production response latency');
+        assert.equal(result.policy.statements.length, 1);
+        assert.deepEqual(await fetchApprovedRuntimePrivacyPolicy({ ...params, fetchTimeoutMs: 250 }), { status: 'network_error', error: 'timeout' });
+        assert.deepEqual(await fetchApprovedRuntimePrivacyPolicy({ ...params, serviceName: 'forbidden' }), { status: 'http_error', httpStatus: 403 });
+        console.log('policy body timeout and explicit timeout/auth failures OK');
+    } finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });