trickle-observe 0.2.77 → 0.2.79

package/dist/observe-register.js

@@ -39,6 +39,7 @@ const wrap_1 = require("./wrap");
 const fetch_observer_1 = require("./fetch-observer");
 const express_1 = require("./express");
 const trace_var_1 = require("./trace-var");
+const vite_plugin_1 = require("./vite-plugin");
 const M = module_1.default;
 const originalLoad = M._load;
 const originalCompile = M.prototype._compile;
@@ -538,7 +539,12 @@ function transformCjsSource(source, filename, moduleName, env) {
             destructInsertions = findDestructuredDeclarations(source);
         }
     }
-    if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && classInsertions.length === 0)
+    // Additional variable patterns: reassignments, for-loops, catch clauses, function params
+    const reassignInsertions = (0, vite_plugin_1.findReassignments)(source);
+    const forLoopInsertions = (0, vite_plugin_1.findForLoopVars)(source);
+    const catchInsertions = (0, vite_plugin_1.findCatchVars)(source);
+    const funcParamInsertions = (0, vite_plugin_1.findFunctionParams)(source, false);
+    if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && funcParamInsertions.length === 0 && classInsertions.length === 0)
         return source;
     // Resolve the path to the wrap helper (compiled JS)
     const wrapHelperPath = path_1.default.join(__dirname, 'wrap.js');
@@ -561,7 +567,7 @@ function transformCjsSource(source, filename, moduleName, env) {
         `};`,
     ];
     // Add variable tracing helper if we have var insertions
-    if (varInsertions.length > 0 || destructInsertions.length > 0) {
+    if (varInsertions.length > 0 || destructInsertions.length > 0 || reassignInsertions.length > 0 || forLoopInsertions.length > 0 || catchInsertions.length > 0 || funcParamInsertions.length > 0) {
         const traceVarPath = path_1.default.join(__dirname, 'trace-var.js');
         prefixLines.push(`var __trickle_tv_mod = require(${JSON.stringify(traceVarPath)});`, `var __trickle_tv = function(v, n, l) { try { __trickle_tv_mod.traceVar(v, n, l, ${JSON.stringify(moduleName)}, ${JSON.stringify(filename)}); } catch(e){} };`);
     }
@@ -588,6 +594,37 @@ function transformCjsSource(source, filename, moduleName, env) {
             code: `\n;try{${calls}}catch(__e){}\n`,
         });
     }
+    // Reassignment insertions
+    for (const { lineEnd, varName, lineNo } of reassignInsertions) {
+        allInsertions.push({
+            position: lineEnd,
+            code: `\n;try{__trickle_tv(${varName},${JSON.stringify(varName)},${lineNo})}catch(__e){}\n`,
+        });
+    }
+    // For-loop variable insertions
+    for (const { bodyStart, varNames, lineNo } of forLoopInsertions) {
+        const calls = varNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+        allInsertions.push({
+            position: bodyStart,
+            code: `\ntry{${calls}}catch(__e){}\n`,
+        });
+    }
+    // Catch clause insertions
+    for (const { bodyStart, varNames, lineNo } of catchInsertions) {
+        const calls = varNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+        allInsertions.push({
+            position: bodyStart,
+            code: `\ntry{${calls}}catch(__e2){}\n`,
+        });
+    }
+    // Function parameter insertions
+    for (const { bodyStart, paramNames, lineNo } of funcParamInsertions) {
+        const calls = paramNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+        allInsertions.push({
+            position: bodyStart,
+            code: `\ntry{${calls}}catch(__e){}\n`,
+        });
+    }
     // Add class method wrappings
     for (const ci of classInsertions) {
         allInsertions.push(ci);

package/dist/trace-var.js

@@ -57,8 +57,8 @@ const type_hash_1 = require("./type-hash");
 /** Where to write variable observations */
 let varsFilePath = '';
 let debugMode = false;
-/** Cache: "file:line:varName:typeHash" → already written */
-const varCache = new Set();
+/** Cache: "file:line:varName" → { fingerprint, timestamp } for value-aware dedup */
+const varCache = new Map();
 /** Batch buffer for writing — avoids one fs.appendFileSync per variable */
 let varBuffer = [];
 let flushTimer = null;
@@ -105,10 +105,17 @@ function traceVar(value, varName, line, moduleName, filePath) {
         // Create a stable hash for dedup
         const dummyArgs = { kind: 'tuple', elements: [] };
         const typeHash = (0, type_hash_1.hashType)(dummyArgs, type);
-        const cacheKey = `${filePath}:${line}:${varName}:${typeHash}`;
-        if (varCache.has(cacheKey))
+        // Value-aware dedup: re-send if value changed or 10s elapsed
+        const cacheKey = `${filePath}:${line}:${varName}`;
+        const t = typeof value;
+        const fp = (t === 'string' || t === 'number' || t === 'boolean' || value === null || value === undefined)
+            ? String(value).substring(0, 60)
+            : typeHash;
+        const now = Date.now();
+        const prev = varCache.get(cacheKey);
+        if (prev && prev.fp === fp && (now - prev.ts) < 10000)
             return;
-        varCache.add(cacheKey);
+        varCache.set(cacheKey, { fp, ts: now });
         const sample = sanitizeVarSample(value);
         const observation = {
             kind: 'variable',

package/dist/vite-plugin.d.ts

@@ -40,6 +40,53 @@ export declare function tricklePlugin(options?: TricklePluginOptions): {
         map: null;
     } | null;
 };
+/**
+ * Find variable reassignments (not declarations) and return insertions for tracing.
+ * Handles: x = newValue; x += 1; x ||= fallback; etc.
+ * Only matches standalone reassignment statements at the start of a line.
+ * Skips: property assignments (obj.x = ...), indexed (arr[i] = ...),
+ *        comparisons (===, !==), arrow functions (=>), declarations (const/let/var).
+ */
+export declare function findReassignments(source: string): Array<{
+    lineEnd: number;
+    varName: string;
+    lineNo: number;
+}>;
+/**
+ * Find for-loop variable declarations and return insertions for tracing.
+ * Handles:
+ *   for (const item of items) { ... }         → trace item
+ *   for (const [key, val] of entries) { ... }  → trace key, val
+ *   for (const { a, b } of items) { ... }      → trace a, b
+ *   for (const key in obj) { ... }             → trace key
+ *   for (let i = 0; i < n; i++) { ... }        → trace i
+ * Inserts trace calls at the start of the loop body.
+ */
+/**
+ * Find catch clause variables and return insertions for tracing.
+ * Handles: catch (err) { ... } → trace err at start of catch body.
+ */
+export declare function findCatchVars(source: string): Array<{
+    bodyStart: number;
+    varNames: string[];
+    lineNo: number;
+}>;
+export declare function findForLoopVars(source: string): Array<{
+    bodyStart: number;
+    varNames: string[];
+    lineNo: number;
+}>;
+/**
+ * Find function parameter names and return insertions for tracing at the start
+ * of function bodies. Traces the runtime values of all parameters.
+ * Handles: function declarations, arrow functions, method definitions.
+ * Skips: React components (already tracked via __trickle_rc with props).
+ */
+export declare function findFunctionParams(source: string, isReactFile: boolean): Array<{
+    bodyStart: number;
+    paramNames: string[];
+    lineNo: number;
+}>;
 export declare function transformEsmSource(source: string, filename: string, moduleName: string, backendUrl: string, debug: boolean, traceVars: boolean, originalSource?: string | null, isSSR?: boolean, 
 /** URL for fetch-based browser transport (Next.js client). When set and isSSR=false, uses fetch() instead of import.meta.hot */
 ingestUrl?: string | null): string;

package/dist/vite-plugin.js

@@ -23,6 +23,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tricklePlugin = tricklePlugin;
+exports.findReassignments = findReassignments;
+exports.findCatchVars = findCatchVars;
+exports.findForLoopVars = findForLoopVars;
+exports.findFunctionParams = findFunctionParams;
 exports.transformEsmSource = transformEsmSource;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -658,8 +662,8 @@ function findJsxExpressions(source) {
         // Skip if this looks like a template literal expression `${`
         if (charBefore === '$')
             continue;
-        // Skip if preceded by `(` or `,` (function arguments, not JSX)
-        if (charBefore === '(' || charBefore === ',')
+        // Skip if preceded by `,` (function arguments, not JSX)
+        if (charBefore === ',')
             continue;
         // Must be in a JSX context: look backward for `>` or `}` (closing tag bracket or prev expression)
         // before hitting structural JS characters like `{`, `(`, `;`
@@ -675,8 +679,19 @@ function findJsxExpressions(source) {
                 inJsx = true;
                 break;
             } // After a previous JSX expression
-            if (ch === '{' || ch === '(' || ch === ';')
+            if (ch === '{' || ch === ';')
                 break;
+            // `(` breaks scan in code context, but in JSX text `(` is normal
+            // Check: if `(` is preceded by `>` or text, it's JSX text
+            if (ch === '(') {
+                const before = source.slice(Math.max(0, scanPos - 20), scanPos).trim();
+                if (before.endsWith('>') || /[a-zA-Z0-9\s]$/.test(before)) {
+                    // Could be JSX text like "Users ({count})" — keep scanning
+                    scanPos--;
+                    continue;
+                }
+                break;
+            }
             // `=` only breaks if NOT preceded by other text (could be JSX text like "count = 5")
             if (ch === '=' && scanPos > 0 && /\s/.test(source[scanPos - 1])) {
                 // Check if this `=` is a JSX attribute assignment: look further back for tag

package/dist-esm/vite-plugin.js

@@ -488,7 +488,7 @@ function extractDestructuredNames(pattern) {
  * Skips: property assignments (obj.x = ...), indexed (arr[i] = ...),
  *        comparisons (===, !==), arrow functions (=>), declarations (const/let/var).
  */
-function findReassignments(source) {
+export function findReassignments(source) {
     const results = [];
     // Match: <identifier> <assignOp>= <value> at the start of a line
     // Compound operators: +=, -=, *=, /=, %=, **=, &&=, ||=, ??=, <<=, >>=, >>>=, &=, |=, ^=
@@ -604,7 +604,7 @@ function findReassignments(source) {
  * Find catch clause variables and return insertions for tracing.
  * Handles: catch (err) { ... } → trace err at start of catch body.
  */
-function findCatchVars(source) {
+export function findCatchVars(source) {
     const results = [];
     const catchRegex = /\bcatch\s*\(\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?::\s*[^)]+?)?\s*\)\s*\{/g;
     let match;
@@ -651,8 +651,8 @@ function findJsxExpressions(source) {
         // Skip if this looks like a template literal expression `${`
         if (charBefore === '$')
             continue;
-        // Skip if preceded by `(` or `,` (function arguments, not JSX)
-        if (charBefore === '(' || charBefore === ',')
+        // Skip if preceded by `,` (function arguments, not JSX)
+        if (charBefore === ',')
             continue;
         // Must be in a JSX context: look backward for `>` or `}` (closing tag bracket or prev expression)
         // before hitting structural JS characters like `{`, `(`, `;`
@@ -668,8 +668,19 @@ function findJsxExpressions(source) {
                 inJsx = true;
                 break;
             } // After a previous JSX expression
-            if (ch === '{' || ch === '(' || ch === ';')
+            if (ch === '{' || ch === ';')
                 break;
+            // `(` breaks scan in code context, but in JSX text `(` is normal
+            // Check: if `(` is preceded by `>` or text, it's JSX text
+            if (ch === '(') {
+                const before = source.slice(Math.max(0, scanPos - 20), scanPos).trim();
+                if (before.endsWith('>') || /[a-zA-Z0-9\s]$/.test(before)) {
+                    // Could be JSX text like "Users ({count})" — keep scanning
+                    scanPos--;
+                    continue;
+                }
+                break;
+            }
             // `=` only breaks if NOT preceded by other text (could be JSX text like "count = 5")
             if (ch === '=' && scanPos > 0 && /\s/.test(source[scanPos - 1])) {
                 // Check if this `=` is a JSX attribute assignment: look further back for tag
@@ -755,7 +766,7 @@ function findJsxExpressions(source) {
     }
     return results;
 }
-function findForLoopVars(source) {
+export function findForLoopVars(source) {
     const results = [];
     // Match: for (const/let/var ...
     const forRegex = /\bfor\s*\(/g;
@@ -847,7 +858,7 @@ function findForLoopVars(source) {
  * Handles: function declarations, arrow functions, method definitions.
  * Skips: React components (already tracked via __trickle_rc with props).
  */
-function findFunctionParams(source, isReactFile) {
+export function findFunctionParams(source, isReactFile) {
     const results = [];
     // Match function declarations: function name(params) {
     const funcDeclRegex = /\b(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.77",
+  "version": "0.2.79",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/observe-register.ts

@@ -36,6 +36,12 @@ import { WrapOptions } from './types';
 import { patchFetch } from './fetch-observer';
 import { instrumentExpress, trickleMiddleware } from './express';
 import { initVarTracer, traceVar } from './trace-var';
+import {
+  findReassignments,
+  findForLoopVars,
+  findCatchVars,
+  findFunctionParams,
+} from './vite-plugin';
 
 const M = Module as any;
 const originalLoad = M._load;
@@ -508,7 +514,13 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     }
   }
 
-  if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && classInsertions.length === 0) return source;
+  // Additional variable patterns: reassignments, for-loops, catch clauses, function params
+  const reassignInsertions = findReassignments(source);
+  const forLoopInsertions = findForLoopVars(source);
+  const catchInsertions = findCatchVars(source);
+  const funcParamInsertions = findFunctionParams(source, false);
+
+  if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && funcParamInsertions.length === 0 && classInsertions.length === 0) return source;
 
   // Resolve the path to the wrap helper (compiled JS)
   const wrapHelperPath = path.join(__dirname, 'wrap.js');
@@ -533,7 +545,7 @@ function transformCjsSource(source: string, filename: string, moduleName: string
   ];
 
   // Add variable tracing helper if we have var insertions
-  if (varInsertions.length > 0 || destructInsertions.length > 0) {
+  if (varInsertions.length > 0 || destructInsertions.length > 0 || reassignInsertions.length > 0 || forLoopInsertions.length > 0 || catchInsertions.length > 0 || funcParamInsertions.length > 0) {
     const traceVarPath = path.join(__dirname, 'trace-var.js');
     prefixLines.push(
       `var __trickle_tv_mod = require(${JSON.stringify(traceVarPath)});`,
@@ -571,6 +583,41 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     });
   }
 
+  // Reassignment insertions
+  for (const { lineEnd, varName, lineNo } of reassignInsertions) {
+    allInsertions.push({
+      position: lineEnd,
+      code: `\n;try{__trickle_tv(${varName},${JSON.stringify(varName)},${lineNo})}catch(__e){}\n`,
+    });
+  }
+
+  // For-loop variable insertions
+  for (const { bodyStart, varNames, lineNo } of forLoopInsertions) {
+    const calls = varNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+    allInsertions.push({
+      position: bodyStart,
+      code: `\ntry{${calls}}catch(__e){}\n`,
+    });
+  }
+
+  // Catch clause insertions
+  for (const { bodyStart, varNames, lineNo } of catchInsertions) {
+    const calls = varNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+    allInsertions.push({
+      position: bodyStart,
+      code: `\ntry{${calls}}catch(__e2){}\n`,
+    });
+  }
+
+  // Function parameter insertions
+  for (const { bodyStart, paramNames, lineNo } of funcParamInsertions) {
+    const calls = paramNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo})`).join(';');
+    allInsertions.push({
+      position: bodyStart,
+      code: `\ntry{${calls}}catch(__e){}\n`,
+    });
+  }
+
   // Add class method wrappings
   for (const ci of classInsertions) {
     allInsertions.push(ci);

package/src/trace-var.ts

@@ -24,8 +24,8 @@ import { hashType } from './type-hash';
 let varsFilePath = '';
 let debugMode = false;
 
-/** Cache: "file:line:varName:typeHash" → already written */
-const varCache = new Set<string>();
+/** Cache: "file:line:varName" → { fingerprint, timestamp } for value-aware dedup */
+const varCache = new Map<string, { fp: string; ts: number }>();
 
 /** Batch buffer for writing — avoids one fs.appendFileSync per variable */
 let varBuffer: string[] = [];
@@ -92,9 +92,16 @@ export function traceVar(
     const dummyArgs: TypeNode = { kind: 'tuple', elements: [] };
     const typeHash = hashType(dummyArgs, type);
 
-    const cacheKey = `${filePath}:${line}:${varName}:${typeHash}`;
-    if (varCache.has(cacheKey)) return;
-    varCache.add(cacheKey);
+    // Value-aware dedup: re-send if value changed or 10s elapsed
+    const cacheKey = `${filePath}:${line}:${varName}`;
+    const t = typeof value;
+    const fp = (t === 'string' || t === 'number' || t === 'boolean' || value === null || value === undefined)
+      ? String(value).substring(0, 60)
+      : typeHash;
+    const now = Date.now();
+    const prev = varCache.get(cacheKey);
+    if (prev && prev.fp === fp && (now - prev.ts) < 10000) return;
+    varCache.set(cacheKey, { fp, ts: now });
 
     const sample = sanitizeVarSample(value);
 

package/src/vite-plugin.ts

@@ -473,7 +473,7 @@ function extractDestructuredNames(pattern: string): string[] {
  * Skips: property assignments (obj.x = ...), indexed (arr[i] = ...),
  *        comparisons (===, !==), arrow functions (=>), declarations (const/let/var).
  */
-function findReassignments(source: string): Array<{ lineEnd: number; varName: string; lineNo: number }> {
+export function findReassignments(source: string): Array<{ lineEnd: number; varName: string; lineNo: number }> {
   const results: Array<{ lineEnd: number; varName: string; lineNo: number }> = [];
 
   // Match: <identifier> <assignOp>= <value> at the start of a line
@@ -578,7 +578,7 @@ function findReassignments(source: string): Array<{ lineEnd: number; varName: st
  * Find catch clause variables and return insertions for tracing.
  * Handles: catch (err) { ... } → trace err at start of catch body.
  */
-function findCatchVars(source: string): Array<{ bodyStart: number; varNames: string[]; lineNo: number }> {
+export function findCatchVars(source: string): Array<{ bodyStart: number; varNames: string[]; lineNo: number }> {
   const results: Array<{ bodyStart: number; varNames: string[]; lineNo: number }> = [];
   const catchRegex = /\bcatch\s*\(\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?::\s*[^)]+?)?\s*\)\s*\{/g;
   let match;
@@ -632,8 +632,8 @@ function findJsxExpressions(source: string): Array<{ exprStart: number; exprEnd:
     // Skip if this looks like a template literal expression `${`
     if (charBefore === '$') continue;
 
-    // Skip if preceded by `(` or `,` (function arguments, not JSX)
-    if (charBefore === '(' || charBefore === ',') continue;
+    // Skip if preceded by `,` (function arguments, not JSX)
+    if (charBefore === ',') continue;
 
     // Must be in a JSX context: look backward for `>` or `}` (closing tag bracket or prev expression)
     // before hitting structural JS characters like `{`, `(`, `;`
@@ -643,7 +643,18 @@ function findJsxExpressions(source: string): Array<{ exprStart: number; exprEnd:
       const ch = source[scanPos];
       if (ch === '>') { inJsx = true; break; }
       if (ch === '}') { inJsx = true; break; } // After a previous JSX expression
-      if (ch === '{' || ch === '(' || ch === ';') break;
+      if (ch === '{' || ch === ';') break;
+      // `(` breaks scan in code context, but in JSX text `(` is normal
+      // Check: if `(` is preceded by `>` or text, it's JSX text
+      if (ch === '(') {
+        const before = source.slice(Math.max(0, scanPos - 20), scanPos).trim();
+        if (before.endsWith('>') || /[a-zA-Z0-9\s]$/.test(before)) {
+          // Could be JSX text like "Users ({count})" — keep scanning
+          scanPos--;
+          continue;
+        }
+        break;
+      }
       // `=` only breaks if NOT preceded by other text (could be JSX text like "count = 5")
       if (ch === '=' && scanPos > 0 && /\s/.test(source[scanPos - 1])) {
         // Check if this `=` is a JSX attribute assignment: look further back for tag
@@ -720,7 +731,7 @@ function findJsxExpressions(source: string): Array<{ exprStart: number; exprEnd:
   return results;
 }
 
-function findForLoopVars(source: string): Array<{ bodyStart: number; varNames: string[]; lineNo: number }> {
+export function findForLoopVars(source: string): Array<{ bodyStart: number; varNames: string[]; lineNo: number }> {
   const results: Array<{ bodyStart: number; varNames: string[]; lineNo: number }> = [];
 
   // Match: for (const/let/var ...
@@ -812,7 +823,7 @@ function findForLoopVars(source: string): Array<{ bodyStart: number; varNames: s
  * Handles: function declarations, arrow functions, method definitions.
  * Skips: React components (already tracked via __trickle_rc with props).
  */
-function findFunctionParams(source: string, isReactFile: boolean): Array<{ bodyStart: number; paramNames: string[]; lineNo: number }> {
+export function findFunctionParams(source: string, isReactFile: boolean): Array<{ bodyStart: number; paramNames: string[]; lineNo: number }> {
   const results: Array<{ bodyStart: number; paramNames: string[]; lineNo: number }> = [];
 
   // Match function declarations: function name(params) {