@reproapp/node-sdk 0.0.58 → 0.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,9 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node test/semantic-serialization.test.js && node test/semantic-serialization-trace.test.js && node test/content-addressed-trace-values.test.js && node test/trace-observation-snapshots.test.js && node test/session-storage-budget.test.js && node test/trace-source-exclude.test.js && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/sdk-background-timeout-isolation.test.js && node test/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-high-priority-fairness.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-service-scope.test.js && node test/privacy-policy-index.test.js && node test/policy-capture-attestation.test.js && node test/object-id-shapes.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
-    "test:containers": "npm run build && node test/trace-worker-policy-reference.test.js && node test/trace-throughput.testcontainers.test.js && node test/twelve-element-capture.testcontainers.test.js && node test/background-continuous-traffic.testcontainers.test.js && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
+    "test": "npm run build && node test/optional-chain-semantics.test.js && node test/semantic-serialization.test.js && node test/semantic-serialization-trace.test.js && node test/content-addressed-trace-values.test.js && node test/trace-observation-snapshots.test.js && node test/session-storage-budget.test.js && node test/trace-source-exclude.test.js && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/sdk-background-timeout-isolation.test.js && node test/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-high-priority-fairness.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-service-scope.test.js && node test/privacy-policy-index.test.js && node test/policy-capture-attestation.test.js && node test/object-id-shapes.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
+    "test:containers": "npm run build && node test/trace-worker-policy-reference.test.js && node test/trace-throughput.testcontainers.test.js && node test/twelve-element-capture.testcontainers.test.js && node test/background-continuous-traffic.testcontainers.test.js && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js",
+    "test:optional-chains": "npm run build && node test/optional-chain-semantics.test.js && node test/optional-chain.testcontainers.test.js && node test/optional-chain-http.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",
@@ -45,6 +46,7 @@
     "@babel/core": "^7.28.4",
     "@babel/generator": "^7.28.3",
     "@babel/parser": "^7.28.4",
+    "@babel/plugin-transform-optional-chaining": "^7.29.7",
     "@babel/plugin-transform-typescript": "^7.28.0",
     "@babel/traverse": "^7.28.4",
     "@babel/types": "^7.28.4",

package/test/express-trace-http-args.test.js

@@ -8,6 +8,7 @@ const capturedBodies = [];
 
 global.fetch = async (url, init = {}) => {
     const target = String(url || '');
+    if (target.endsWith('/v1/sdk/runtime-services')) return { ok: true };
     if (!target.includes('/v1/ingest/events')) {
         throw new Error(`unexpected fetch target: ${target}`);
     }
@@ -56,6 +57,9 @@ async function main() {
         appSecret: 'secret',
         appName: 'express-trace-http-args',
         serviceName: 'express-trace-http-args',
+        // This fixture tests HTTP arguments, not hosted policy initialization.
+        privacy: { enabled: false },
+        apiBase: 'http://127.0.0.1:65535',
         ingestBase: 'http://127.0.0.1:65535',
         tracing: {
             disableFunctionTypes: ['constructor'],

package/test/fixtures/optional-chain-app.cjs

@@ -0,0 +1,52 @@
+const http = require('node:http');
+const assert = require('node:assert/strict');
+const { MongoClient } = require('mongodb');
+const { initRepro, __reproTestHooks } = require('../../dist');
+const { flushIngestQueue } = require('../../dist/ingest/client');
+
+async function main() {
+  const [mode, uri, collector] = process.argv.slice(2);
+  if (mode === 'traced') await initRepro({ tenantId: 'TENANT_test', appId: 'APP_test', appSecret: 'test-only',
+    apiBase: collector, ingestBase: collector, privacy: { captureRaw: true },
+    tracing: { include: [/optional-chain-business\.cjs$/], logFunctionCalls: false } });
+  const { processReturn } = require('./optional-chain-business.cjs');
+  const client = await new MongoClient(uri).connect();
+  const db = client.db('optional_chain');
+  const server = http.createServer(async (req, res) => {
+    try {
+      const value = await processReturn(db.collection('preferences'), db.collection('writes'), req.url.slice(1), mode);
+      res.end(JSON.stringify({ value }));
+    } catch (error) { res.statusCode = 500; res.end(JSON.stringify({ error: error.name })); }
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const responses = [];
+    for (const id of ['missing', 'empty', 'valid', 'invalid']) {
+      responses.push(await new Promise((resolve, reject) => {
+        http.get({ hostname: '127.0.0.1', port: server.address().port, path: `/${id}`,
+          headers: { 'x-bug-session-id': `S_optional_${mode}`, 'x-bug-action-id': `A_${id}` } }, res => {
+          const chunks = [];
+          res.on('data', chunk => chunks.push(chunk));
+          res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(Buffer.concat(chunks)) }));
+        }).on('error', reject);
+      }));
+    }
+    assert.deepEqual(responses, [
+      { status: 200, body: { value: null } }, { status: 200, body: { value: null } },
+      { status: 200, body: { value: 1 } }, { status: 500, body: { error: 'TypeError' } },
+    ]);
+    if (mode === 'traced') {
+      for (let i = 0; i < 20; i++) {
+        await new Promise(resolve => setTimeout(resolve, 25));
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+      }
+    }
+    assert.equal(await db.collection('writes').countDocuments({ mode }), 1, 'No duplicate/short-circuited writes');
+    console.log(`${mode}: HTTP responses and MongoDB side effects passed`);
+  } finally {
+    server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
+    await client.close();
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/fixtures/optional-chain-business.cjs

@@ -0,0 +1,6 @@
+exports.processReturn = async function processReturn(collection, writes, id, mode) {
+  const productReturnsModule = await collection.findOne({ _id: id });
+  const preference = productReturnsModule?.productReturnsPreferences.find(entry => entry.id === 1);
+  if (preference) await writes.insertOne({ id, mode, preference: preference.id });
+  return preference?.id ?? null;
+};

package/test/fixtures/optional-chain-esm.mjs

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import runtime from '../../tracer/runtime.js';
+
+runtime.setFunctionLogsEnabled(false);
+const events = [];
+const unsubscribe = runtime.trace.on(event => events.push(event));
+function selectPreferences(productReturnsModule) {
+  return productReturnsModule?.productReturnsPreferences.find(entry => entry.id === 1)?.id;
+}
+await runtime.trace.withTrace('optional-esm', async () => {
+  assert.equal(selectPreferences(null), undefined);
+  assert.equal(selectPreferences(undefined), undefined);
+  assert.equal(selectPreferences({ productReturnsPreferences: [{ id: 1 }] }), 1);
+  assert.throws(() => selectPreferences({}), TypeError);
+  let calls = 0;
+  const increment = () => ++calls;
+  const empty = null;
+  assert.equal(empty?.nested.method(increment()).value, undefined);
+  assert.equal(calls, 0);
+  const object = { value: 7, method() { return this; } };
+  assert.equal((object?.method)().value, 7);
+  assert.equal(object?.method?.().value, 7);
+});
+unsubscribe();
+assert.ok(events.some(event => event.type === 'enter' && event.fn === 'selectPreferences'));
+assert.ok(events.some(event => event.type === 'exit' && event.fn === 'selectPreferences' && event.returnValue === 1));
+console.log('native ESM optional chain and trace evidence passed');

package/test/optional-chain-http.testcontainers.test.js

@@ -0,0 +1,55 @@
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const path = require('node:path');
+const { promisify } = require('node:util');
+const run = promisify(require('node:child_process').execFile);
+const { GenericContainer, Wait } = require('testcontainers');
+const { MongoClient } = require('mongodb');
+
+async function main() {
+  let container, mongo, server;
+  const captured = [];
+  try {
+    container = await new GenericContainer('mongo:7').withExposedPorts(27017)
+      .withWaitStrategy(Wait.forListeningPorts()).start();
+    const uri = `mongodb://${container.getHost()}:${container.getMappedPort(27017)}`;
+    mongo = await new MongoClient(uri).connect();
+    await mongo.db('optional_chain').collection('preferences').insertMany([
+      { _id: 'empty', productReturnsPreferences: [] },
+      { _id: 'valid', productReturnsPreferences: [{ id: 1 }] }, { _id: 'invalid' },
+    ]);
+    server = http.createServer(async (req, res) => {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const body = JSON.parse(Buffer.concat(chunks).toString() || '{}');
+      captured.push(...(body.events || []));
+      res.writeHead(202, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ accepted: body.events?.length ?? 0 }));
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    const collector = `http://127.0.0.1:${server.address().port}`;
+    for (const mode of ['baseline', 'traced']) {
+      const result = await run(process.execPath, [path.join(__dirname, 'fixtures/optional-chain-app.cjs'), mode, uri, collector], {
+        timeout: 30000, env: { ...process.env, REPRO_INGEST_BASE: collector, REPRO_API_BASE: collector,
+          REPRO_API_BASE_URL: collector, REPRO_PRIVACY_API_BASE: collector, TRACE_IDLE_FLUSH_MS: '10',
+          TRACE_LINGER_AFTER_FINISH_MS: '0', REPRO_SDK_BACKGROUND_IDLE_DELAY_MS: '0', REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS: '0' },
+      });
+      console.log(result.stdout.trim());
+    }
+    const requests = captured.filter(event => event.event_type === 'backend_request');
+    assert.equal(requests.length, 4, 'All four requests must remain captured');
+    assert.ok(captured.some(event => event.event_type === 'db_change'), 'Database evidence must remain captured');
+    const traces = captured.filter(event => event.event_type === 'trace_batch').flatMap(event => event.payload.trace || []);
+    assert.ok(traces.some(event => event.fn === 'processReturn' && event.type === 'enter'), 'Arguments/call evidence still present');
+    assert.ok(traces.some(event => event.fn === 'processReturn' && event.type === 'exit' && event.returnValue === 1), 'Return-value evidence still present');
+    assert.ok(traces.some(event => event.fn === 'processReturn' && event.type === 'exit' && event.threw), 'Real application errors remain captured');
+    const manifests = captured.filter(event => event.event_type === 'request_capture_manifest');
+    assert.equal(manifests.length, 4);
+    assert.ok(manifests.every(event => !event.payload.requestCaptureManifest.captureFailures?.length));
+    console.log('HTTP -> traced optional chains -> MongoDB -> collector: outcomes, writes, traces and manifests verified');
+  } finally {
+    if (server) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+    await mongo?.close(); await container?.stop();
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/optional-chain-semantics.test.js

@@ -0,0 +1,145 @@
+const assert = require('node:assert/strict');
+const vm = require('node:vm');
+const babel = require('@babel/core');
+const ts = require('typescript');
+const Module = require('node:module');
+const path = require('node:path');
+const { installCJS } = require('../tracer/cjs-hook');
+const makeWrap = require('../tracer/wrap-plugin');
+const { trace, setFunctionLogsEnabled } = require('../tracer/runtime');
+setFunctionLogsEnabled(false);
+
+const cases = [
+  'root?.productReturnsPreferences.find(x => x.id === 1)',
+  'root?.productReturnsPreferences.find(x => x.id === 1).id',
+  'root?.productReturnsPreferences.find(x => x.id === 2)?.id',
+  'root?.nested.method(arg())',
+  'root?.nested.method?.(arg())',
+  'root?.missing.method(arg())',
+  'root?.missing?.method(arg())',
+  'root?.method(arg()).value',
+  'root?.method(arg())?.value',
+  'root?.method(arg()).next(arg()).value',
+  'root?.[key()]?.(arg())',
+  'root?.nested[key()](arg())',
+  'root?.nested[key()]?.(arg())',
+  'root?.getter(arg())',
+  'root?.getter?.(arg())',
+  'root?.absent?.(arg())',
+  'root?.notCallable?.(arg())',
+  '(root?.method)(arg())',
+  '(root?.method)?.(arg())',
+  '(root?.nested.method)(arg())',
+  '(root?.nested.method)?.(arg())',
+  '(root?.nested).method(arg())',
+  'root?.method(...spread)',
+  'root?.method(arg(), root?.nested.method(arg()))',
+  'root?.method(await asyncArg())',
+  'root?.nested.method(await asyncArg())?.value',
+  'delete root?.method(arg()).value',
+  'delete root?.nested.value',
+  'root?.method(arg()) ?? "fallback"',
+  'root?.method(arg()) && arg()',
+  'root?.method(arg()) ? arg() : "false"',
+  '(root?.method(arg()), arg())',
+  'root?.returnsNull().value',
+  'root?.returnsNull()?.value',
+  'root?.returnsNull().method(arg())',
+  'root?.returnsNull()?.method(arg())',
+  'fn?.(arg()).value',
+  'fn?.(arg())?.value',
+  'fn?.(arg()).next(arg()).value',
+  '(fn?.(arg())).value',
+  'root?.nested.method.call(root, arg())',
+  'root?.method.bind(root)(arg())',
+  'root?.throwing?.(arg())',
+  'root?.method(root?.getter(arg()))',
+  'root?.method(root?.absent?.(arg()))',
+  'root?.[await asyncKey()](await asyncArg())',
+  'root?.method(...(root?.productReturnsPreferences ?? []))',
+  'root?.method(arg()).next?.(arg()).value',
+  'root?.method?.(arg()).next?.(arg()).value',
+  'root?.nested.method?.(root?.method(arg()))',
+  'new (root?.Ctor)(arg())',
+  'eval?.("typeof effects")',
+  '(function(undefined) { return root?.absent?.(); })("shadowed")',
+  '(function(x = root?.nested.method(arg())) { return x; })()',
+  '(function*() { return root?.nested.method(yield "pause"); })().next()',
+  '(new Derived()).read(root)',
+];
+
+function source(expression) {
+  return `module.exports = async function run(kind) {
+    const effects = [];
+    function arg() { effects.push('arg'); return 7; }
+    async function asyncArg() { effects.push('await'); return 7; }
+    async function asyncKey() { effects.push('await-key'); return 'method'; }
+    function key() { effects.push('key'); return 'method'; }
+    const result = { value: 11, next(value) { effects.push('next:' + value); return this; } };
+    const object = {
+      value: 3, productReturnsPreferences: [{ id: 1 }], notCallable: 4,
+      method(value) { effects.push('this:' + this.value + ':' + value); return result; },
+      nested: { value: 5, method(value) { effects.push('nested:' + this.value + ':' + value); return result; } },
+      get getter() { effects.push('getter'); return this.method; },
+      get throwing() { effects.push('throwing'); throw new RangeError('expected'); },
+      Ctor: class { constructor(value) { this.value = value; } },
+      returnsNull() { effects.push('null'); return null; }
+    };
+    class Base { read(value) { effects.push('super'); return value; } }
+    class Derived extends Base {
+      #get(value) { effects.push('private'); return value; }
+      read(value) { return super.read?.(value)?.method(this.#get?.(7)); }
+    }
+    const root = kind === 'null' ? null : kind === 'undefined' ? undefined : object;
+    const fn = kind === 'null' ? null : kind === 'undefined' ? undefined : value => { effects.push('fn:' + value); return result; };
+    const spread = { *[Symbol.iterator]() { effects.push('spread'); yield 7; } };
+    try {
+      const value = ${expression};
+      return JSON.stringify({ value, effects });
+    } catch (error) { return JSON.stringify({ error: error.name, effects }); }
+  };`;
+}
+
+function load(code, filename) {
+  const module = { exports: {} };
+  vm.runInNewContext(code, { module, exports: module.exports,
+    __trace: global.__trace, __repro_call: global.__repro_call }, { filename });
+  return module.exports;
+}
+
+async function main() {
+  installCJS({ include: [/optional-chain-virtual-/] });
+  let count = 0;
+  for (const expression of cases) {
+    const filename = `/test/optional-chain-${count}.js`;
+    const code = source(expression);
+    const transformed = babel.transformSync(code, { filename, configFile: false, babelrc: false,
+      plugins: [makeWrap(filename)] }).code;
+    const original = load(code, filename);
+    const variants = [['babel', load(transformed, filename), original]];
+    for (const target of [ts.ScriptTarget.ES2019, ts.ScriptTarget.ES2022]) {
+      const typescript = code.replace('run(kind)', 'run(kind: string)').replace('const effects = []', 'const effects: string[] = []');
+      const compiled = ts.transpileModule(typescript, { compilerOptions: { target, module: ts.ModuleKind.CommonJS } }).outputText;
+      const moduleFilename = path.join(__dirname, `fixtures/optional-chain-virtual-${count}-${target}.cjs`);
+      const mod = new Module(moduleFilename, module);
+      mod.filename = moduleFilename;
+      mod.paths = module.paths;
+      mod._compile(compiled, moduleFilename);
+      assert.equal(mod.exports.__repro_instrumented, true, 'CJS hook must actually instrument, not silently fall back');
+      // Compare to the code handed to the hook, including the TS compiler's
+      // own downleveling semantics, not to a different compilation target.
+      variants.push([`CJS/TS-${target}`, mod.exports, load(compiled, moduleFilename)]);
+    }
+    for (const [variant, instrumented, baseline] of variants) {
+      for (const kind of ['null', 'undefined', 'present']) {
+        const expected = await baseline(kind);
+        assert.equal(await instrumented(kind), expected, `${expression} (${variant}, ${kind}, idle)`);
+        assert.equal(await trace.withTrace(`optional-${count}`, () => instrumented(kind)), expected,
+          `${expression} (${variant}, ${kind}, recording)`);
+        count += 2;
+      }
+    }
+  }
+  console.log(`optional chaining: ${count} native/instrumented semantic comparisons passed`);
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/optional-chain.testcontainers.test.js

@@ -0,0 +1,24 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { GenericContainer, Wait } = require('testcontainers');
+
+async function main() {
+  for (const image of ['node:18-bookworm-slim', 'node:20-alpine', 'node:22.22.0-bookworm-slim']) {
+    const container = await new GenericContainer(image)
+      .withBindMounts([{ source: path.resolve(__dirname, '..'), target: '/sdk', mode: 'ro' }])
+      .withWorkingDir('/sdk')
+      .withCommand(['node', '-e', 'console.log("ready"); setInterval(() => {}, 60000)'])
+      .withWaitStrategy(Wait.forLogMessage('ready')).start();
+    try {
+      for (const command of [
+        ['node', 'test/optional-chain-semantics.test.js'],
+        ['node', '--require', './tracer/runtime.js', '--experimental-loader', './tracer/esm-loader.mjs', 'test/fixtures/optional-chain-esm.mjs'],
+      ]) {
+        const result = await container.exec(command);
+        assert.equal(result.exitCode, 0, `${image}: ${result.output}`);
+        console.log(`${image}: ${result.output.trim()}`);
+      }
+    } finally { await container.stop(); }
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

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

@@ -10,6 +10,7 @@ const originalFetch = global.fetch;
 const capturedBodies = [];
 
 global.fetch = async (url, init = {}) => {
+    if (String(url).endsWith('/v1/sdk/runtime-services')) return { ok: true };
     assert.match(String(url), /\/v1\/ingest\/events$/);
     capturedBodies.push(JSON.parse(String(init.body || '{}')));
     return {
@@ -59,6 +60,9 @@ async function main() {
         appSecret: 'secret',
         appName: 'semantic-trace',
         serviceName: 'semantic-trace',
+        // Exercise the built-in fallback without depending on a hosted policy.
+        privacy: { enabled: false },
+        apiBase: 'http://127.0.0.1:65535',
         ingestBase: 'http://127.0.0.1:65535',
         tracing: {
             disableFunctionTypes: ['constructor'],

package/tracer/cjs-hook.js

@@ -126,7 +126,6 @@ function installCJS({ include, exclude, parserPlugins } = {}) {
                     mapOriginalPosition = sourceInfo.mapOriginalPosition;
                 }
                 if (shouldHandle(filename, metaFilename)) {
-                    try { process.stderr.write(`[trace-debug] compile: ${filename}\n`); } catch {}
                     // Transform the already-compiled JS (keeps Nest’s decorator metadata intact).
                     const res = babel.transformSync(code, {
                         filename,
@@ -161,7 +160,6 @@ function installCJS({ include, exclude, parserPlugins } = {}) {
             }
         } catch (err) {
             out = code; // never break the app if transform fails
-            try { process.stderr.write(`[trace-debug] compile error: ${filename} :: ${err?.message || err}\n`); } catch {}
         }
 
         const ret = origCompile.call(this, out, filename);

package/tracer/wrap-plugin.js

@@ -1,4 +1,5 @@
 // wrap-plugin.js
+const transformOptionalChaining = require('@babel/plugin-transform-optional-chaining').default;
 module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
     return ({ types: t }) => {
         const {
@@ -453,10 +454,13 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             if (n.__repro_call_wrapped) return;
             if (n.__repro_internal) return;
 
-            // Skip our helper, super(), import(), optional calls for now
+            // Preserve special call semantics and avoid instrumenting our helpers.
             if (t.isIdentifier(n.callee, { name: '__repro_call' })) return;
             if (t.isIdentifier(n.callee, { name: '__awaiter' })) return;
             if (t.isIdentifier(n.callee, { name: '__generator' })) return;
+            // Routing direct eval through a helper turns it into indirect eval
+            // and changes its lexical scope (including TS-downleveled chains).
+            if (t.isIdentifier(n.callee, { name: 'eval' })) return;
             if (t.isSuper(n.callee)) return;
             if (isSuperMemberCall(n.callee)) return;
             if (t.isImport(n.callee)) return;
@@ -558,127 +562,12 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             path.node.__repro_call_wrapped = true;
         }
 
-        function wrapOptionalCall(path, state) {
-            const { node: n } = path;
-            if (n.__repro_call_wrapped) return;
-            if (n.__repro_internal) return;
-
-            if (t.isIdentifier(n.callee, { name: '__repro_call' })) return;
-            if (t.isIdentifier(n.callee, { name: '__awaiter' })) return;
-            if (t.isIdentifier(n.callee, { name: '__generator' })) return;
-            if (t.isSuper(n.callee)) return;
-            if (isSuperMemberCall(n.callee)) return;
-            if (t.isImport(n.callee)) return;
-
-            const loc = n.loc?.start || null;
-            const mapped = loc && typeof mapOriginalPosition === 'function'
-                ? mapOriginalPosition(loc.line ?? null, loc.column ?? 0)
-                : null;
-
-            const file = mapped?.file || filenameForMeta || state.file.opts.filename || '';
-            const line = mapped?.line ?? loc?.line ?? 0;
-
-            const fileLit = t.stringLiteral(file ?? '');
-            const lineLit = t.numericLiteral(line ?? 0);
-
-            const unawaited = !isAwaitedCall(path);
-            const label = describeExpression(n.callee) || '';
-            const makeArgsArray = () => t.arrayExpression(n.arguments.map(arg => t.cloneNode(arg, true)));
-
-            const isOptMember = (t.isOptionalMemberExpression && t.isOptionalMemberExpression(n.callee)) || false;
-            if (t.isMemberExpression(n.callee) || isOptMember) {
-                const callee = n.callee;
-                const objOrig = callee.object;
-                const prop = callee.property;
-                const computed = callee.computed === true;
-
-                const needsObjGuard = Boolean(callee.optional);
-                const needsCalleeGuard = n.optional === true;
-
-                const objId = path.scope.generateUidIdentifierBasedOnNode(objOrig, 'obj');
-                const fnId = path.scope.generateUidIdentifier('fn');
-
-                const member = t.memberExpression(objId, prop, computed);
-                const fnInit = needsObjGuard
-                    ? t.conditionalExpression(
-                        t.binaryExpression('==', objId, t.nullLiteral()),
-                        t.identifier('undefined'),
-                        member
-                    )
-                    : member;
-
-                const tests = [];
-                if (needsObjGuard) tests.push(t.binaryExpression('==', objId, t.nullLiteral()));
-                if (needsCalleeGuard) tests.push(t.binaryExpression('==', fnId, t.nullLiteral()));
-
-                let guardTest = null;
-                if (tests.length === 1) guardTest = tests[0];
-                else if (tests.length === 2) guardTest = t.logicalExpression('||', tests[0], tests[1]);
-
-                const reproCall = t.callExpression(
-                    t.identifier('__repro_call'),
-                    [
-                        fnId,
-                        objId,
-                        makeArgsArray(),
-                        fileLit,
-                        lineLit,
-                        t.stringLiteral(label || ''),
-                        t.booleanLiteral(unawaited)
-                    ]
-                );
-
-                const guardedCall = guardTest
-                    ? t.conditionalExpression(guardTest, t.identifier('undefined'), reproCall)
-                    : reproCall;
-
-                const seq = t.sequenceExpression([
-                    t.assignmentExpression('=', objId, objOrig),
-                    t.assignmentExpression('=', fnId, fnInit),
-                    guardedCall
-                ]);
-
-                path.scope.push({ id: objId });
-                path.scope.push({ id: fnId });
-                path.replaceWith(seq);
-                path.node.__repro_call_wrapped = true;
-                return;
-            }
-
-            const fnOrig = n.callee;
-            const fnId = path.scope.generateUidIdentifier('fn');
-            const needsCalleeGuard = n.optional === true;
-            const guardTest = needsCalleeGuard ? t.binaryExpression('==', fnId, t.nullLiteral()) : null;
-
-            const reproCall = t.callExpression(
-                t.identifier('__repro_call'),
-                [
-                    fnId,
-                    t.nullLiteral(),
-                    makeArgsArray(),
-                    fileLit,
-                    lineLit,
-                    t.stringLiteral(label || ''),
-                    t.booleanLiteral(unawaited)
-                ]
-            );
-
-            const guardedCall = guardTest
-                ? t.conditionalExpression(guardTest, t.identifier('undefined'), reproCall)
-                : reproCall;
-
-            const seq = t.sequenceExpression([
-                t.assignmentExpression('=', fnId, fnOrig),
-                guardedCall
-            ]);
-
-            path.scope.push({ id: fnId });
-            path.replaceWith(seq);
-            path.node.__repro_call_wrapped = true;
-        }
 
         return {
             name: 'omnitrace-wrap-functions-and-calls',
+            // Lower complete chains before wrapping their calls; guarding only
+            // the immediate receiver loses short-circuiting across chain segments.
+            inherits: transformOptionalChaining,
             visitor: {
                 // function body enter/exit
                 FunctionDeclaration: wrap,
@@ -692,11 +581,6 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
                 CallExpression: {
                     exit(path, state) { wrapCall(path, state); }
                 },
-                OptionalCallExpression: {
-                    exit(path, state) { wrapOptionalCall(path, state); }
-                },
-                // (If you also want to wrap OptionalCallExpression in older Babel ASTs,
-                // add the same handler here)
             }
         };
     };