trickle-observe 0.2.2 → 0.2.3

package/dist/vite-plugin.js

@@ -3,8 +3,9 @@
  * Vite plugin for trickle observation.
  *
  * Integrates into Vite's (and Vitest's) transform pipeline to wrap
- * user functions with trickle observation — the same thing observe-register.ts
- * does for Node's Module._compile, but for Vite/Vitest.
+ * user functions with trickle observation AND trace variable assignments —
+ * the same thing observe-register.ts does for Node's Module._compile,
+ * but for Vite/Vitest.
  *
  * Usage in vitest.config.ts:
  *
@@ -23,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tricklePlugin = tricklePlugin;
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 function tricklePlugin(options = {}) {
     const include = options.include
         ?? (process.env.TRICKLE_OBSERVE_INCLUDE
@@ -37,6 +39,7 @@ function tricklePlugin(options = {}) {
         ?? 'http://localhost:4888';
     const debug = options.debug
         ?? (process.env.TRICKLE_DEBUG === '1' || process.env.TRICKLE_DEBUG === 'true');
+    const traceVars = options.traceVars ?? (process.env.TRICKLE_TRACE_VARS !== '0');
     function shouldTransform(id) {
         // Only JS/TS files
         const ext = path_1.default.extname(id).toLowerCase();
@@ -66,8 +69,18 @@ function tricklePlugin(options = {}) {
         transform(code, id) {
             if (!shouldTransform(id))
                 return null;
+            // Read the original source file to get accurate line numbers.
+            // Vite transforms the code before our plugin (enforce: 'post'),
+            // so line numbers from `code` don't match the original .ts file.
+            let originalSource = null;
+            try {
+                originalSource = fs_1.default.readFileSync(id, 'utf-8');
+            }
+            catch {
+                // If we can't read the original, we'll use transformed line numbers
+            }
             const moduleName = path_1.default.basename(id).replace(/\.[jt]sx?$/, '');
-            const transformed = transformEsmSource(code, id, moduleName, backendUrl, debug);
+            const transformed = transformEsmSource(code, id, moduleName, backendUrl, debug, traceVars, originalSource);
             if (transformed === code)
                 return null;
             if (debug) {
@@ -132,16 +145,310 @@ function findClosingBrace(source, openBrace) {
     return -1;
 }
 /**
- * Transform ESM source code to wrap function declarations with trickle observation.
+ * Find variable declarations in source and return insertions for tracing.
+ * Handles: const x = ...; let x = ...; var x = ...;
+ * Skips: destructuring, for-loop vars, require() calls, imports, type annotations.
+ */
+function findVarDeclarations(source) {
+    const varInsertions = [];
+    // Match: const/let/var <identifier> = <something>
+    const varRegex = /^([ \t]*)(export\s+)?(const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?::\s*[^=]+?)?\s*=[^=]/gm;
+    let vmatch;
+    while ((vmatch = varRegex.exec(source)) !== null) {
+        const varName = vmatch[4];
+        // Skip trickle internals
+        if (varName.startsWith('__trickle'))
+            continue;
+        // Skip TS compiled vars
+        if (varName === '_a' || varName === '_b' || varName === '_c')
+            continue;
+        // Check if this is a require() call or import — skip those
+        const restOfLine = source.slice(vmatch.index + vmatch[0].length - 1, vmatch.index + vmatch[0].length + 200);
+        if (/^\s*require\s*\(/.test(restOfLine))
+            continue;
+        // Skip function/class assignments (those are handled by function wrapping)
+        if (/^\s*(?:async\s+)?(?:function\s|\([^)]*\)\s*(?::\s*[^=]+?)?\s*=>|\w+\s*=>)/.test(restOfLine))
+            continue;
+        // Calculate line number
+        let lineNo = 1;
+        for (let i = 0; i < vmatch.index; i++) {
+            if (source[i] === '\n')
+                lineNo++;
+        }
+        // Find the end of this statement
+        const startPos = vmatch.index + vmatch[0].length - 1;
+        let pos = startPos;
+        let depth = 0;
+        let foundEnd = -1;
+        while (pos < source.length) {
+            const ch = source[pos];
+            if (ch === '(' || ch === '[' || ch === '{') {
+                depth++;
+            }
+            else if (ch === ')' || ch === ']' || ch === '}') {
+                depth--;
+                if (depth < 0)
+                    break;
+            }
+            else if (ch === ';' && depth === 0) {
+                foundEnd = pos;
+                break;
+            }
+            else if (ch === '\n' && depth === 0) {
+                const nextNonWs = source.slice(pos + 1).match(/^\s*(\S)/);
+                if (nextNonWs && !'.+=-|&?:,'.includes(nextNonWs[1])) {
+                    foundEnd = pos;
+                    break;
+                }
+            }
+            else if (ch === '"' || ch === "'" || ch === '`') {
+                const quote = ch;
+                pos++;
+                while (pos < source.length) {
+                    if (source[pos] === '\\') {
+                        pos++;
+                    }
+                    else if (source[pos] === quote)
+                        break;
+                    pos++;
+                }
+            }
+            else if (ch === '/' && pos + 1 < source.length && source[pos + 1] === '/') {
+                while (pos < source.length && source[pos] !== '\n')
+                    pos++;
+                continue;
+            }
+            else if (ch === '/' && pos + 1 < source.length && source[pos + 1] === '*') {
+                pos += 2;
+                while (pos < source.length - 1 && !(source[pos] === '*' && source[pos + 1] === '/'))
+                    pos++;
+                pos++;
+            }
+            pos++;
+        }
+        if (foundEnd === -1)
+            continue;
+        varInsertions.push({ lineEnd: foundEnd + 1, varName, lineNo });
+    }
+    return varInsertions;
+}
+/**
+ * Find destructured variable declarations: const { a, b } = ... and const [a, b] = ...
+ * Extracts the individual variable names from the destructuring pattern.
+ */
+function findDestructuredDeclarations(source) {
+    const results = [];
+    // Match: const/let/var { ... } = ... or const/let/var [ ... ] = ...
+    const destructRegex = /^[ \t]*(?:export\s+)?(?:const|let|var)\s+(\{[^}]*\}|\[[^\]]*\])\s*(?::\s*[^=]+?)?\s*=[^=]/gm;
+    let match;
+    while ((match = destructRegex.exec(source)) !== null) {
+        const pattern = match[1];
+        // Extract variable names from the destructuring pattern
+        const varNames = extractDestructuredNames(pattern);
+        if (varNames.length === 0)
+            continue;
+        // Skip if it's a require() call
+        const restOfLine = source.slice(match.index + match[0].length - 1, match.index + match[0].length + 200);
+        if (/^\s*require\s*\(/.test(restOfLine))
+            continue;
+        // Calculate line number
+        let lineNo = 1;
+        for (let i = 0; i < match.index; i++) {
+            if (source[i] === '\n')
+                lineNo++;
+        }
+        // Find the end of this statement (same logic as findVarDeclarations)
+        const startPos = match.index + match[0].length - 1;
+        let pos = startPos;
+        let depth = 0;
+        let foundEnd = -1;
+        while (pos < source.length) {
+            const ch = source[pos];
+            if (ch === '(' || ch === '[' || ch === '{') {
+                depth++;
+            }
+            else if (ch === ')' || ch === ']' || ch === '}') {
+                depth--;
+                if (depth < 0)
+                    break;
+            }
+            else if (ch === ';' && depth === 0) {
+                foundEnd = pos;
+                break;
+            }
+            else if (ch === '\n' && depth === 0) {
+                const nextNonWs = source.slice(pos + 1).match(/^\s*(\S)/);
+                if (nextNonWs && !'.+=-|&?:,'.includes(nextNonWs[1])) {
+                    foundEnd = pos;
+                    break;
+                }
+            }
+            else if (ch === '"' || ch === "'" || ch === '`') {
+                const quote = ch;
+                pos++;
+                while (pos < source.length) {
+                    if (source[pos] === '\\') {
+                        pos++;
+                    }
+                    else if (source[pos] === quote)
+                        break;
+                    pos++;
+                }
+            }
+            else if (ch === '/' && pos + 1 < source.length && source[pos + 1] === '/') {
+                while (pos < source.length && source[pos] !== '\n')
+                    pos++;
+                continue;
+            }
+            else if (ch === '/' && pos + 1 < source.length && source[pos + 1] === '*') {
+                pos += 2;
+                while (pos < source.length - 1 && !(source[pos] === '*' && source[pos + 1] === '/'))
+                    pos++;
+                pos++;
+            }
+            pos++;
+        }
+        if (foundEnd === -1)
+            continue;
+        results.push({ lineEnd: foundEnd + 1, varNames, lineNo });
+    }
+    return results;
+}
+/**
+ * Extract variable names from a destructuring pattern.
+ * Handles: { a, b, c: d } → ['a', 'b', 'd']  (renamed vars use the local name)
+ * Handles: [a, b, ...rest] → ['a', 'b', 'rest']
+ * Handles: { a: { b, c } } → ['b', 'c']  (nested destructuring)
+ */
+function extractDestructuredNames(pattern) {
+    const names = [];
+    // Remove outer braces/brackets
+    const inner = pattern.slice(1, -1).trim();
+    if (!inner)
+        return names;
+    // Split by commas at depth 0
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of inner) {
+        if (ch === '{' || ch === '[')
+            depth++;
+        else if (ch === '}' || ch === ']')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    for (let part of parts) {
+        // Remove type annotations: `a: Type` vs `a: b` (rename)
+        // Skip rest elements for now: ...rest → rest
+        if (part.startsWith('...')) {
+            const restName = part.slice(3).trim().split(/[\s:]/)[0];
+            if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(restName)) {
+                names.push(restName);
+            }
+            continue;
+        }
+        // Check for rename pattern: key: localName or key: { nested }
+        const colonIdx = part.indexOf(':');
+        if (colonIdx !== -1) {
+            const afterColon = part.slice(colonIdx + 1).trim();
+            // Nested destructuring: key: { a, b } or key: [a, b]
+            if (afterColon.startsWith('{') || afterColon.startsWith('[')) {
+                const nestedNames = extractDestructuredNames(afterColon);
+                names.push(...nestedNames);
+            }
+            else {
+                // Rename: key: localName — extract localName (skip if it has another colon for type annotation)
+                const localName = afterColon.split(/[\s=]/)[0].trim();
+                if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(localName)) {
+                    names.push(localName);
+                }
+            }
+        }
+        else {
+            // Simple: just the identifier (possibly with default: `a = defaultVal`)
+            const name = part.split(/[\s=]/)[0].trim();
+            if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
+                names.push(name);
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Transform ESM source code to wrap function declarations and trace variables.
  *
- * Prepends an import of the wrap helper, then inserts wrapper calls after
- * each function declaration body — same approach as observe-register's
- * transformCjsSource but using ESM imports.
+ * Prepends imports of the wrap/trace helpers, then inserts wrapper calls after
+ * each function declaration body and trace calls after variable declarations.
  */
-function transformEsmSource(source, filename, moduleName, backendUrl, debug) {
+/**
+ * Find the original line number for a simple variable declaration.
+ * Searches the original source lines for `const/let/var <varName>` near the expected position.
+ * Vite transforms typically remove lines (types, imports), so the original line is usually
+ * >= the transformed line. We search forward-biased (up to +80) but also a bit backward (-10).
+ */
+function findOriginalLine(origLines, varName, transformedLine) {
+    const pattern = new RegExp(`\\b(const|let|var)\\s+${escapeRegexStr(varName)}\\b`);
+    // Search: first try exact, then expand forward (more likely) and a bit backward
+    for (let delta = 0; delta <= 80; delta++) {
+        // Forward first (original line is usually after transformed line due to removed TS types)
+        const fwd = transformedLine - 1 + delta;
+        if (fwd >= 0 && fwd < origLines.length && pattern.test(origLines[fwd])) {
+            return fwd + 1;
+        }
+        // Also check backward (small range)
+        if (delta > 0 && delta <= 10) {
+            const bwd = transformedLine - 1 - delta;
+            if (bwd >= 0 && bwd < origLines.length && pattern.test(origLines[bwd])) {
+                return bwd + 1;
+            }
+        }
+    }
+    return -1;
+}
+/**
+ * Find the original line number for a destructured declaration.
+ * Searches for const/let/var { or [ patterns containing at least one of the variable names.
+ */
+function findOriginalLineDestructured(origLines, varNames, transformedLine) {
+    // Match names as actual bindings (not renamed property keys).
+    // In `{ data: customer }`, 'data' is a key (followed by ':'), 'customer' is the binding.
+    // In `{ data, error }`, 'data' is a binding (followed by ',' or '}').
+    // We check: name followed by comma, }, ], =, whitespace, or end — NOT followed by ':' (rename).
+    const namePatterns = varNames.map(n => new RegExp(`\\b${escapeRegexStr(n)}\\b(?!\\s*:)`));
+    for (let delta = 0; delta <= 80; delta++) {
+        const fwd = transformedLine - 1 + delta;
+        if (fwd >= 0 && fwd < origLines.length) {
+            const line = origLines[fwd];
+            if (/\b(const|let|var)\s+[\[{]/.test(line) && namePatterns.some(p => p.test(line))) {
+                return fwd + 1;
+            }
+        }
+        if (delta > 0 && delta <= 10) {
+            const bwd = transformedLine - 1 - delta;
+            if (bwd >= 0 && bwd < origLines.length) {
+                const line = origLines[bwd];
+                if (/\b(const|let|var)\s+[\[{]/.test(line) && namePatterns.some(p => p.test(line))) {
+                    return bwd + 1;
+                }
+            }
+        }
+    }
+    return -1;
+}
+function escapeRegexStr(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function transformEsmSource(source, filename, moduleName, backendUrl, debug, traceVars, originalSource) {
     // Match top-level and nested function declarations (including async, export)
     const funcRegex = /^[ \t]*(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/gm;
-    const insertions = [];
+    const funcInsertions = [];
     let match;
     while ((match = funcRegex.exec(source)) !== null) {
         const name = match[1];
@@ -164,7 +471,7 @@ function transformEsmSource(source, filename, moduleName, backendUrl, debug) {
         const closeBrace = findClosingBrace(source, openBrace);
         if (closeBrace === -1)
             continue;
-        insertions.push({ position: closeBrace + 1, name, paramNames });
+        funcInsertions.push({ position: closeBrace + 1, name, paramNames });
     }
     // Also match arrow functions assigned to const/let/var
     const arrowRegex = /^[ \t]*(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?::\s*[^=]+?)?\s*=>\s*\{/gm;
@@ -173,7 +480,6 @@ function transformEsmSource(source, filename, moduleName, backendUrl, debug) {
         const openBrace = source.indexOf('{', match.index + match[0].length - 1);
         if (openBrace === -1)
             continue;
-        // Extract param names from the arrow function
         const arrowStr = match[0];
         const arrowParamMatch = arrowStr.match(/=\s*(?:async\s+)?(?:\(([^)]*)\)|([a-zA-Z_$][a-zA-Z0-9_$]*))\s*(?::\s*[^=]+?)?\s*=>/);
         let paramNames = [];
@@ -191,14 +497,42 @@ function transformEsmSource(source, filename, moduleName, backendUrl, debug) {
         const closeBrace = findClosingBrace(source, openBrace);
         if (closeBrace === -1)
             continue;
-        insertions.push({ position: closeBrace + 1, name, paramNames });
+        funcInsertions.push({ position: closeBrace + 1, name, paramNames });
     }
-    if (insertions.length === 0)
+    // Find variable declarations for tracing
+    const varInsertions = traceVars ? findVarDeclarations(source) : [];
+    // Find destructured variable declarations for tracing
+    const destructInsertions = traceVars ? findDestructuredDeclarations(source) : [];
+    if (funcInsertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0)
         return source;
-    // Prepend ESM import of the wrap helper + configure transport
-    const prefix = [
-        `import { wrapFunction as __trickle_wrapFn } from 'trickle-observe';`,
-        `import { configure as __trickle_configure } from 'trickle-observe';`,
+    // Fix line numbers: Vite transforms (TypeScript stripping) may change line numbers.
+    // Map transformed line numbers to original source line numbers.
+    if (originalSource && originalSource !== source) {
+        const origLines = originalSource.split('\n');
+        // For each variable insertion, find the declaration in the original source
+        for (const vi of varInsertions) {
+            const origLine = findOriginalLine(origLines, vi.varName, vi.lineNo);
+            if (origLine !== -1)
+                vi.lineNo = origLine;
+        }
+        for (const di of destructInsertions) {
+            // Use the first variable name to locate the line
+            if (di.varNames.length > 0) {
+                const origLine = findOriginalLineDestructured(origLines, di.varNames, di.lineNo);
+                if (origLine !== -1)
+                    di.lineNo = origLine;
+            }
+        }
+    }
+    // Build prefix — ALL imports first (ESM requires imports before any statements)
+    const importLines = [
+        `import { wrapFunction as __trickle_wrapFn, configure as __trickle_configure } from 'trickle-observe';`,
+    ];
+    if (varInsertions.length > 0 || destructInsertions.length > 0) {
+        importLines.push(`import { mkdirSync as __trickle_mkdirSync, appendFileSync as __trickle_appendFileSync } from 'node:fs';`, `import { join as __trickle_join } from 'node:path';`);
+    }
+    const prefixLines = [
+        ...importLines,
         `__trickle_configure({ backendUrl: ${JSON.stringify(backendUrl)}, batchIntervalMs: 2000, debug: ${debug}, enabled: true, environment: 'node' });`,
         `function __trickle_wrap(fn, name, paramNames) {`,
         `  const opts = {`,
@@ -214,15 +548,41 @@ function transformEsmSource(source, filename, moduleName, backendUrl, debug) {
         `  if (paramNames && paramNames.length) opts.paramNames = paramNames;`,
         `  return __trickle_wrapFn(fn, opts);`,
         `}`,
-        '',
-    ].join('\n');
-    // Insert wrapper calls after each function body (reverse order)
-    let result = source;
-    for (let i = insertions.length - 1; i >= 0; i--) {
-        const { position, name, paramNames } = insertions[i];
+    ];
+    // Add variable tracing if needed — inlined to avoid import resolution issues in Vite SSR.
+    // Uses synchronous writes (appendFileSync) to guarantee data persists even if Vitest
+    // kills the worker abruptly without firing exit events.
+    if (varInsertions.length > 0 || destructInsertions.length > 0) {
+        prefixLines.push(`if (!globalThis.__trickle_var_tracer) {`, `  const _cache = new Set();`, `  let _varsFile = null;`, `  function _inferType(v, d) {`, `    if (d <= 0) return { kind: 'primitive', name: 'unknown' };`, `    if (v === null) return { kind: 'primitive', name: 'null' };`, `    if (v === undefined) return { kind: 'primitive', name: 'undefined' };`, `    const t = typeof v;`, `    if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint' || t === 'symbol') return { kind: 'primitive', name: t };`, `    if (t === 'function') return { kind: 'function' };`, `    if (Array.isArray(v)) { return v.length === 0 ? { kind: 'array', element: { kind: 'primitive', name: 'unknown' } } : { kind: 'array', element: _inferType(v[0], d-1) }; }`, `    if (t === 'object') {`, `      if (v instanceof Date) return { kind: 'object', properties: { __date: { kind: 'primitive', name: 'string' } } };`, `      if (v instanceof RegExp) return { kind: 'object', properties: { __regexp: { kind: 'primitive', name: 'string' } } };`, `      if (v instanceof Error) return { kind: 'object', properties: { __error: { kind: 'primitive', name: 'string' } } };`, `      if (v instanceof Promise) return { kind: 'promise', resolved: { kind: 'primitive', name: 'unknown' } };`, `      const props = {}; const keys = Object.keys(v).slice(0, 20);`, `      for (const k of keys) { try { props[k] = _inferType(v[k], d-1); } catch(e) { props[k] = { kind: 'primitive', name: 'unknown' }; } }`, `      return { kind: 'object', properties: props };`, `    }`, `    return { kind: 'primitive', name: 'unknown' };`, `  }`, `  function _sanitize(v, d) {`, `    if (d <= 0) return '[truncated]'; if (v === null || v === undefined) return v; const t = typeof v;`, `    if (t === 'string') return v.length > 100 ? v.substring(0, 100) + '...' : v;`, `    if (t === 'number' || t === 'boolean') return v; if (t === 'bigint') return String(v);`, `    if (t === 'function') return '[Function: ' + (v.name || 'anonymous') + ']';`, `    if (Array.isArray(v)) return v.slice(0, 3).map(i => _sanitize(i, d-1));`, `    if (t === 'object') { if (v instanceof Date) return v.toISOString(); if (v instanceof RegExp) return String(v); if (v instanceof Error) return { error: v.message }; if (v instanceof Promise) return '[Promise]';`, `      const r = {}; const keys = Object.keys(v).slice(0, 10); for (const k of keys) { try { r[k] = _sanitize(v[k], d-1); } catch(e) { r[k] = '[unreadable]'; } } return r; }`, `    return String(v);`, `  }`, `  globalThis.__trickle_var_tracer = function(v, n, l, mod, file) {`, `    try {`, `      if (!_varsFile) {`, `        const dir = process.env.TRICKLE_LOCAL_DIR || __trickle_join(process.cwd(), '.trickle');`, `        try { __trickle_mkdirSync(dir, { recursive: true }); } catch(e) {}`, `        _varsFile = __trickle_join(dir, 'variables.jsonl');`, `      }`, `      const type = _inferType(v, 3);`, `      const th = JSON.stringify(type).substring(0, 32);`, `      const ck = file + ':' + l + ':' + n + ':' + th;`, `      if (_cache.has(ck)) return;`, `      _cache.add(ck);`, `      __trickle_appendFileSync(_varsFile, JSON.stringify({ kind: 'variable', varName: n, line: l, module: mod, file: file, type: type, typeHash: th, sample: _sanitize(v, 2) }) + '\\n');`, `    } catch(e) {}`, `  };`, `}`, `function __trickle_tv(v, n, l) { try { globalThis.__trickle_var_tracer(v, n, l, ${JSON.stringify(moduleName)}, ${JSON.stringify(filename)}); } catch(e) {} }`);
+    }
+    prefixLines.push('');
+    const prefix = prefixLines.join('\n');
+    const allInsertions = [];
+    for (const { position, name, paramNames } of funcInsertions) {
         const paramNamesArg = paramNames.length > 0 ? JSON.stringify(paramNames) : 'null';
-        const wrapperCall = `\ntry{${name}=__trickle_wrap(${name},'${name}',${paramNamesArg})}catch(__e){}\n`;
-        result = result.slice(0, position) + wrapperCall + result.slice(position);
+        allInsertions.push({
+            position,
+            code: `\ntry{${name}=__trickle_wrap(${name},'${name}',${paramNamesArg})}catch(__e){}\n`,
+        });
+    }
+    for (const { lineEnd, varName, lineNo } of varInsertions) {
+        allInsertions.push({
+            position: lineEnd,
+            code: `\n;try{__trickle_tv(${varName},${JSON.stringify(varName)},${lineNo})}catch(__e){}\n`,
+        });
+    }
+    for (const { lineEnd, varNames, lineNo } of destructInsertions) {
+        const calls = varNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+        allInsertions.push({
+            position: lineEnd,
+            code: `\n;try{${calls}}catch(__e){}\n`,
+        });
+    }
+    // Sort by position descending (insert from end to preserve earlier positions)
+    allInsertions.sort((a, b) => b.position - a.position);
+    let result = source;
+    for (const { position, code } of allInsertions) {
+        result = result.slice(0, position) + code + result.slice(position);
     }
     return prefix + result;
 }

package/dist/wrap.js

@@ -4,7 +4,6 @@ exports.typeCache = void 0;
 exports.wrapFunction = wrapFunction;
 const type_inference_1 = require("./type-inference");
 const type_hash_1 = require("./type-hash");
-const proxy_tracker_1 = require("./proxy-tracker");
 const cache_1 = require("./cache");
 const transport_1 = require("./transport");
 const typeCache = new cache_1.TypeCache();
@@ -29,21 +28,14 @@ function wrapFunction(fn, opts) {
         if (opts.sampleRate < 1 && Math.random() > opts.sampleRate) {
             return fn.apply(this, args);
         }
-        // Set up arg tracking
-        const trackers = [];
-        const proxiedArgs = args.map((arg, i) => {
-            if (arg !== null && arg !== undefined && typeof arg === 'object') {
-                const tracker = (0, proxy_tracker_1.createTracker)(arg);
-                trackers.push(tracker);
-                return tracker.proxy;
-            }
-            return arg;
-        });
         let result;
         let threwError = false;
         let caughtError;
+        const trackers = [];
         try {
-            result = fn.apply(this, proxiedArgs);
+            // Always pass ORIGINAL args to the function — never proxied ones.
+            // Proxied args can break framework internals (Express Router, DI containers, etc.)
+            result = fn.apply(this, args);
         }
         catch (err) {
             threwError = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
     "./auto": "./auto.js",
     "./auto-env": "./auto-env.js",
     "./auto-esm": "./auto-esm.mjs",
-    "./vite-plugin": "./dist/vite-plugin.js"
+    "./vite-plugin": "./dist/vite-plugin.js",
+    "./trace-var": "./dist/trace-var.js"
   },
   "scripts": {
     "build": "tsc",
@@ -22,6 +23,12 @@
   "devDependencies": {
     "typescript": "^5.4.0"
   },
-  "keywords": ["observability", "types", "runtime", "lambda", "express"],
+  "keywords": [
+    "observability",
+    "types",
+    "runtime",
+    "lambda",
+    "express"
+  ],
   "license": "MIT"
 }