@reproapp/node-sdk 0.0.47 → 0.0.49

package/dist/index.d.ts

@@ -27,6 +27,7 @@ import type { Request, Response, NextFunction } from 'express';
 import type { Schema } from 'mongoose';
 import { type IngestClientConfig } from './ingest/client';
 import { type NormalizedRuntimePrivacyPolicy, type RuntimePrivacyConfig, type RuntimePrivacyDbContext, type RuntimePrivacySurface } from './privacy';
+import { projectSemanticInfrastructureValue } from './semantic-serialization';
 type SpanContext = {
     traceId: string | null;
     spanId: string | number | null;
@@ -106,6 +107,7 @@ type TraceValueBatchEntry = {
     eventIndex?: number;
 };
 type TraceMaterializationConfig = {
+    tenantId: string;
     appId: string;
     appSecret?: string;
     appName?: string;
@@ -118,6 +120,7 @@ type TraceMaterializationWorkerPayload = {
     masking: NormalizedMaskingConfig | null;
     privacy: NormalizedRuntimePrivacyPolicy | null;
     fullValueCaptureEnabled: boolean;
+    valueNamespace?: string;
 };
 export type HeaderRule = string | RegExp;
 export type HeaderCaptureOptions = {
@@ -295,6 +298,8 @@ type RequestCaptureScopeState = {
     privacyMode: 'policy' | 'fallback' | 'raw';
     privacyPolicyFingerprint?: string;
     privacyStatementCount: number;
+    emittedValueDefinitionIds: Set<string>;
+    traceObservationSnapshots: Map<string, any>;
 };
 type BackendLiveTimingConfig = {
     sessionMaxDurationMs: number;
@@ -334,7 +339,7 @@ type InlinePrivacyMaterializationResult = {
 };
 declare function materializeInlinePrivacyValueAsync(target: RuntimePrivacySurface, value: any, cfg: ReproMiddlewareConfig, req: MaskRequestContext, trace: TraceEventForFilter | null, masking: NormalizedMaskingConfig | null, privacy: NormalizedRuntimePrivacyPolicy | null, db?: RuntimePrivacyDbContext | null, captureScope?: RequestCaptureScopeState | null): Promise<InlinePrivacyMaterializationResult>;
 declare function getEventTraceValueEntries(event: TraceEventRecord | PendingTraceEventRecord): TraceValueBatchEntry[] | undefined;
-declare function estimateTraceBatchSerializedBytes(batch: TraceEventRecord[], requestRid: string, actionId: string | null | undefined, batchIndex: number): number;
+declare function estimateTraceBatchSerializedBytes(batch: TraceEventRecord[], requestRid: string, actionId: string | null | undefined, batchIndex: number, previouslyEmittedValueIds?: ReadonlySet<string>): number;
 declare function chunkTraceEventsForTransport(events: TraceEventRecord[], requestRid: string, actionId: string | null | undefined): TraceEventRecord[][];
 export type ReproMiddlewareConfig = IngestClientConfig & {
     /** API base used for backend-owned live session documents. Defaults to REPRO_API_BASE_URL/REPRO_API_BASE/privacy.apiBase. */
@@ -491,6 +496,7 @@ export declare const __reproTestHooks: {
     estimateTraceBatchSerializedBytesForTest: typeof estimateTraceBatchSerializedBytes;
     sanitizeTraceValueForPrivacyForTest: typeof sanitizeTraceValueForPrivacy;
     sanitizeMaterializedTraceValueForTest: typeof sanitizeMaterializedTraceValue;
+    projectSemanticInfrastructureValueForTest: typeof projectSemanticInfrastructureValue;
     getEventTraceValueEntriesForTest: typeof getEventTraceValueEntries;
 };
 export {};

package/dist/index.js

@@ -9,6 +9,7 @@ const path_1 = require("path");
 const url_1 = require("url");
 const client_1 = require("./ingest/client");
 const privacy_1 = require("./privacy");
+const semantic_serialization_1 = require("./semantic-serialization");
 /**
  * ============================= IMPORTANT =============================
  * We snapshot Mongoose core methods BEFORE tracer init, then re-apply them
@@ -837,6 +838,8 @@ function createRequestCaptureScope(requestRid, transport, cfg) {
         privacyMode,
         privacyPolicyFingerprint: privacy?.fingerprint,
         privacyStatementCount: privacy?.statements.length ?? 0,
+        emittedValueDefinitionIds: new Set(),
+        traceObservationSnapshots: new Map(),
     };
 }
 function recordRequestCaptureFailure(scope, stage, target, reason) {
@@ -2275,7 +2278,11 @@ const TRACE_MAX_BATCHES_PER_REQUEST = (() => {
     const env = Number(process.env.REPRO_TRACE_MAX_BATCHES_PER_REQUEST);
     if (Number.isFinite(env) && env > 0)
         return Math.trunc(env);
-    return Math.ceil(TRACE_MAX_EVENTS_PER_REQUEST / TRACE_BATCH_SIZE);
+    // Byte-based splitting can legitimately produce one batch per event when
+    // every event owns a distinct large value. The event limit remains the
+    // hard upper bound; deriving this from the count-only batch size silently
+    // dropped otherwise valid events after ten batches.
+    return TRACE_MAX_EVENTS_PER_REQUEST;
 })();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
@@ -2603,6 +2610,10 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder)
         return mongoPlaceholder;
+    const semanticProjection = (0, semantic_serialization_1.projectSemanticInfrastructureValue)(value);
+    if (semanticProjection) {
+        return sanitizeTraceValue(semanticProjection.value, depth, seen, options, valuePath);
+    }
     if (isThenable(value)) {
         return { __type: 'Promise', state: 'pending' };
     }
@@ -2800,6 +2811,61 @@ function normalizeRawTraceArgs(values) {
 function hasMeaningfulRawTraceError(error) {
     return error !== undefined && error !== null;
 }
+const TRACE_OBSERVATION_SNAPSHOT = Symbol('repro.traceObservationSnapshot');
+// Trace events can remain queued after user code mutates the observed objects.
+// Intern immutable semantic snapshots per request so temporal evidence stays
+// correct without retaining another full copy for repeated unchanged values.
+function internTraceObservationSnapshot(snapshot, captureScope) {
+    if (!captureScope || snapshot === null || typeof snapshot !== 'object') {
+        return snapshot;
+    }
+    const serialized = stableSerializeTraceValue(snapshot);
+    if (serialized === null)
+        return snapshot;
+    const digest = (0, crypto_1.createHash)('sha256')
+        .update('repro-trace-observation-v1\0')
+        .update(serialized)
+        .digest('hex');
+    const existing = captureScope.traceObservationSnapshots.get(digest);
+    if (existing !== undefined)
+        return existing;
+    captureScope.traceObservationSnapshots.set(digest, snapshot);
+    return snapshot;
+}
+function snapshotTraceValueAtObservation(value, captureScope, valuePath = '$', target = 'trace.value') {
+    try {
+        const snapshot = sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true }, valuePath);
+        return internTraceObservationSnapshot(snapshot, captureScope);
+    }
+    catch {
+        recordRequestCaptureFailure(captureScope, 'trace.snapshot', target, 'snapshot_failed');
+        return makeOmittedValue('capture-snapshot-failed');
+    }
+}
+function snapshotTraceArgsAtObservation(values, captureScope) {
+    const snapshot = snapshotTraceValueAtObservation(normalizeRawTraceArgs(values), captureScope, '$', 'trace.args');
+    return Array.isArray(snapshot) ? snapshot : [snapshot];
+}
+function snapshotRawTraceEventAtObservation(raw, captureScope) {
+    if (!raw || typeof raw !== 'object' || raw[TRACE_OBSERVATION_SNAPSHOT] === true) {
+        return raw;
+    }
+    const snapshot = { ...raw };
+    if (raw.args !== undefined) {
+        snapshot.args = snapshotTraceArgsAtObservation(raw.args, captureScope);
+    }
+    if (raw.returnValue !== undefined) {
+        snapshot.returnValue = snapshotTraceValueAtObservation(raw.returnValue, captureScope, '$', 'trace.returnValue');
+    }
+    if (hasMeaningfulRawTraceError(raw.error)) {
+        snapshot.error = snapshotTraceValueAtObservation(raw.error, captureScope, '$', 'trace.error');
+    }
+    Object.defineProperty(snapshot, TRACE_OBSERVATION_SNAPSHOT, {
+        value: true,
+        enumerable: false,
+    });
+    return snapshot;
+}
 function attachTraceValueEntry(event, entry) {
     const current = event[TRACE_FULL_VALUE_ENTRY_SYMBOL];
     if (Array.isArray(current)) {
@@ -2824,6 +2890,7 @@ async function materializePendingTraceEvents(events, params) {
             trace: candidate,
             masking: params.masking,
             privacy: activePrivacy,
+            valueNamespace: params.valueNamespace,
         };
         const traceValueMetadata = {
             fn: evt.fn,
@@ -2946,6 +3013,7 @@ async function materializePendingTraceEventsAsync(events, params) {
         return await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
+                tenantId: params.cfg.tenantId,
                 appId: params.cfg.appId,
                 appSecret: params.cfg.appSecret,
                 appName: params.cfg.appName,
@@ -2955,6 +3023,7 @@ async function materializePendingTraceEventsAsync(events, params) {
             masking: params.masking,
             privacy,
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
+            valueNamespace: params.valueNamespace,
         });
     }
     catch (err) {
@@ -2981,6 +3050,7 @@ async function __materializePendingTraceEventsForWorker(payload) {
             maskReq: payload.maskReq,
             masking: payload.masking,
             resolvePrivacy: () => payload.privacy,
+            valueNamespace: payload.valueNamespace,
         });
         return materialized.map((event) => {
             const entries = getEventTraceValueEntries(event);
@@ -3982,6 +4052,10 @@ function cloneFullValueCandidate(value, ctx, limits, depth = 0, seen = new WeakM
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder)
         return undefined;
+    const semanticProjection = (0, semantic_serialization_1.projectSemanticInfrastructureValue)(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidate(semanticProjection.value, ctx, limits, depth, seen, valuePath);
+    }
     if (isThenable(value))
         return undefined;
     if (shouldSkipFullValueObject(value))
@@ -4166,6 +4240,10 @@ async function cloneFullValueCandidateAsync(value, ctx, limits, depth = 0, seen
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder)
         return undefined;
+    const semanticProjection = (0, semantic_serialization_1.projectSemanticInfrastructureValue)(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidateAsync(semanticProjection.value, ctx, limits, depth, seen, valuePath);
+    }
     if (isThenable(value))
         return undefined;
     if (shouldSkipFullValueObject(value))
@@ -4314,13 +4392,16 @@ function getEventTraceValueEntries(event) {
     }
     return undefined;
 }
-function collectBatchTraceValueEntries(batch, batchIndex) {
+function collectBatchTraceValueEntries(batch, batchIndex, emittedValueIds = new Set()) {
     const collected = [];
     batch.forEach((event, eventIndex) => {
         const entries = getEventTraceValueEntries(event);
         if (!Array.isArray(entries) || !entries.length)
             return;
         entries.forEach((entry) => {
+            if (emittedValueIds.has(entry.id))
+                return;
+            emittedValueIds.add(entry.id);
             collected.push({
                 ...entry,
                 batchIndex,
@@ -4338,8 +4419,25 @@ function serializedByteLength(value) {
         return Number.MAX_SAFE_INTEGER;
     }
 }
-function estimateTraceBatchSerializedBytes(batch, requestRid, actionId, batchIndex) {
-    const traceValues = collectBatchTraceValueEntries(batch, batchIndex);
+function contentAddressedValueId(target, candidateSerialized, capture) {
+    const config = capture.runtimeConfig;
+    const signingKey = String(config.appSecret ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`);
+    const namespace = String(capture.valueNamespace ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`);
+    const digest = (0, crypto_1.createHmac)('sha256', signingKey)
+        .update('repro-captured-value-v1\0')
+        .update(namespace)
+        .update('\0')
+        .update(target)
+        .update('\0')
+        .update(candidateSerialized)
+        .digest('hex')
+        .slice(0, 40);
+    return `rv1_${digest}`;
+}
+function estimateTraceBatchSerializedBytes(batch, requestRid, actionId, batchIndex, previouslyEmittedValueIds = new Set()) {
+    const traceValues = collectBatchTraceValueEntries(batch, batchIndex, new Set(previouslyEmittedValueIds));
     return serializedByteLength({
         actionId: actionId ?? null,
         trace: batch,
@@ -4358,26 +4456,32 @@ function chunkTraceEventsForTransport(events, requestRid, actionId) {
     const boundedEvents = boundTraceEventsForTransport(events);
     const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches = [];
+    const emittedValueIds = new Set();
     let current = [];
+    const commitCurrent = () => {
+        if (!current.length)
+            return;
+        collectBatchTraceValueEntries(current, sizedBatches.length, emittedValueIds);
+        sizedBatches.push(current);
+        current = [];
+    };
     for (const event of countBatches.flat()) {
         if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
             break;
         }
         if (current.length >= TRACE_BATCH_SIZE) {
-            sizedBatches.push(current);
-            current = [];
+            commitCurrent();
             if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
                 break;
             }
         }
         const candidate = current.concat(event);
         const batchIndex = sizedBatches.length;
-        const estimatedBytes = estimateTraceBatchSerializedBytes(candidate, requestRid, actionId, batchIndex);
+        const estimatedBytes = estimateTraceBatchSerializedBytes(candidate, requestRid, actionId, batchIndex, emittedValueIds);
         if (current.length > 0 &&
             estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES) {
-            sizedBatches.push(current);
+            commitCurrent();
             if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
-                current = [];
                 break;
             }
             current = [event];
@@ -4387,7 +4491,7 @@ function chunkTraceEventsForTransport(events, requestRid, actionId) {
     }
     if (current.length > 0 &&
         sizedBatches.length < TRACE_MAX_BATCHES_PER_REQUEST) {
-        sizedBatches.push(current);
+        commitCurrent();
     }
     return sizedBatches;
 }
@@ -4424,7 +4528,7 @@ function createCapturedValueEntry(params) {
     if (!candidateSerialized || candidateSerialized === previewSerialized) {
         return undefined;
     }
-    const valueId = (0, crypto_1.randomUUID)();
+    const valueId = contentAddressedValueId(params.target, candidateSerialized, params.capture);
     const projectedKind = candidate && typeof candidate === 'object'
         ? (candidate.__kind || candidate.__type)
         : undefined;
@@ -4471,7 +4575,7 @@ async function createCapturedValueEntryAsync(params) {
     if (!candidateSerialized || candidateSerialized === previewSerialized) {
         return undefined;
     }
-    const valueId = (0, crypto_1.randomUUID)();
+    const valueId = contentAddressedValueId(params.target, candidateSerialized, params.capture);
     const projectedKind = candidate && typeof candidate === 'object'
         ? (candidate.__kind || candidate.__type)
         : undefined;
@@ -4492,13 +4596,20 @@ async function createCapturedValueEntryAsync(params) {
         entry,
     };
 }
+function appendCapturedValueDefinition(sink, entry, captureScope) {
+    if (!entry)
+        return;
+    const emitted = captureScope?.emittedValueDefinitionIds;
+    if (emitted?.has(entry.id))
+        return;
+    emitted?.add(entry.id);
+    sink.push(entry);
+}
 function maybeCaptureRequestValue(params, sink) {
     const result = createCapturedValueEntry(params);
     if (!result)
         return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 async function maybeCaptureRequestValueAsync(params, sink, captureScope) {
@@ -4512,9 +4623,7 @@ async function maybeCaptureRequestValueAsync(params, sink, captureScope) {
     }
     if (!result)
         return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 function maybeCaptureTraceValue(params) {
@@ -4533,9 +4642,7 @@ function maybeCaptureDbValue(params, sink) {
     const result = createCapturedValueEntry(params);
     if (!result)
         return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 async function maybeCaptureDbValueAsync(params, sink, captureScope) {
@@ -4549,9 +4656,7 @@ async function maybeCaptureDbValueAsync(params, sink, captureScope) {
     }
     if (!result)
         return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 function pushUniqueCaptureCandidate(candidates, value) {
@@ -4591,7 +4696,7 @@ async function maybeCaptureDbValueFromCandidatesAsync(params, sink, captureScope
         if (!result)
             continue;
         if (result.entry) {
-            sink.push(result.entry);
+            appendCapturedValueDefinition(sink, result.entry, captureScope);
             return result.captureRef;
         }
         if (!skippedRef) {
@@ -4725,21 +4830,25 @@ function reproMiddleware(cfg) {
             res.on('close', endTrackedClientRequest);
             return next(); // only capture tagged requests
         }
-        const captureCfg = backendLiveChild
-            ? {
+        let captureCfg = cfg;
+        if (backendLiveChild) {
+            captureCfg = {
                 ...cfg,
                 actorId: backendLiveChild.actorId,
                 actorType: backendLiveChild.actorType,
                 actorLabels: backendLiveChild.actorLabels,
-            }
-            : taggedActorIdentity
-                ? {
-                    ...cfg,
-                    actorId: taggedActorIdentity.actorId,
-                    actorType: taggedActorIdentity.actorType,
-                    actorLabels: taggedActorIdentity.actorLabels,
-                }
-                : cfg;
+            };
+            shareRuntimePrivacyState(cfg, captureCfg);
+        }
+        else if (taggedActorIdentity) {
+            captureCfg = {
+                ...cfg,
+                actorId: taggedActorIdentity.actorId,
+                actorType: taggedActorIdentity.actorType,
+                actorLabels: taggedActorIdentity.actorLabels,
+            };
+            shareRuntimePrivacyState(cfg, captureCfg);
+        }
         if (taggedActorIdentity) {
             post(captureCfg, sid, {
                 entries: [{
@@ -4987,6 +5096,7 @@ function reproMiddleware(cfg) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
                 const paramsValueCapture = await maybeCaptureRequestValueAsync({
@@ -5000,6 +5110,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const queryValueCapture = await maybeCaptureRequestValueAsync({
@@ -5013,6 +5124,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const headersValueCapture = await maybeCaptureRequestValueAsync({
@@ -5026,6 +5138,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const respBodyValueCapture = capturedBody === undefined
@@ -5041,6 +5154,7 @@ function reproMiddleware(cfg) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
                 const responseDurationMs = finishedAt !== null && Number.isFinite(finishedAt)
@@ -5208,17 +5322,17 @@ function reproMiddleware(cfg) {
                                 evt.__reproPending = {
                                     ...(ev.args !== undefined
                                         ? {
-                                            argsRaw: normalizeRawTraceArgs(ev.args),
+                                            argsRaw: snapshotTraceArgsAtObservation(ev.args, captureScope),
                                         }
                                         : {}),
                                     ...(ev.returnValue !== undefined
                                         ? {
-                                            returnValueRaw: ev.returnValue,
+                                            returnValueRaw: snapshotTraceValueAtObservation(ev.returnValue, captureScope, '$', 'trace.returnValue'),
                                         }
                                         : {}),
                                     ...(hasErrorPayload
                                         ? {
-                                            errorRaw: ev.error,
+                                            errorRaw: snapshotTraceValueAtObservation(ev.error, captureScope, '$', 'trace.error'),
                                         }
                                         : {}),
                                 };
@@ -5250,6 +5364,7 @@ function reproMiddleware(cfg) {
                                 masking,
                                 resolvePrivacy,
                                 captureScope,
+                                valueNamespace: sid,
                             });
                             const baseEvents = balanceTraceEvents(materializedEvents.slice());
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
@@ -5273,9 +5388,10 @@ function reproMiddleware(cfg) {
                         // on the wire so a large trace queue cannot starve completion.
                         emitRequestCaptureManifest(traceBatches.length);
                         try {
+                            const emittedValueIds = new Set();
                             for (let i = 0; i < traceBatches.length; i++) {
                                 const batch = traceBatches[i];
-                                const traceValues = collectBatchTraceValueEntries(batch, i);
+                                const traceValues = collectBatchTraceValueEntries(batch, i, emittedValueIds);
                                 post(captureCfg, sid, {
                                     entries: [{
                                             actionId: aid,
@@ -5846,12 +5962,6 @@ function dehydrateComplexValue(value) {
         }
     }
     catch { }
-    const ctor = value?.constructor?.name;
-    if (ctor && ctor !== 'Object') {
-        const plain = safeJson(value);
-        if (plain !== undefined)
-            return plain;
-    }
     return value;
 }
 function emitDbQuery(cfg, sid, aid, payload) {
@@ -5922,6 +6032,7 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
         masking: null,
         privacy,
         db: dbContext,
+        valueNamespace: sid,
     };
     const dbValues = [];
     const pkValueCapture = pkMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
@@ -5929,37 +6040,37 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
         rawValue: payload.pk,
         previewValue: pkPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const beforeValueCapture = beforeMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.before',
         rawValue: payload.before,
         previewValue: beforePreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const afterValueCapture = afterMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.after',
         rawValue: payload.after,
         previewValue: afterPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const queryValueCapture = queryMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.query',
         rawValue: querySource,
         previewValue: queryPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
         rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const errorValueCapture = errorMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.error',
         rawValue: payload.error,
         previewValue: errorPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const dbEntry = attachSpanContext({
         type: payload.type ?? 'mongo',
         collection: payload.collection,
@@ -6501,6 +6612,7 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
         trace: candidate,
         masking,
         privacy,
+        valueNamespace: getCtx().sid,
     };
     const traceValueMetadata = {
         fn: evt.fn,
@@ -6569,6 +6681,7 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
 function buildPendingKafkaTraceEvent(raw) {
     if (!raw || (raw.type !== 'enter' && raw.type !== 'exit'))
         return null;
+    raw = snapshotRawTraceEventAtObservation(raw, getCtx().captureScope);
     const sourceFileForLibrary = typeof raw.sourceFile === 'string' && raw.sourceFile
         ? String(raw.sourceFile)
         : null;
@@ -6638,6 +6751,7 @@ async function recordKafkaTraceEventAsync(raw, sink, cfg, maskReq) {
         maskReq,
         masking,
         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+        valueNamespace: getCtx().sid,
     });
     sink.push(...materializedEvents);
 }
@@ -6649,10 +6763,11 @@ function buildKafkaTraceEntries(actionId, requestRid, events) {
         ? reorderTraceEvents(baseEvents)
         : sortTraceEventsChronologically(baseEvents);
     const batches = chunkTraceEventsForTransport(orderedEvents, requestRid, actionId);
+    const emittedValueIds = new Set();
     return batches.map((batch, index) => ({
         actionId: actionId ?? null,
         trace: batch,
-        traceValues: collectBatchTraceValueEntries(batch, index),
+        traceValues: collectBatchTraceValueEntries(batch, index, emittedValueIds),
         traceBatch: {
             rid: requestRid,
             index,
@@ -6686,6 +6801,7 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                         masking,
                         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
                         captureScope,
+                        valueNamespace: sid,
                     });
                     entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
                 }
@@ -6999,7 +7115,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
                     unsubscribe = __TRACER__.tracer.on((event) => {
                         if (!event || event.traceId !== traceId)
                             return;
-                        rawTraceEvents.push(event);
+                        rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                     });
                 }
                 catch { }
@@ -7113,7 +7229,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                     unsubscribe = __TRACER__.tracer.on((event) => {
                         if (!event || event.traceId !== traceId)
                             return;
-                        rawTraceEvents.push(event);
+                        rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                     });
                 }
                 catch { }
@@ -7831,7 +7947,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                 unsubscribe = __TRACER__.tracer.on((event) => {
                     if (!event || event.traceId !== traceId)
                         return;
-                    rawTraceEvents.push(event);
+                    rawTraceEvents.push(snapshotRawTraceEventAtObservation(event, captureScope));
                 });
             }
             catch { }
@@ -10090,5 +10206,6 @@ exports.__reproTestHooks = {
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,
     sanitizeMaterializedTraceValueForTest: sanitizeMaterializedTraceValue,
+    projectSemanticInfrastructureValueForTest: semantic_serialization_1.projectSemanticInfrastructureValue,
     getEventTraceValueEntriesForTest: getEventTraceValueEntries,
 };

package/dist/semantic-serialization.d.ts

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