@reproapp/node-sdk 0.0.47 → 0.0.48

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,7 @@ type RequestCaptureScopeState = {
     privacyMode: 'policy' | 'fallback' | 'raw';
     privacyPolicyFingerprint?: string;
     privacyStatementCount: number;
+    emittedValueDefinitionIds: Set<string>;
 };
 type BackendLiveTimingConfig = {
     sessionMaxDurationMs: number;
@@ -334,7 +338,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 +495,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,7 @@ function createRequestCaptureScope(requestRid, transport, cfg) {
         privacyMode,
         privacyPolicyFingerprint: privacy?.fingerprint,
         privacyStatementCount: privacy?.statements.length ?? 0,
+        emittedValueDefinitionIds: new Set(),
     };
 }
 function recordRequestCaptureFailure(scope, stage, target, reason) {
@@ -2275,7 +2277,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 +2609,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' };
     }
@@ -2824,6 +2834,7 @@ async function materializePendingTraceEvents(events, params) {
             trace: candidate,
             masking: params.masking,
             privacy: activePrivacy,
+            valueNamespace: params.valueNamespace,
         };
         const traceValueMetadata = {
             fn: evt.fn,
@@ -2946,6 +2957,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 +2967,7 @@ async function materializePendingTraceEventsAsync(events, params) {
             masking: params.masking,
             privacy,
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
+            valueNamespace: params.valueNamespace,
         });
     }
     catch (err) {
@@ -2981,6 +2994,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 +3996,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 +4184,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 +4336,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 +4363,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 +4400,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 +4435,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 +4472,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 +4519,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 +4540,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 +4567,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 +4586,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 +4600,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 +4640,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) {
@@ -4987,6 +5036,7 @@ function reproMiddleware(cfg) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
                 const paramsValueCapture = await maybeCaptureRequestValueAsync({
@@ -5000,6 +5050,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const queryValueCapture = await maybeCaptureRequestValueAsync({
@@ -5013,6 +5064,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const headersValueCapture = await maybeCaptureRequestValueAsync({
@@ -5026,6 +5078,7 @@ function reproMiddleware(cfg) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
                 }, requestValueEntries, captureScope);
                 const respBodyValueCapture = capturedBody === undefined
@@ -5041,6 +5094,7 @@ function reproMiddleware(cfg) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
                     }, requestValueEntries, captureScope);
                 const responseDurationMs = finishedAt !== null && Number.isFinite(finishedAt)
@@ -5250,6 +5304,7 @@ function reproMiddleware(cfg) {
                                 masking,
                                 resolvePrivacy,
                                 captureScope,
+                                valueNamespace: sid,
                             });
                             const baseEvents = balanceTraceEvents(materializedEvents.slice());
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
@@ -5273,9 +5328,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 +5902,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 +5972,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 +5980,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 +6552,7 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
         trace: candidate,
         masking,
         privacy,
+        valueNamespace: getCtx().sid,
     };
     const traceValueMetadata = {
         fn: evt.fn,
@@ -6638,6 +6690,7 @@ async function recordKafkaTraceEventAsync(raw, sink, cfg, maskReq) {
         maskReq,
         masking,
         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+        valueNamespace: getCtx().sid,
     });
     sink.push(...materializedEvents);
 }
@@ -6649,10 +6702,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 +6740,7 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                         masking,
                         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
                         captureScope,
+                        valueNamespace: sid,
                     });
                     entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
                 }
@@ -10090,5 +10145,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;

package/dist/semantic-serialization.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSemanticInfrastructureValue = void 0;
+function constructorName(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        const constructor = prototype
+            ? Object.getOwnPropertyDescriptor(prototype, 'constructor')?.value
+            : undefined;
+        const name = constructor?.name;
+        return typeof name === 'string' ? name : '';
+    }
+    catch {
+        return '';
+    }
+}
+function ownDataDescriptors(value) {
+    const out = {};
+    let descriptors;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(value);
+    }
+    catch {
+        return out;
+    }
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            out[key] = descriptor;
+        }
+    }
+    return out;
+}
+function method(value, key) {
+    try {
+        let current = value;
+        while (current) {
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (descriptor) {
+                return Object.prototype.hasOwnProperty.call(descriptor, 'value') &&
+                    typeof descriptor.value === 'function';
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function primitiveStateValue(value) {
+    if (value === null)
+        return null;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value instanceof Date)
+        return value.toISOString();
+    return undefined;
+}
+function semanticValue(category, className, details = {}) {
+    return {
+        matched: true,
+        value: {
+            __kind: 'repro-semantic',
+            category,
+            ...(className ? { className } : {}),
+            ...details,
+        },
+    };
+}
+function projectConfigurationService(value, className) {
+    if (!/(^|Api|App|Runtime|Environment)ConfigService$/i.test(className))
+        return null;
+    if (!method(value, 'get') && !method(value, 'getOrThrow'))
+        return null;
+    return semanticValue('configuration-service', className);
+}
+function projectLogger(value, className) {
+    if (!/(Logger|LoggerService)$/i.test(className))
+        return null;
+    const descriptors = ownDataDescriptors(value);
+    const context = primitiveStateValue(descriptors.context?.value);
+    return semanticValue('logger', className, context !== undefined ? { context } : {});
+}
+function projectNestInfrastructure(value, className) {
+    if (!/(ModuleRef|ModulesContainer|InstanceWrapper|NestContainer|Injector|DiscoveryService|ExecutionContextHost|ArgumentsHost|HttpAdapterHost)$/i.test(className)) {
+        return null;
+    }
+    return semanticValue('nestjs-infrastructure', className);
+}
+function projectRedis(value, className) {
+    const looksLikeRedis = /Redis|Commander|Cluster/i.test(className) && (method(value, 'get') || method(value, 'set') || method(value, 'pipeline') || method(value, 'multi'));
+    if (!looksLikeRedis)
+        return null;
+    const descriptors = ownDataDescriptors(value);
+    const status = primitiveStateValue(descriptors.status?.value);
+    return semanticValue('redis-client', className, status !== undefined ? { status } : {});
+}
+function projectKafka(value, className) {
+    if (!/Kafka/i.test(className))
+        return null;
+    if (method(value, 'send') && method(value, 'connect') && method(value, 'disconnect')) {
+        return semanticValue('kafka-producer', className || 'KafkaProducer');
+    }
+    if (method(value, 'subscribe') && method(value, 'run') && method(value, 'connect')) {
+        return semanticValue('kafka-consumer', className || 'KafkaConsumer');
+    }
+    if (method(value, 'listTopics') && method(value, 'connect') && method(value, 'disconnect')) {
+        return semanticValue('kafka-admin', className || 'KafkaAdmin');
+    }
+    return null;
+}
+function projectAmqp(value, className) {
+    if (!/(Amqp|Channel|ChannelModel|ConfirmChannel)/i.test(className))
+        return null;
+    if (method(value, 'publish') && method(value, 'sendToQueue') && method(value, 'ack')) {
+        return semanticValue('amqp-channel', className || 'AmqpChannel');
+    }
+    if (method(value, 'createChannel') && method(value, 'close')) {
+        return semanticValue('amqp-connection', className || 'AmqpConnection');
+    }
+    return null;
+}
+function projectPostgres(value, className) {
+    if (/^(Pool|BoundPool)$/i.test(className) && method(value, 'query') && method(value, 'connect')) {
+        return semanticValue('postgres-pool', className);
+    }
+    if (/^(Client|PoolClient)$/i.test(className) && method(value, 'query')) {
+        return semanticValue('postgres-client', className);
+    }
+    return null;
+}
+function projectTypeOrm(value, className) {
+    if (/^DataSource$/i.test(className) && method(value, 'createQueryRunner')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^EntityManager$/i.test(className) && method(value, 'getRepository') && method(value, 'query')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^QueryRunner$/i.test(className) && method(value, 'query') && method(value, 'release')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^Repository$/i.test(className) && method(value, 'find') && method(value, 'save')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    return null;
+}
+/**
+ * Projects known runtime machinery into stable, non-recursive descriptions.
+ * Unknown application values deliberately return null and remain fully captured.
+ */
+function projectSemanticInfrastructureValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const className = constructorName(value);
+    if (!className || className === 'Object')
+        return null;
+    return (projectConfigurationService(value, className) ||
+        projectLogger(value, className) ||
+        projectNestInfrastructure(value, className) ||
+        projectRedis(value, className) ||
+        projectKafka(value, className) ||
+        projectAmqp(value, className) ||
+        projectPostgres(value, className) ||
+        projectTypeOrm(value, className));
+}
+exports.projectSemanticInfrastructureValue = projectSemanticInfrastructureValue;