@reproapp/node-sdk 0.0.46 → 0.0.48

package/test/content-addressed-mongodb.testcontainers.test.js

@@ -0,0 +1,348 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '100';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = '2048';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const mongoose = require('mongoose');
+const { GenericContainer, Wait } = require('testcontainers');
+
+const {
+    initReproTracing,
+    reproMiddleware,
+    reproMongoosePlugin,
+    __reproTestHooks,
+} = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const byteLength = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
+
+class Logger {
+    constructor(context) {
+        this.context = context;
+        this.buffers = Array.from({ length: 200 }, () => 'mongo-test-logger-buffer');
+    }
+
+    log() {}
+}
+
+class ConfigService {
+    constructor() {
+        this.cache = {
+            DATABASE_URL: 'mongodb://captured-config-secret@database/repro',
+        };
+        this.internalConfig = Array.from({ length: 1000 }, (_, index) => ({
+            index,
+            credential: `mongo-config-credential-${index}`,
+        }));
+    }
+
+    get(key) {
+        return this.cache[key];
+    }
+}
+
+class SubjectRepository {
+    constructor(model, configService) {
+        this.model = model;
+        this.configService = configService;
+        this.logger = new Logger('SubjectRepository');
+        this.collectionName = 'subjects';
+    }
+}
+
+async function loadSubjectRepeatedly(repository, query) {
+    const docs = [];
+    for (let index = 0; index < 6; index += 1) {
+        docs.push(await repository.model.findOne(query).lean().exec());
+    }
+
+    let duplicateCode = null;
+    try {
+        await repository.model.create({
+            ...docs[0],
+            _id: undefined,
+        });
+    } catch (error) {
+        duplicateCode = error?.code ?? null;
+    }
+
+    return {
+        repositoryIdentityPreserved: repository instanceof SubjectRepository,
+        duplicateCode,
+        docs,
+    };
+}
+
+function makeSubject() {
+    return {
+        subjectNumber: 'SUBJECT-CONTENT-1001',
+        status: 'screened',
+        visits: Array.from({ length: 80 }, (_, visitIndex) => ({
+            visitNumber: `VISIT-${String(visitIndex).padStart(3, '0')}`,
+            assessments: Array.from({ length: 5 }, (_, assessmentIndex) => ({
+                code: `ASSESSMENT-${visitIndex}-${assessmentIndex}`,
+                result: visitIndex * 10 + assessmentIndex,
+                referenceRange: { min: 0, max: 1000, unit: 'mg' },
+                flags: assessmentIndex === 4 ? ['review'] : [],
+            })),
+        })),
+        metadata: {
+            source: 'clinical-import',
+            audit: {
+                importedBy: 'SYSTEM',
+                importBatch: 'BATCH-CONTENT-1',
+            },
+        },
+    };
+}
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/subjects/repeated-read';
+    req.originalUrl = req.url;
+    req.headers = {
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = {};
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.setHeader = () => {};
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+    return { req, res };
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function dbChanges(events) {
+    return events
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => event.payload?.db || []);
+}
+
+function manifests(events) {
+    return events
+        .filter((event) => event.event_type === 'request_capture_manifest')
+        .map((event) => event.payload?.requestCaptureManifest ?? event.payload)
+        .filter(Boolean);
+}
+
+async function startMongo() {
+    if (process.env.REPRO_MONGO_TEST_URI) {
+        return { uri: process.env.REPRO_MONGO_TEST_URI, stop: async () => {} };
+    }
+    const container = await new GenericContainer('mongo:7')
+        .withExposedPorts(27017)
+        .withTmpFs({ '/data/db': 'rw,noexec,nosuid,size=1g' })
+        .withCommand(['mongod', '--bind_ip_all', '--setParameter', 'diagnosticDataCollectionEnabled=false'])
+        .withWaitStrategy(Wait.forListeningPorts())
+        .start();
+    return {
+        uri: `mongodb://${container.getHost()}:${container.getMappedPort(27017)}/repro_content_addressed`,
+        stop: () => container.stop(),
+    };
+}
+
+async function main() {
+    const posts = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        posts.push(JSON.parse(String(init.body || '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    let mongo;
+    let connection;
+    try {
+        mongo = await startMongo();
+        connection = await mongoose.createConnection(mongo.uri).asPromise();
+
+        const config = {
+            tenantId: 'TENANT_content_addressed_mongo',
+            appId: 'APP_content_addressed_mongo',
+            appSecret: 'content-addressed-mongo-secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const assessmentSchema = new mongoose.Schema({
+            code: String,
+            result: Number,
+            referenceRange: { min: Number, max: Number, unit: String },
+            flags: [String],
+        }, { _id: false });
+        const visitSchema = new mongoose.Schema({
+            visitNumber: String,
+            assessments: [assessmentSchema],
+        }, { _id: false });
+        const subjectSchema = new mongoose.Schema({
+            subjectNumber: { type: String, unique: true },
+            status: String,
+            visits: [visitSchema],
+            metadata: mongoose.Schema.Types.Mixed,
+        });
+        reproMongoosePlugin(config)(subjectSchema);
+        const Subject = connection.model('ContentSubject', subjectSchema, 'content_subjects');
+        await Subject.init();
+        await Subject.create(makeSubject());
+
+        initReproTracing({ instrument: false, fullValueCapture: true, logFunctionCalls: false });
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const middleware = reproMiddleware(config);
+        const { req, res } = makeReqRes('S_content_addressed_mongo', 'A_content_addressed_mongo');
+        const repository = new SubjectRepository(Subject, new ConfigService());
+        let operationResult;
+
+        await new Promise((resolve, reject) => {
+            middleware(req, res, async (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                try {
+                    operationResult = await global.__repro_call(
+                        loadSubjectRepeatedly,
+                        null,
+                        [repository, { subjectNumber: 'SUBJECT-CONTENT-1001' }],
+                        '/app/src/subjects.repository.ts',
+                        120,
+                        'loadSubjectRepeatedly',
+                        false,
+                    );
+                    res.end();
+                    resolve();
+                } catch (operationError) {
+                    reject(operationError);
+                }
+            });
+        });
+
+        assert.equal(operationResult.repositoryIdentityPreserved, true);
+        assert.equal(operationResult.duplicateCode, 11000);
+        assert.equal(operationResult.docs.length, 6);
+        assert.equal(operationResult.docs[0].visits.length, 80);
+        assert.equal(operationResult.docs[5].visits[79].assessments[4].code, 'ASSESSMENT-79-4');
+
+        const deadline = Date.now() + 8000;
+        while (Date.now() < deadline) {
+            const events = flattenEvents(posts);
+            if (dbChanges(events).length >= 7 && manifests(events).length === 1 &&
+                events.some((event) => event.event_type === 'trace_batch')) {
+                break;
+            }
+            await sleep(25);
+        }
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const events = flattenEvents(posts);
+        const changes = dbChanges(events);
+        const manifest = manifests(events)[0];
+        assert(manifest, 'expected request capture manifest');
+        assert.equal(manifest.expected.dbChange, changes.length);
+
+        const readChanges = changes.filter((change) =>
+            change.collection === 'content_subjects' &&
+            change.op === 'findOne' &&
+            change.resultMetaValueCapture?.status === 'stored'
+        );
+        assert(readChanges.length >= 6, JSON.stringify(changes));
+        const resultValueIds = new Set(
+            readChanges.map((change) => change.resultMetaValueCapture.valueId),
+        );
+        assert.equal(resultValueIds.size, 1, 'identical query results must share one content ID');
+
+        const dbValueDefinitions = events
+            .filter((event) => event.event_type === 'db_change')
+            .flatMap((event) => event.payload?.dbValues || []);
+        const resultDefinitions = dbValueDefinitions.filter((entry) =>
+            resultValueIds.has(entry.id) && entry.target === 'db.resultMeta'
+        );
+        assert.equal(resultDefinitions.length, 1, 'repeated DB result must be transported once');
+        const fullResult = resultDefinitions[0].value;
+        assert.equal(fullResult.subjectNumber, 'SUBJECT-CONTENT-1001');
+        assert.equal(fullResult.visits.length, 80);
+        assert.equal(fullResult.visits[79].assessments[4].code, 'ASSESSMENT-79-4');
+        const legacyRepeatedResultBytes = readChanges.length * byteLength(fullResult);
+        const optimizedResultBytes = byteLength(fullResult) + readChanges.reduce(
+            (total, change) => total + byteLength(change.resultMetaValueCapture),
+            0,
+        );
+        const resultReduction = 1 - optimizedResultBytes / legacyRepeatedResultBytes;
+        assert(
+            resultReduction > 0.75,
+            `repeated DB result storage reduced only ${(resultReduction * 100).toFixed(1)}%`,
+        );
+
+        const failedWrite = changes.find((change) =>
+            change.collection === 'content_subjects' && change.error?.code === 11000
+        );
+        assert(failedWrite, 'duplicate-key failure must remain captured');
+
+        const traceBatches = events.filter((event) => event.event_type === 'trace_batch');
+        const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+        const enter = traceEvents.find((event) =>
+            event.fn === 'loadSubjectRepeatedly' && event.type === 'enter'
+        );
+        assert(enter, JSON.stringify(traceEvents));
+        const traceDefinitions = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+        const argsDefinition = traceDefinitions.find((entry) =>
+            entry.id === enter.argsValueCapture?.valueId
+        );
+        assert(argsDefinition, JSON.stringify(traceDefinitions));
+        assert.deepEqual(argsDefinition.value[0].configService, {
+            __kind: 'repro-semantic',
+            category: 'configuration-service',
+            className: 'ConfigService',
+        });
+        assert.equal(argsDefinition.value[1].subjectNumber, 'SUBJECT-CONTENT-1001');
+
+        const capturedJson = JSON.stringify(posts);
+        assert(!capturedJson.includes('captured-config-secret'));
+        assert(!capturedJson.includes('mongo-config-credential-999'));
+        assert(!capturedJson.includes('mongo-test-logger-buffer'));
+
+        console.log('content-addressed MongoDB testcontainers coverage OK', JSON.stringify({
+            repeatedResultOccurrences: readChanges.length,
+            uniqueResultDefinitions: resultDefinitions.length,
+            legacyRepeatedResultBytes,
+            optimizedResultBytes,
+            resultReductionPercent: Number((resultReduction * 100).toFixed(2)),
+        }));
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest().catch(() => {});
+        await flushIngestQueue().catch(() => {});
+        global.fetch = originalFetch;
+        if (connection) await connection.close().catch(() => {});
+        if (mongo) await mongo.stop().catch(() => {});
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

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

@@ -0,0 +1,264 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = '2048';
+process.env.REPRO_TRACE_BATCH_MAX_SERIALIZED_BYTES = '65536';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const { initReproTracing, reproMiddleware, __reproTestHooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { normalizeRuntimePrivacyPolicy } = require('../dist/privacy');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/content-addressed-values';
+    req.originalUrl = req.url;
+    req.headers = {
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = {};
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 204;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.setHeader = () => {};
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+    return { req, res };
+}
+
+function makePayload(changed = false, internalSecret) {
+    const payload = {
+        eventType: 'clinical.shipment.observed',
+        shipmentNumber: changed ? 'SHIP-CONTENT-CHANGED' : 'SHIP-CONTENT-STABLE',
+        rows: Array.from({ length: 300 }, (_, index) => ({
+            index,
+            depot: `DEPOT-${String(index).padStart(4, '0')}`,
+            site: {
+                number: `SITE-${index % 20}`,
+                country: { code: 'US', region: 'FDA' },
+            },
+            status: index % 2 === 0 ? 'available' : 'released',
+        })),
+    };
+    if (internalSecret !== undefined) {
+        payload.internalSecret = internalSecret;
+    }
+    return payload;
+}
+
+function observePayload(payload) {
+    return payload.shipmentNumber;
+}
+
+async function runRequest(config, sessionId, repeatedPayload, changedPayload = makePayload(true)) {
+    const posts = [];
+    const previousFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        posts.push(JSON.parse(String(init.body || '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    const middleware = reproMiddleware(config);
+    const { req, res } = makeReqRes(sessionId, `A_${sessionId}`);
+    try {
+        await new Promise((resolve, reject) => {
+            middleware(req, res, async (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                try {
+                    for (let index = 0; index < 60; index += 1) {
+                        const result = global.__repro_call(
+                            observePayload,
+                            null,
+                            [repeatedPayload],
+                            '/app/shipments.service.ts',
+                            70,
+                            'observePayload',
+                            false,
+                        );
+                        assert.equal(result, repeatedPayload.shipmentNumber);
+                    }
+                    const changedResult = global.__repro_call(
+                        observePayload,
+                        null,
+                        [changedPayload],
+                        '/app/shipments.service.ts',
+                        75,
+                        'observePayload',
+                        false,
+                    );
+                    assert.equal(changedResult, changedPayload.shipmentNumber);
+                    res.end();
+                    resolve();
+                } catch (traceError) {
+                    reject(traceError);
+                }
+            });
+        });
+
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            const events = posts.flatMap((post) => post.events || []);
+            if (events.some((event) => event.event_type === 'backend_request') &&
+                events.some((event) => event.event_type === 'trace_batch')) {
+                break;
+            }
+            await sleep(20);
+        }
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+        return posts;
+    } finally {
+        global.fetch = previousFetch;
+    }
+}
+
+function inspectCapture(posts) {
+    const ingestEvents = posts.flatMap((post) => post.events || []);
+    const traceBatches = ingestEvents.filter((event) => event.event_type === 'trace_batch');
+    const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+    const observedEvents = traceEvents.filter((event) => event.fn === 'observePayload');
+    const definitions = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+    const refs = observedEvents
+        .map((event) => event.argsValueCapture?.valueId)
+        .filter((valueId) => typeof valueId === 'string');
+    return { ingestEvents, traceBatches, observedEvents, definitions, refs };
+}
+
+async function main() {
+    const config = {
+        tenantId: 'TENANT_content_addressed',
+        appId: 'APP_content_addressed',
+        appSecret: 'content-addressed-test-secret',
+        captureHeaders: false,
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+
+    initReproTracing({ instrument: false, fullValueCapture: true, logFunctionCalls: false });
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+
+    const repeatedPayload = makePayload(false);
+    const first = inspectCapture(await runRequest(config, 'S_content_addressed_one', repeatedPayload));
+
+    assert.equal(first.observedEvents.length, 122, 'each invocation must retain enter and exit evidence');
+    assert.equal(first.refs.length, 122, 'every large argument occurrence must retain a resolvable ref');
+    assert.equal(new Set(first.refs).size, 2, 'only stable and changed values should receive IDs');
+    assert.equal(first.definitions.length, 2, 'each distinct value must be defined once per request');
+    assert.equal(new Set(first.definitions.map((entry) => entry.id)).size, 2);
+
+    for (const ref of first.refs) {
+        assert(first.definitions.some((entry) => entry.id === ref), `unresolved captured value ref ${ref}`);
+    }
+    const stableDefinition = first.definitions.find((entry) =>
+        entry.value?.[0]?.shipmentNumber === 'SHIP-CONTENT-STABLE'
+    );
+    assert(stableDefinition, JSON.stringify(first.definitions));
+    assert.equal(stableDefinition.value[0].rows.length, 300);
+    assert.equal(stableDefinition.value[0].rows[299].depot, 'DEPOT-0299');
+
+    const serializedBytes = Buffer.byteLength(JSON.stringify(first.traceBatches));
+    assert(serializedBytes < 250000, `repeated values inflated trace transport to ${serializedBytes} bytes`);
+
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const second = inspectCapture(await runRequest(config, 'S_content_addressed_two', repeatedPayload));
+    assert.equal(second.definitions.length, 2);
+    assert.notEqual(
+        first.definitions[0].id,
+        second.definitions[0].id,
+        'content IDs must be session-scoped to prevent cross-session correlation',
+    );
+
+    const secretPolicy = normalizeRuntimePrivacyPolicy({
+        environment: 'dev',
+        groups: [
+            {
+                gid: 'content-addressed-secret-policy',
+                scope: 'FIELD',
+                selector: 'field:internalSecret',
+                statements: [
+                    {
+                        sid: 'drop-trace-argument-secret',
+                        when: {
+                            scope: 'FIELD',
+                            selector: 'field:internalSecret',
+                            target: 'trace.args[].internalSecret',
+                        },
+                        apply: { action: 'DROP' },
+                        meta: { priority: 1 },
+                    },
+                ],
+            },
+        ],
+    });
+    assert(secretPolicy);
+
+    const policyConfig = {
+        ...config,
+        appId: 'APP_content_addressed_policy',
+        privacy: { environment: 'dev' },
+    };
+    __reproTestHooks.setRuntimePrivacyPolicyForTest(policyConfig, secretPolicy);
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const policyCapture = inspectCapture(await runRequest(
+        policyConfig,
+        'S_content_addressed_policy',
+        makePayload(false, 'policy-secret-alpha'),
+        makePayload(false, 'policy-secret-beta'),
+    ));
+    assert.equal(policyCapture.refs.length, 122);
+    assert.equal(new Set(policyCapture.refs).size, 1);
+    assert.equal(policyCapture.definitions.length, 1);
+    const policySerialized = JSON.stringify(policyCapture.definitions);
+    assert(!policySerialized.includes('policy-secret-alpha'), policySerialized);
+    assert(!policySerialized.includes('policy-secret-beta'), policySerialized);
+    assert(policySerialized.includes('[dropped]'), policySerialized);
+
+    const rawConfig = {
+        ...config,
+        appId: 'APP_content_addressed_raw',
+        privacy: { environment: 'dev', captureRaw: true },
+    };
+    __reproTestHooks.setRuntimePrivacyPolicyForTest(rawConfig, secretPolicy);
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const rawCapture = inspectCapture(await runRequest(
+        rawConfig,
+        'S_content_addressed_raw',
+        makePayload(false, 'raw-secret-alpha'),
+        makePayload(false, 'raw-secret-beta'),
+    ));
+    assert.equal(new Set(rawCapture.refs).size, 2);
+    assert.equal(rawCapture.definitions.length, 2);
+    const rawSerialized = JSON.stringify(rawCapture.definitions);
+    assert(rawSerialized.includes('raw-secret-alpha'), rawSerialized);
+    assert(rawSerialized.includes('raw-secret-beta'), rawSerialized);
+
+    console.log('content-addressed trace value deduplication OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/fixtures/semantic-serialization-trace-controller.js

@@ -0,0 +1,85 @@
+class Logger {
+    constructor(context) {
+        this.context = context;
+        this.internalBuffer = Array.from({ length: 200 }, () => 'logger-runtime-state');
+    }
+
+    log() {}
+}
+
+class ConfigService {
+    constructor() {
+        this.cache = {
+            DATABASE_URL: 'mongodb://runtime-user:runtime-password@database/repro',
+            SENDGRID_API_KEY: 'sendgrid-runtime-secret',
+        };
+        this.internalConfig = {
+            modules: Array.from({ length: 800 }, (_, index) => ({
+                index,
+                secret: `config-secret-${index}`,
+                nested: { host: `database-${index}.internal`, port: 27017 },
+            })),
+        };
+    }
+
+    get(key) {
+        return this.cache[key];
+    }
+}
+
+class ApiConfigService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+}
+
+class ShipmentGenerator {
+    constructor(configService) {
+        this.apiConfigService = new ApiConfigService(configService);
+        this.logger = new Logger('ShipmentGenerator');
+        this.triggerAction = 'ShipmentCreated';
+    }
+}
+
+class ShipmentDto {
+    constructor() {
+        this.shipmentNumber = 'SHIP-TRACE-1001';
+        this.site = {
+            number: 'SITE-0042',
+            address: {
+                country: {
+                    code: 'US',
+                    regulatory: { region: 'FDA', enabled: true },
+                },
+            },
+        };
+        this.kits = Array.from({ length: 160 }, (_, index) => ({
+            kitNumber: `KIT-${String(index).padStart(4, '0')}`,
+            status: index % 2 === 0 ? 'available' : 'released',
+            temperature: { minC: 2, maxC: 8 },
+        }));
+    }
+}
+
+function recordShipment(generator, shipment) {
+    return {
+        accepted: true,
+        originalGeneratorObserved: generator instanceof ShipmentGenerator,
+        originalShipmentObserved: shipment instanceof ShipmentDto,
+        runtimeConfigStillReadable:
+            generator.apiConfigService.configService.cache.DATABASE_URL.startsWith('mongodb://'),
+        shipmentNumber: shipment.shipmentNumber,
+        lastKit: shipment.kits[shipment.kits.length - 1].kitNumber,
+    };
+}
+
+async function handleSemanticTrace(_req, res) {
+    const configService = new ConfigService();
+    const generator = new ShipmentGenerator(configService);
+    const shipment = new ShipmentDto();
+    res.json(recordShipment(generator, shipment));
+}
+
+module.exports = {
+    handleSemanticTrace,
+};