@reproapp/node-sdk 0.0.50 → 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 =============================
@@ -1121,22 +1123,20 @@ function hasActiveClientRequests() {
 function noteClientActivity(now = Date.now()) {
     lastClientActivityAt = now;
 }
-function getSdkBackgroundDelayMs(now = Date.now()) {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt) {
+    // Bound deferral by work age, not just by a continuously active request.
+    // Short non-overlapping requests reset oldestActiveClientRequestAt forever.
+    const oldestWorkAt = Math.min(sdkBackgroundHighQueue[0]?.enqueuedAt ?? Infinity, sdkBackgroundQueue[0]?.enqueuedAt ?? Infinity, ingestEnqueuedAt ?? Infinity, oldestActiveClientRequestAt ?? Infinity);
+    const remainingDeferMs = Number.isFinite(oldestWorkAt) && Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS)
+        ? Math.max(0, oldestWorkAt + SDK_BACKGROUND_MAX_DEFER_MS - now)
+        : Infinity;
     if (hasActiveClientRequests()) {
-        if (oldestActiveClientRequestAt !== null &&
-            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
-            SDK_BACKGROUND_MAX_DEFER_MS >= 0) {
-            const activeForMs = now - oldestActiveClientRequestAt;
-            if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS)
-                return 0;
-            return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
-        }
-        return SDK_BACKGROUND_IDLE_DELAY_MS;
+        return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, remainingDeferMs);
     }
     const sinceLastActivity = now - lastClientActivityAt;
     const idleDelayRemaining = Math.max(0, SDK_BACKGROUND_IDLE_DELAY_MS - sinceLastActivity);
     const quietWindowRemaining = Math.max(0, sdkBackgroundQuietUntil - now);
-    return Math.max(idleDelayRemaining, quietWindowRemaining);
+    return Math.min(Math.max(idleDelayRemaining, quietWindowRemaining), remainingDeferMs);
 }
 function shouldDeferSdkBackgroundWork(now = Date.now()) {
     return getSdkBackgroundDelayMs(now) > 0;
@@ -1172,6 +1172,7 @@ function scheduleTraceMaterializerIdleShutdown() {
         const worker = traceMaterializerWorker;
         traceMaterializerWorker = null;
         if (worker) {
+            traceMaterializerExpectedTerminations.add(worker);
             try {
                 void worker.terminate?.();
             }
@@ -1197,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;
     }
@@ -1258,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();
@@ -1342,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) {
@@ -1372,13 +1383,8 @@ function beginClientRequest() {
         oldestActiveClientRequestAt = now;
     }
     activeClientRequestCount += 1;
-    if (sdkBackgroundTimer) {
-        try {
-            clearTimeout(sdkBackgroundTimer);
-        }
-        catch { }
-        sdkBackgroundTimer = null;
-    }
+    // The scheduled drain rechecks activity; cancelling it here loses the
+    // queued work's deadline under sustained traffic.
 }
 function endClientRequest() {
     activeClientRequestCount = Math.max(0, activeClientRequestCount - 1);
@@ -1397,15 +1403,18 @@ function endClientRequest() {
     }
 }
 function scheduleSdkBackgroundWork(work, options = {}) {
+    const item = { work, enqueuedAt: Date.now() };
     if (options.priority === 'high') {
-        sdkBackgroundHighQueue.push(work);
+        sdkBackgroundHighQueue.push(item);
     }
     else {
-        sdkBackgroundQueue.push(work);
+        sdkBackgroundQueue.push(item);
     }
     scheduleSdkBackgroundDrain();
 }
 function scheduleSdkBackgroundDrain(delayMs = 0) {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length)
+        return;
     if (sdkBackgroundTimer)
         return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
@@ -1441,12 +1450,12 @@ async function drainSdkBackgroundQueue() {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work)
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item)
                 continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             }
             catch {
                 // never break user code
@@ -1464,8 +1473,8 @@ async function drainSdkBackgroundQueue() {
     }
 }
 (0, client_1.configureIngestQueueDrain)({
-    shouldDefer: shouldDeferSdkBackgroundWork,
-    deferMs: SDK_BACKGROUND_IDLE_DELAY_MS,
+    shouldDefer: (enqueuedAt) => getSdkBackgroundDelayMs(Date.now(), enqueuedAt) > 0,
+    deferMs: Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, SDK_BACKGROUND_MAX_DEFER_MS),
 });
 // Track in-flight requests per session so we can delay flushing until a session is drained.
 const sessionInFlight = new Map();
@@ -2824,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)
@@ -3006,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 {
@@ -3020,7 +3046,7 @@ async function materializePendingTraceEventsAsync(events, params) {
         }
     }
     try {
-        return await materializePendingTraceEventsOffThread(events, {
+        const materialized = await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
                 tenantId: params.cfg.tenantId,
@@ -3036,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 {
@@ -3063,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;
         });
@@ -3192,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];
@@ -3338,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;
 }
@@ -4200,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/ingest/client.d.ts

@@ -3,8 +3,8 @@ export type EnqueueIngestOptions = {
     priority?: 'normal' | 'high' | 'critical';
 };
 export declare const configureIngestQueueDrain: (options: {
-    shouldDefer?: (() => boolean) | null;
-    deferMs?: number;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null | undefined;
+    deferMs?: number | undefined;
 }) => void;
 export declare const kickIngestQueueDrain: () => void;
 export declare const postIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => Promise<void>;

package/dist/ingest/client.js

@@ -61,7 +61,7 @@ const kickIngestQueueDrain = () => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 exports.kickIngestQueueDrain = kickIngestQueueDrain;
@@ -233,12 +233,12 @@ const scheduleDrain = (delayMs = 0) => {
     if (drainTimer) {
         return;
     }
-    const nextDelay = shouldDeferDrain?.()
+    const nextDelay = shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)
         ? Math.max(delayMs, deferDrainMs)
         : delayMs;
     drainTimer = setTimeout(() => {
         drainTimer = null;
-        if (shouldDeferDrain?.()) {
+        if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
             scheduleDrain(deferDrainMs);
             return;
         }
@@ -302,14 +302,14 @@ const drainIngestQueue = async () => {
     if (draining) {
         return;
     }
-    if (shouldDeferDrain?.()) {
+    if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
         scheduleDrain(deferDrainMs);
         return;
     }
     draining = true;
     try {
         while (ingestQueue.length > 0) {
-            if (shouldDeferDrain?.()) {
+            if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
                 scheduleDrain(deferDrainMs);
                 return;
             }
@@ -367,6 +367,7 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {

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.50",
+  "version": "0.0.52",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,13 +9,14 @@
     "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",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
     "test": "npm run build && node test/semantic-serialization.test.js && node test/semantic-serialization-trace.test.js && node test/content-addressed-trace-values.test.js && node test/trace-observation-snapshots.test.js && node test/session-storage-budget.test.js && node test/trace-source-exclude.test.js && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/sdk-background-timeout-isolation.test.js && node test/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-high-priority-fairness.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-service-scope.test.js && node test/privacy-policy-index.test.js && node test/policy-capture-attestation.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
-    "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
+    "test:containers": "npm run build && node test/background-continuous-traffic.testcontainers.test.js && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

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';
 
 /**
@@ -1552,8 +1554,9 @@ let activeClientRequestCount = 0;
 let oldestActiveClientRequestAt: number | null = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
-const sdkBackgroundHighQueue: Array<() => Promise<void> | void> = [];
-const sdkBackgroundQueue: Array<() => Promise<void> | void> = [];
+type SdkBackgroundWork = { work: () => Promise<void> | void; enqueuedAt: number };
+const sdkBackgroundHighQueue: SdkBackgroundWork[] = [];
+const sdkBackgroundQueue: SdkBackgroundWork[] = [];
 let sdkBackgroundTimer: NodeJS.Timeout | null = null;
 let sdkBackgroundDraining = false;
 let traceMaterializerWorker: any = null;
@@ -1575,23 +1578,25 @@ function noteClientActivity(now = Date.now()): void {
     lastClientActivityAt = now;
 }
 
-function getSdkBackgroundDelayMs(now = Date.now()): number {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt?: number): number {
+    // Bound deferral by work age, not just by a continuously active request.
+    // Short non-overlapping requests reset oldestActiveClientRequestAt forever.
+    const oldestWorkAt = Math.min(
+        sdkBackgroundHighQueue[0]?.enqueuedAt ?? Infinity,
+        sdkBackgroundQueue[0]?.enqueuedAt ?? Infinity,
+        ingestEnqueuedAt ?? Infinity,
+        oldestActiveClientRequestAt ?? Infinity,
+    );
+    const remainingDeferMs = Number.isFinite(oldestWorkAt) && Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS)
+        ? Math.max(0, oldestWorkAt + SDK_BACKGROUND_MAX_DEFER_MS - now)
+        : Infinity;
     if (hasActiveClientRequests()) {
-        if (
-            oldestActiveClientRequestAt !== null &&
-            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
-            SDK_BACKGROUND_MAX_DEFER_MS >= 0
-        ) {
-            const activeForMs = now - oldestActiveClientRequestAt;
-            if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS) return 0;
-            return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
-        }
-        return SDK_BACKGROUND_IDLE_DELAY_MS;
+        return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, remainingDeferMs);
     }
     const sinceLastActivity = now - lastClientActivityAt;
     const idleDelayRemaining = Math.max(0, SDK_BACKGROUND_IDLE_DELAY_MS - sinceLastActivity);
     const quietWindowRemaining = Math.max(0, sdkBackgroundQuietUntil - now);
-    return Math.max(idleDelayRemaining, quietWindowRemaining);
+    return Math.min(Math.max(idleDelayRemaining, quietWindowRemaining), remainingDeferMs);
 }
 
 function shouldDeferSdkBackgroundWork(now = Date.now()): boolean {
@@ -1622,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);
@@ -1646,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;
     }
@@ -1697,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();
@@ -1776,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) {
@@ -1804,10 +1819,8 @@ function beginClientRequest(): void {
         oldestActiveClientRequestAt = now;
     }
     activeClientRequestCount += 1;
-    if (sdkBackgroundTimer) {
-        try { clearTimeout(sdkBackgroundTimer); } catch {}
-        sdkBackgroundTimer = null;
-    }
+    // The scheduled drain rechecks activity; cancelling it here loses the
+    // queued work's deadline under sustained traffic.
 }
 
 function endClientRequest(): void {
@@ -1828,15 +1841,17 @@ function scheduleSdkBackgroundWork(
     work: () => Promise<void> | void,
     options: { priority?: 'high' | 'normal' } = {},
 ): void {
+    const item = { work, enqueuedAt: Date.now() };
     if (options.priority === 'high') {
-        sdkBackgroundHighQueue.push(work);
+        sdkBackgroundHighQueue.push(item);
     } else {
-        sdkBackgroundQueue.push(work);
+        sdkBackgroundQueue.push(item);
     }
     scheduleSdkBackgroundDrain();
 }
 
 function scheduleSdkBackgroundDrain(delayMs = 0): void {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length) return;
     if (sdkBackgroundTimer) return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
     sdkBackgroundTimer = setTimeout(() => {
@@ -1871,11 +1886,11 @@ async function drainSdkBackgroundQueue(): Promise<void> {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work) continue;
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item) continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             } catch {
                 // never break user code
             }
@@ -1891,8 +1906,8 @@ async function drainSdkBackgroundQueue(): Promise<void> {
 }
 
 configureIngestQueueDrain({
-    shouldDefer: shouldDeferSdkBackgroundWork,
-    deferMs: SDK_BACKGROUND_IDLE_DELAY_MS,
+    shouldDefer: (enqueuedAt) => getSdkBackgroundDelayMs(Date.now(), enqueuedAt) > 0,
+    deferMs: Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, SDK_BACKGROUND_MAX_DEFER_MS),
 });
 
 // Track in-flight requests per session so we can delay flushing until a session is drained.
@@ -3427,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')
@@ -3702,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 {
@@ -3720,7 +3750,7 @@ async function materializePendingTraceEventsAsync(
         }
     }
     try {
-        return await materializePendingTraceEventsOffThread(events, {
+        const materialized = await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
                 tenantId: params.cfg.tenantId,
@@ -3736,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, {
@@ -3772,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;
         });
@@ -3922,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[] {
@@ -4101,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;
@@ -5139,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/ingest/client.ts

@@ -44,6 +44,7 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
+    enqueuedAt: number;
     priority: 'normal' | 'high' | 'critical';
 };
 
@@ -59,13 +60,13 @@ let draining = false;
 let criticalDraining = false;
 let backoffMs = 0;
 let criticalBackoffMs = 0;
-let shouldDeferDrain: (() => boolean) | null = null;
+let shouldDeferDrain: ((enqueuedAt?: number) => boolean) | null = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 const throttledUntil = new Map<string, number>();
 const throttleDelay = (config: IngestClientConfig) => Math.max(0, (throttledUntil.get(resolveIngestUrl(config)) ?? 0) - Date.now());
 
 export const configureIngestQueueDrain = (options: {
-    shouldDefer?: (() => boolean) | null;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null;
     deferMs?: number;
 }): void => {
     shouldDeferDrain = options.shouldDefer ?? null;
@@ -79,7 +80,7 @@ export const kickIngestQueueDrain = (): void => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 
@@ -288,12 +289,12 @@ const scheduleDrain = (delayMs = 0): void => {
     if (drainTimer) {
         return;
     }
-    const nextDelay = shouldDeferDrain?.()
+    const nextDelay = shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)
         ? Math.max(delayMs, deferDrainMs)
         : delayMs;
     drainTimer = setTimeout(() => {
         drainTimer = null;
-        if (shouldDeferDrain?.()) {
+        if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
             scheduleDrain(deferDrainMs);
             return;
         }
@@ -365,14 +366,14 @@ const drainIngestQueue = async (): Promise<void> => {
     if (draining) {
         return;
     }
-    if (shouldDeferDrain?.()) {
+    if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
         scheduleDrain(deferDrainMs);
         return;
     }
     draining = true;
     try {
         while (ingestQueue.length > 0) {
-            if (shouldDeferDrain?.()) {
+            if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
                 scheduleDrain(deferDrainMs);
                 return;
             }
@@ -444,6 +445,7 @@ export const enqueueIngestEntries = (
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {

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/background-continuous-traffic.testcontainers.test.js

@@ -0,0 +1,100 @@
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '2000';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '200';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { GenericContainer, Wait } = require('testcontainers');
+const { initRepro } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function main() {
+  const events = [];
+  let rejectedOnce = false;
+  const sink = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      const batch = JSON.parse(Buffer.concat(chunks)).events;
+      if (!rejectedOnce && batch.some(event => event.event_type === 'backend_request')) {
+        rejectedOnce = true;
+        res.writeHead(503); res.end('{}'); return;
+      }
+      events.push(...batch);
+      res.writeHead(202); res.end('{}');
+    });
+  });
+  await new Promise(resolve => sink.listen(0, '127.0.0.1', resolve));
+  let mongo, app, polling;
+  let stopped = false, polls = 0, maxPollGap = 0;
+  try {
+    mongo = await new GenericContainer('mongo:7').withExposedPorts(27017)
+      .withWaitStrategy(Wait.forListeningPorts()).start();
+    const config = { tenantId: 'TENANT_busy', appId: 'APP_busy', appSecret: 'test',
+      privacy: { environment: 'dev', captureRaw: true },
+      ingestBase: `http://127.0.0.1:${sink.address().port}`,
+      tracing: { fullValueCapture: true, disableFunctionTypes: ['constructor'], logFunctionCalls: false } };
+    await initRepro(config);
+    app = await require('./fixtures/live-capture-limits-server').start(config,
+      `mongodb://${mongo.getHost()}:${mongo.getMappedPort(27017)}/busy`);
+    const base = `http://127.0.0.1:${app.server.address().port}`;
+    polling = (async () => {
+      let previous = Date.now();
+      while (!stopped) {
+        // Untagged, short requests also participate in the SDK's activity tracking.
+        const response = await fetch(`${base}/uncorrelated`);
+        await response.text();
+        maxPollGap = Math.max(maxPollGap, Date.now() - previous);
+        previous = Date.now();
+        polls++;
+        await sleep(20);
+      }
+    })();
+    for (const mode of ['live', 'staging']) {
+      const response = await fetch(`${base}/shipment?__repro_sid=S_busy_${mode}&__repro_aid=A_${mode}&__repro_mode=${mode}`);
+      assert.equal(response.status, 200);
+      const body = await response.json();
+      assert.equal(body.rows.length, 157, 'capture must not change business responses');
+      assert.equal(body.rows[156].id, 156);
+    }
+    const complete = () => ['live', 'staging'].every(mode => {
+      const scoped = events.filter(event => event.session_id === `S_busy_${mode}`);
+      return ['request_capture_start', 'backend_request', 'request_capture_manifest', 'trace_batch', 'db_change']
+        .every(type => scoped.some(event => event.event_type === type));
+    });
+    // Do not call flushIngestQueue: automatic delivery must work while traffic continues.
+    const deadline = Date.now() + 6000;
+    while (!complete() && Date.now() < deadline) await sleep(25);
+    assert(polls > 5, 'continuous traffic must overlap capture finalization');
+    assert(maxPollGap < 2000, `traffic must not accidentally create an idle window: ${maxPollGap}ms`);
+    assert(complete(), `uploads starved during short requests: ${JSON.stringify(events.map(e => [e.session_id, e.event_type]))}`);
+    assert(rejectedOnce, 'the test must exercise a real collector retry');
+    for (const mode of ['live', 'staging']) {
+      const scoped = events.filter(event => event.session_id === `S_busy_${mode}`);
+      const requests = scoped.filter(event => event.event_type === 'backend_request');
+      assert.equal(requests.length, 1, 'finish and close must not duplicate requests');
+      const request = requests[0].payload.request;
+      const values = scoped.flatMap(e => [...(e.payload.requestValues || []), ...(e.payload.traceValues || []), ...(e.payload.dbValues || [])]);
+      const body = values.find(v => v.id === request.respBodyValueCapture?.valueId)?.value || request.respBody;
+      assert.equal(body.rows.length, mode === 'live' ? 101 : 157);
+      const trace = scoped.flatMap(e => e.payload.trace || []).find(e => e.fn === 'inspectShipment' && e.type === 'enter');
+      assert(trace, 'instrumented function arguments must survive background delivery');
+      const args = values.find(v => v.id === trace.argsValueCapture?.valueId)?.value || trace.args;
+      assert.equal(args[0].rows.length, mode === 'live' ? 101 : 157);
+      assert(scoped.flatMap(e => e.payload.db || []).some(change => change.op === 'findOne'));
+    }
+    console.log(`continuous short HTTP traffic: complete live/staging captures delivered during ${polls} requests`);
+  } finally {
+    stopped = true;
+    if (polling) await polling;
+    if (app) await app.close();
+    await sleep(2100);
+    await flushIngestQueue();
+    await new Promise(resolve => sink.close(resolve));
+    if (mongo) await mongo.stop();
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

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; });