@reproapp/node-sdk 0.0.49 → 0.0.50

package/dist/live-capture-limits.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitLiveArguments = exports.collectCaptureOmissions = exports.limitLiveCapture = exports.LIVE_CAPTURE_LIMITS = void 0;
+const http_1 = require("http");
+const semantic_serialization_1 = require("./semantic-serialization");
+exports.LIVE_CAPTURE_LIMITS = Object.freeze({ maxDepth: 10, maxKeys: 100, maxEntries: 100 });
+const marker = (omission) => ({ __kind: 'repro-omitted', complete: false, ...omission });
+const childPath = (path, key) => `${path}[${JSON.stringify(key)}]`;
+function parseStructuredString(value) {
+    if (typeof value !== 'string' || !/^[\s]*[\[{]/.test(value))
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Snapshot only data descriptors: capture must never execute application getters. */
+function limitLiveCapture(value, rootPath = '$') {
+    const omissions = [];
+    const seen = new WeakMap();
+    const omit = (detail) => { omissions.push(detail); return marker(detail); };
+    const walk = (input, depth, path) => {
+        if (input === null || input === undefined)
+            return input;
+        if (typeof input === 'string') {
+            const parsed = parseStructuredString(input);
+            if (parsed === undefined)
+                return input;
+            const before = omissions.length;
+            const bounded = walk(parsed, depth, path);
+            // Preserve the original string exactly unless its structured data exceeded a limit.
+            return omissions.length === before ? input : JSON.stringify(bounded);
+        }
+        if (typeof input === 'bigint' || typeof input === 'symbol')
+            return String(input);
+        if (typeof input === 'function')
+            return '[Function]';
+        if (typeof input !== 'object')
+            return input;
+        const previous = seen.get(input);
+        if (previous && previous.depth <= depth)
+            return { __reproCircularRef: previous.path };
+        seen.set(input, { path, depth });
+        const descriptor = (key) => Object.getOwnPropertyDescriptor(input, key);
+        const data = (key) => descriptor(key)?.value;
+        if (data('__kind') === 'repro-omitted') {
+            const detail = { reason: data('reason'), path: data('path'), limit: data('limit'), originalCount: data('originalCount'), capturedCount: data('capturedCount') };
+            omissions.push(detail);
+            return marker(detail);
+        }
+        if (input instanceof Date)
+            return Number.isNaN(Date.prototype.getTime.call(input)) ? 'Invalid Date' : Date.prototype.toISOString.call(input);
+        if (input instanceof RegExp)
+            return RegExp.prototype.toString.call(input);
+        if (input instanceof http_1.IncomingMessage) {
+            // The business body is its own root, not depth one in a socket graph.
+            return { __kind: 'http-request', method: data('method'), url: data('originalUrl') ?? data('url'),
+                headers: walk(data('headers') ?? Object.getOwnPropertyDescriptor(http_1.IncomingMessage.prototype, 'headers')?.get?.call(input), 0, childPath(path, 'headers')),
+                query: walk(data('query'), 0, childPath(path, 'query')),
+                body: walk(data('body'), 0, childPath(path, 'body')),
+                params: walk(data('params'), 0, childPath(path, 'params')) };
+        }
+        if (input instanceof http_1.ServerResponse)
+            return { __kind: 'http-response', statusCode: data('statusCode') };
+        const projected = (0, semantic_serialization_1.projectSemanticInfrastructureValue)(input);
+        if (projected)
+            return projected.value;
+        // Mongoose stores business fields in _doc; never recurse through $__ state.
+        const documentData = (0, semantic_serialization_1.mongooseDocumentData)(input);
+        if (documentData)
+            return walk(documentData, depth, path);
+        if (depth > exports.LIVE_CAPTURE_LIMITS.maxDepth)
+            return omit({ reason: 'max-depth', path, limit: exports.LIVE_CAPTURE_LIMITS.maxDepth, capturedCount: 0 });
+        if (input instanceof Error) {
+            const details = Object.create(null);
+            for (const key of ['message', 'stack', 'cause', 'errors', ...Object.keys(input)]) {
+                const item = descriptor(key);
+                if (item)
+                    Object.defineProperty(details, key, { ...item, enumerable: true, configurable: true });
+            }
+            return walk(details, depth, path);
+        }
+        if (input instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && input instanceof SharedArrayBuffer) || input instanceof DataView) {
+            let bytes;
+            if (input instanceof DataView) {
+                const read = (key) => Object.getOwnPropertyDescriptor(DataView.prototype, key).get.call(input);
+                bytes = new Uint8Array(read('buffer'), read('byteOffset'), read('byteLength'));
+            }
+            else
+                bytes = new Uint8Array(input);
+            return { __type: input instanceof DataView ? 'DataView' : 'ArrayBuffer', values: walk(bytes, depth, path).values };
+        }
+        if (input instanceof Map) {
+            const entries = [];
+            const size = Object.getOwnPropertyDescriptor(Map.prototype, 'size').get.call(input);
+            for (const [key, item] of Map.prototype.entries.call(input)) {
+                if (entries.length >= exports.LIVE_CAPTURE_LIMITS.maxEntries)
+                    break;
+                const index = entries.length;
+                entries.push([walk(key, depth + 1, childPath(path, `key:${index}`)), walk(item, depth + 1, childPath(path, index))]);
+            }
+            if (size > entries.length)
+                entries.push(omit({ reason: 'max-entries', path, limit: 100, originalCount: size, capturedCount: entries.length }));
+            return { __type: 'Map', entries };
+        }
+        if (input instanceof Set) {
+            const values = [];
+            const size = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get.call(input);
+            for (const item of Set.prototype.values.call(input)) {
+                if (values.length >= 100)
+                    break;
+                values.push(walk(item, depth + 1, childPath(path, values.length)));
+            }
+            if (size > values.length)
+                values.push(omit({ reason: 'max-entries', path, limit: 100, originalCount: size, capturedCount: values.length }));
+            return { __type: 'Set', values };
+        }
+        if (Array.isArray(input) || (ArrayBuffer.isView(input) && !(input instanceof DataView))) {
+            const length = input.length;
+            const previousMarker = Array.isArray(input) && length === 101 ? descriptor('100')?.value : null;
+            const prior = previousMarker && Object.getOwnPropertyDescriptors(previousMarker);
+            const hasPriorLimit = prior?.__kind?.value === 'repro-omitted' && prior?.reason?.value === 'max-entries';
+            const values = [];
+            for (let i = 0; i < Math.min(length, 100); i++) {
+                const itemDescriptor = descriptor(String(i));
+                values.push(itemDescriptor && !('value' in itemDescriptor)
+                    ? omit({ reason: 'accessor', path: childPath(path, i), capturedCount: 0 })
+                    : walk(itemDescriptor?.value, depth + 1, childPath(path, i)));
+            }
+            if (length > 100)
+                values.push(hasPriorLimit
+                    ? walk(previousMarker, depth + 1, path)
+                    : omit({ reason: 'max-entries', path, limit: 100, originalCount: length, capturedCount: 100 }));
+            return Array.isArray(input) ? values : { __type: 'TypedArray', values };
+        }
+        const keys = Object.keys(input);
+        const previousMetadataKey = keys.find(key => {
+            if (!/^__reproCapture\$*$/.test(key))
+                return false;
+            const candidate = descriptor(key)?.value;
+            return candidate && Object.getOwnPropertyDescriptor(candidate, '__kind')?.value === 'repro-omitted'
+                && Object.getOwnPropertyDescriptor(candidate, 'reason')?.value === 'max-keys';
+        });
+        const businessKeys = keys.filter(key => key !== previousMetadataKey);
+        const out = Object.create(null);
+        for (const key of businessKeys.slice(0, 100)) {
+            const itemDescriptor = descriptor(key);
+            out[key] = 'value' in itemDescriptor
+                ? walk(itemDescriptor.value, depth + 1, childPath(path, key))
+                : omit({ reason: 'accessor', path: childPath(path, key), capturedCount: 0 });
+        }
+        if (businessKeys.length > 100 || previousMetadataKey) {
+            const detail = previousMetadataKey
+                ? walk(descriptor(previousMetadataKey)?.value, depth + 1, path)
+                : omit({ reason: 'max-keys', path, limit: 100, originalCount: businessKeys.length, capturedCount: 100 });
+            let metadataKey = '__reproCapture';
+            while (Object.prototype.hasOwnProperty.call(out, metadataKey))
+                metadataKey += '$';
+            out[metadataKey] = detail;
+        }
+        return out;
+    };
+    try {
+        return { value: walk(value, 0, rootPath), omissions };
+    }
+    catch {
+        return { value: omit({ reason: 'uninspectable', path: rootPath, capturedCount: 0 }), omissions };
+    }
+}
+exports.limitLiveCapture = limitLiveCapture;
+function collectCaptureOmissions(value) {
+    const result = [];
+    const seen = new WeakSet();
+    const pending = [value];
+    while (pending.length) {
+        const item = pending.pop();
+        const node = typeof item === 'string' ? parseStructuredString(item) : item;
+        if (!node || typeof node !== 'object' || seen.has(node))
+            continue;
+        seen.add(node);
+        const descriptors = Object.getOwnPropertyDescriptors(node);
+        if (descriptors.__kind?.value === 'repro-omitted') {
+            result.push({ reason: descriptors.reason?.value, path: descriptors.path?.value, limit: descriptors.limit?.value,
+                originalCount: descriptors.originalCount?.value, capturedCount: descriptors.capturedCount?.value });
+            continue;
+        }
+        for (const item of Object.values(descriptors))
+            if ('value' in item)
+                pending.push(item.value);
+    }
+    return result;
+}
+exports.collectCaptureOmissions = collectCaptureOmissions;
+function limitLiveArguments(args) {
+    const values = args.slice(0, 100).map((arg, index) => limitLiveCapture(arg, `$[${index}]`).value);
+    if (args.length > 100) {
+        const prior = Object.getOwnPropertyDescriptor(args, '100')?.value;
+        values.push(args.length === 101 && prior && Object.getOwnPropertyDescriptor(prior, '__kind')?.value === 'repro-omitted'
+            ? limitLiveCapture(prior).value
+            : marker({ reason: 'max-entries', path: '$', limit: 100, originalCount: args.length, capturedCount: 100 }));
+    }
+    return values;
+}
+exports.limitLiveArguments = limitLiveArguments;

package/dist/semantic-serialization.d.ts

@@ -2,6 +2,7 @@ export type SemanticProjection = {
     matched: true;
     value: Record<string, unknown>;
 };
+export declare function mongooseDocumentData(value: object): object | null;
 /**
  * Projects known runtime machinery into stable, non-recursive descriptions.
  * Unknown application values deliberately return null and remain fully captured.

package/dist/semantic-serialization.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectSemanticInfrastructureValue = void 0;
+exports.projectSemanticInfrastructureValue = exports.mongooseDocumentData = void 0;
 function constructorName(value) {
     if (!value || typeof value !== 'object')
         return '';
@@ -49,6 +49,13 @@ function method(value, key) {
         return false;
     }
 }
+function mongooseDocumentData(value) {
+    const doc = Object.getOwnPropertyDescriptor(value, '_doc')?.value;
+    if (!doc || typeof doc !== 'object' || !Object.getOwnPropertyDescriptor(value, '$__')?.value)
+        return null;
+    return method(value, '$__init') && method(value, '$toObject') ? doc : null;
+}
+exports.mongooseDocumentData = mongooseDocumentData;
 function primitiveStateValue(value) {
     if (value === null)
         return null;
@@ -82,6 +89,8 @@ function projectConfigurationService(value, className) {
 function projectLogger(value, className) {
     if (!/(Logger|LoggerService)$/i.test(className))
         return null;
+    if (!method(value, 'log') && !method(value, 'info'))
+        return null;
     const descriptors = ownDataDescriptors(value);
     const context = primitiveStateValue(descriptors.context?.value);
     return semanticValue('logger', className, context !== undefined ? { context } : {});
@@ -90,6 +99,15 @@ function projectNestInfrastructure(value, className) {
     if (!/(ModuleRef|ModulesContainer|InstanceWrapper|NestContainer|Injector|DiscoveryService|ExecutionContextHost|ArgumentsHost|HttpAdapterHost)$/i.test(className)) {
         return null;
     }
+    const signatures = {
+        ModuleRef: ['get', 'resolve'], ModulesContainer: ['get', 'set'],
+        InstanceWrapper: ['getInstanceByContextId'], NestContainer: ['getModules'],
+        Injector: ['loadInstance'], DiscoveryService: ['getProviders'],
+        ExecutionContextHost: ['switchToHttp', 'getArgs'], ArgumentsHost: ['switchToHttp', 'getArgs'],
+        HttpAdapterHost: ['listen$'],
+    };
+    if (!(signatures[className] ?? []).some(key => method(value, key)))
+        return null;
     return semanticValue('nestjs-infrastructure', className);
 }
 function projectRedis(value, className) {
@@ -149,6 +167,19 @@ function projectTypeOrm(value, className) {
     }
     return null;
 }
+function projectMongoInfrastructure(value, className) {
+    const signatures = {
+        MongoClient: ['connect', 'db', 'close'],
+        ClientSession: ['startTransaction', 'endSession'],
+        ConnectionPool: ['checkOut', 'checkIn'],
+        NativeConnection: ['openUri', 'model', 'close'],
+        Schema: ['add', 'path', 'plugin'],
+    };
+    const required = signatures[className];
+    return required?.every(key => method(value, key))
+        ? semanticValue('mongodb-infrastructure', className)
+        : null;
+}
 /**
  * Projects known runtime machinery into stable, non-recursive descriptions.
  * Unknown application values deliberately return null and remain fully captured.
@@ -165,6 +196,7 @@ function projectSemanticInfrastructureValue(value) {
         projectRedis(value, className) ||
         projectKafka(value, className) ||
         projectAmqp(value, className) ||
+        projectMongoInfrastructure(value, className) ||
         projectPostgres(value, className) ||
         projectTypeOrm(value, className));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,8 @@
     "node": ">=18"
   },
   "scripts": {
+    "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",
@@ -21,8 +23,11 @@
   },
   "devDependencies": {
     "@nestjs/typeorm": "^11.0.0",
+    "@testcontainers/kafka": "^11.8.1",
     "@types/express": "^5.0.3",
     "@types/pg": "^8.20.0",
+    "amqplib": "^0.10.9",
+    "kafkajs": "^2.2.4",
     "mongodb": "^6.21.0",
     "pg": "^8.22.0",
     "postgres": "^3.4.9",

package/src/index.ts

@@ -29,6 +29,7 @@ import {
     type RuntimePrivacyTraceContext,
 } from './privacy';
 import { projectSemanticInfrastructureValue } from './semantic-serialization';
+import { limitLiveCapture, limitLiveArguments, collectCaptureOmissions, type CaptureOmission } from './live-capture-limits';
 
 /**
  * ============================= IMPORTANT =============================
@@ -380,6 +381,8 @@ type PendingTraceEventRecord = TraceEventRecord & {
 };
 
 type TraceValueCaptureRef = {
+    complete?: boolean;
+    omissions?: CaptureOmission[];
     status:
         | 'stored'
         | 'truncated-for-storage'
@@ -419,6 +422,7 @@ type TraceValueBatchEntry = {
 };
 
 type TraceMaterializationConfig = {
+    captureMode?: 'live' | 'staging';
     tenantId: string;
     appId: string;
     appSecret?: string;
@@ -1213,6 +1217,7 @@ type NativeMongoSuppression = {
 };
 
 type RequestCaptureScopeState = {
+    liveCapture?: boolean;
     requestRid: string;
     transport: 'http' | 'kafka' | 'amqp' | 'background';
     backendRequestCount: number;
@@ -1246,6 +1251,7 @@ function createRequestCaptureScope(
     return {
         requestRid,
         transport,
+        liveCapture: cfg?.captureMode === 'live' || (!!cfg && cfg.captureMode !== 'staging' && !!normalizeLiveModeConfig(cfg)),
         // Every scope represents one captured transport request. This is an
         // observed expectation, not a count of successful enqueue operations.
         backendRequestCount: 1,
@@ -2599,6 +2605,7 @@ async function resolveBackendLiveContext(
         liveMode,
         '/v1/live-sessions/claim',
         {
+            liveCapture: liveMode.liveCapture,
             clientTime: requestStart,
             captureMode: 'backend-only',
             actorId,
@@ -2712,6 +2719,7 @@ function stripReproQueryFromUrl(rawUrl: string): string {
         parsed.searchParams.delete(REPRO_QUERY_SESSION_PARAM);
         parsed.searchParams.delete(REPRO_QUERY_ACTION_PARAM);
         parsed.searchParams.delete(REPRO_QUERY_START_PARAM);
+        parsed.searchParams.delete('__repro_mode');
         return `${parsed.pathname}${parsed.search}${parsed.hash}`;
     } catch {
         return rawUrl;
@@ -2725,6 +2733,7 @@ function stripReproQueryParams(req: Request): void {
             delete query[REPRO_QUERY_SESSION_PARAM];
             delete query[REPRO_QUERY_ACTION_PARAM];
             delete query[REPRO_QUERY_START_PARAM];
+            delete query.__repro_mode;
         }
     } catch {}
     try {
@@ -3439,6 +3448,11 @@ function snapshotTraceValueAtObservation(
     target = 'trace.value',
 ): any {
     try {
+        if (captureScope?.liveCapture) {
+            value = target === 'trace.args' && Array.isArray(value)
+                ? limitLiveArguments(value)
+                : limitLiveCapture(value, valuePath).value;
+        }
         const snapshot = sanitizeTraceValue(
             value,
             0,
@@ -3714,6 +3728,7 @@ async function materializePendingTraceEventsAsync(
                 appSecret: params.cfg.appSecret,
                 appName: params.cfg.appName,
                 privacy: params.cfg.privacy,
+                captureMode: params.captureScope?.liveCapture ? 'live' : params.cfg.captureMode,
             },
             maskReq: params.maskReq,
             masking: params.masking,
@@ -4223,6 +4238,18 @@ async function initializeRuntimePrivacyPolicyAtStartup(cfg: ReproMiddlewareConfi
     );
 }
 
+function isLiveCapture(cfg: ReproMiddlewareConfig, scope?: RequestCaptureScopeState | null): boolean {
+    if (scope) return scope.liveCapture === true;
+    return cfg.captureMode === 'live' || (cfg.captureMode !== 'staging' && getCtx().captureScope?.liveCapture === true);
+}
+
+function constrainLiveCapture(value: any, cfg: ReproMiddlewareConfig, target: string, scope?: RequestCaptureScopeState | null): any {
+    if (!isLiveCapture(cfg, scope)) return value;
+    return target === 'trace.args' && Array.isArray(value)
+        ? limitLiveArguments(value)
+        : limitLiveCapture(value).value;
+}
+
 function applyPrivacyThenMask(
     target: RuntimePrivacySurface,
     value: any,
@@ -4233,6 +4260,7 @@ function applyPrivacyThenMask(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -4263,6 +4291,7 @@ async function applyPrivacyThenMaskAsync(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -4342,6 +4371,7 @@ function materializeInlinePrivacyValue(
     db?: RuntimePrivacyDbContext | null,
     captureScope?: RequestCaptureScopeState | null,
 ): InlinePrivacyMaterializationResult {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -4381,6 +4411,7 @@ async function materializeInlinePrivacyValueAsync(
     db?: RuntimePrivacyDbContext | null,
     captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -5549,6 +5580,9 @@ function createCapturedValueEntry(
 ): { captureRef: TraceValueCaptureRef; entry?: TraceValueBatchEntry } | undefined {
     if (!__FULL_VALUE_CAPTURE_ENABLED) return undefined;
 
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? collectCaptureOmissions(limitedRaw) : [];
+
     const preferredLimits: FullValueCloneLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -5558,7 +5592,7 @@ function createCapturedValueEntry(
     const buildMaskedCandidate = (limits: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
-            : cloneFullValueCandidate(params.rawValue, params.capture, limits);
+            : cloneFullValueCandidate(limitedRaw, params.capture, limits);
         if (projected === undefined) return undefined;
         return applyPrivacyThenMask(
             params.target,
@@ -5579,7 +5613,7 @@ function createCapturedValueEntry(
     }
 
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
 
@@ -5605,6 +5639,7 @@ function createCapturedValueEntry(
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -5635,6 +5670,9 @@ async function createCapturedValueEntryAsync(
 ): Promise<{ captureRef: TraceValueCaptureRef; entry?: TraceValueBatchEntry } | undefined> {
     if (!__FULL_VALUE_CAPTURE_ENABLED) return undefined;
 
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? collectCaptureOmissions(limitedRaw) : [];
+
     const preferredLimits: FullValueCloneLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -5644,7 +5682,7 @@ async function createCapturedValueEntryAsync(
     const buildMaskedCandidate = async (limits: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
-            : await cloneFullValueCandidateAsync(params.rawValue, params.capture, limits);
+            : await cloneFullValueCandidateAsync(limitedRaw, params.capture, limits);
         if (projected === undefined) return undefined;
         return applyPrivacyThenMaskAsync(
             params.target,
@@ -5665,7 +5703,7 @@ async function createCapturedValueEntryAsync(
     }
 
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
 
@@ -5691,6 +5729,7 @@ async function createCapturedValueEntryAsync(
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -5892,6 +5931,8 @@ async function maybeCaptureDbValueFromCandidatesAsync(
 // reproMiddleware — unchanged behavior + passive per-request trace
 // ===================================================================
 export type ReproMiddlewareConfig = IngestClientConfig & {
+    /** Propagated recording mode. A tagged staging request never inherits live limits. */
+    captureMode?: 'live' | 'staging';
     /** API base used for backend-owned live session documents. Defaults to REPRO_API_BASE_URL/REPRO_API_BASE/privacy.apiBase. */
     apiBase?: string;
     /** Configure header capture/masking. Defaults to capturing with sensitive headers masked. */
@@ -5923,6 +5964,11 @@ export type ReproLiveActorDecision = ReproLiveActorArgs & {
 };
 
 export type ReproLiveModeConfig = {
+    /** Stable chain sampling. Runtime updates apply to new chains; targets are evaluated on each claim. */
+    liveCapture?: {
+        sampleRate?: number;
+        targets?: { actorIds?: string[]; labels?: Record<string, string>; expiresAt: number }[];
+    };
     enabled?: boolean;
     backendOnly?: boolean;
     /**
@@ -6112,6 +6158,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
         const queryTs = readRequestQueryNumber(req, REPRO_QUERY_START_PARAM);
+        const queryCaptureMode = readRequestQueryParam(req, '__repro_mode');
         if (querySid || queryAid || queryTs !== null) {
             stripReproQueryParams(req);
         }
@@ -6181,6 +6228,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 }],
             }, { priority: 'high' });
         }
+        const captureMode = backendLiveContext || req.headers['x-repro-capture-mode'] === 'live' || queryCaptureMode === 'live'
+            ? 'live' : 'staging';
+        const modeConfig = { ...captureCfg, captureMode } as ReproMiddlewareConfig;
+        shareRuntimePrivacyState(captureCfg, modeConfig);
+        captureCfg = modeConfig;
         const resolvePrivacy = (): NormalizedRuntimePrivacyPolicy | null =>
             getRuntimePrivacyState(captureCfg).policy ?? null;
 
@@ -7745,6 +7797,7 @@ function patchNodeFetchForPropagation() {
         if (runtime.aid && !hasHttpHeader(headers, KAFKA_HEADER_ACTION_ID)) {
             setHttpHeader(headers, KAFKA_HEADER_ACTION_ID, runtime.aid);
         }
+        if (runtime.sid) setHttpHeader(headers, 'x-repro-capture-mode', getCtx().captureScope?.liveCapture ? 'live' : 'staging');
         if (runtime.traceId && !hasHttpHeader(headers, KAFKA_HEADER_TRACE_ID)) {
             setHttpHeader(headers, KAFKA_HEADER_TRACE_ID, runtime.traceId);
         }
@@ -7799,6 +7852,7 @@ function patchNodeHttpModuleRequest(mod: any) {
             maybeSet(REQUEST_START_HEADER, String(alignedNow()));
             maybeSet(KAFKA_HEADER_SESSION_ID, runtime.sid);
             maybeSet(KAFKA_HEADER_ACTION_ID, runtime.aid);
+            if (runtime.sid) maybeSet('x-repro-capture-mode', getCtx().captureScope?.liveCapture ? 'live' : 'staging');
             maybeSet(KAFKA_HEADER_TRACE_ID, runtime.traceId);
             maybeSet(KAFKA_HEADER_PARENT_SPAN_ID, runtime.parentSpanId);
             maybeSet(KAFKA_HEADER_REQUEST_ID, runtime.requestRid);
@@ -7826,6 +7880,7 @@ type KafkaHeaderValue = string | Buffer | null | undefined;
 type KafkaHeaderMap = Record<string, KafkaHeaderValue>;
 type KafkaContextResolver = () => { sid?: string; aid?: string } | undefined;
 type KafkaPropagationContext = {
+    captureMode?: 'live' | 'staging';
     sid: string | null;
     aid: string | null;
     traceId: string | null;
@@ -7990,6 +8045,11 @@ async function materializeKafkaRequestBody(
     body: Record<string, any>,
     captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
+    // Broker bodies have no separate full-value reference. Returning the trace
+    // inline preview here would permanently replace message arrays with 20 items.
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: constrainLiveCapture(sanitizeInlinePrivacyValue(body), cfg, 'request.body', captureScope) };
+    }
     return materializeInlinePrivacyValueAsync(
         'request.body',
         sanitizeInlinePrivacyValue(body),
@@ -8053,7 +8113,8 @@ function resolveKafkaContext(cfg: KafkaJsPatchConfig, headers: any): KafkaPropag
         null;
     const requestRid = readKafkaHeader(headers, KAFKA_HEADER_REQUEST_ID);
 
-    return { sid, aid, traceId, parentSpanId, requestRid };
+    return { sid, aid, traceId, parentSpanId, requestRid,
+        captureMode: readKafkaHeader(headers, 'x-repro-capture-mode') === 'live' || ctx.captureScope?.liveCapture ? 'live' : 'staging' };
 }
 
 function withOptionalTraceContext<T>(traceId: string | null, fn: () => Promise<T>): Promise<T> {
@@ -8420,6 +8481,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         [KAFKA_HEADER_REQUEST_ID]: publishRid,
                         [KAFKA_HEADER_SESSION_ID]: sid,
                         [KAFKA_HEADER_ACTION_ID]: aid,
+                        'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                     }),
                 };
             });
@@ -8552,6 +8614,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                                 [KAFKA_HEADER_REQUEST_ID]: publishRid,
                                 [KAFKA_HEADER_SESSION_ID]: sid,
                                 [KAFKA_HEADER_ACTION_ID]: aid,
+                                'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                             }),
                         };
                     }),
@@ -8668,6 +8731,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8778,6 +8842,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8972,6 +9037,7 @@ export function patchKafkaJs(cfg: KafkaJsPatchConfig) {
 type AmqpHeaderMap = Record<string, any>;
 type AmqpContextResolver = () => { sid?: string; aid?: string } | undefined;
 type AmqpPropagationContext = {
+    captureMode?: 'live' | 'staging';
     sid: string | null;
     aid: string | null;
     traceId: string | null;
@@ -9240,7 +9306,8 @@ function resolveAmqpContext(cfg: AmqplibPatchConfig, headers: any): AmqpPropagat
         null;
     const requestRid = readAmqpHeader(headers, KAFKA_HEADER_REQUEST_ID);
 
-    return { sid, aid, traceId, parentSpanId, requestRid };
+    return { sid, aid, traceId, parentSpanId, requestRid,
+        captureMode: readAmqpHeader(headers, 'x-repro-capture-mode') === 'live' || ctx.captureScope?.liveCapture ? 'live' : 'staging' };
 }
 
 function withOptionalTraceContextSync<T>(traceId: string | null, fn: () => T): T {
@@ -9478,6 +9545,7 @@ function patchAmqplibPublishMethod(
             [KAFKA_HEADER_REQUEST_ID]: publishRid,
             [KAFKA_HEADER_SESSION_ID]: sid,
             [KAFKA_HEADER_ACTION_ID]: aid,
+            'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
         };
         const shouldPropagate = hasAmqpPropagationValues(propagationValues);
         const callbackIndex = args.length > 0 && typeof args[args.length - 1] === 'function'
@@ -9586,6 +9654,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
         const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'amqp', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {