@tracecode/harness 0.5.1 → 0.6.1

package/workers/java/src/harness/browser/JavaRewriteLibrary.java

@@ -0,0 +1,54 @@
+package harness.browser;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import spike.rewriter.GenericPracticeRewriter;
+
+public final class JavaRewriteLibrary {
+  private JavaRewriteLibrary() {}
+
+  public static String rewriteSource(
+      String source,
+      String executionStyle,
+      String entryName,
+      String exportsSource,
+      String exportsClassName,
+      String packageName
+  ) throws Exception {
+    Path workDir = Files.createTempDirectory("tracecode-java-rewrite-");
+    Path inputPath = workDir.resolve("Input.java");
+    Path outputPath = workDir.resolve("Output.java");
+
+    try {
+      Files.writeString(inputPath, normalizeTopLevelPublicClasses(source), StandardCharsets.UTF_8);
+      GenericPracticeRewriter.main(
+          new String[] {
+              inputPath.toString(),
+              outputPath.toString(),
+              executionStyle,
+              entryName,
+          });
+      String rewrittenSource = Files.readString(outputPath, StandardCharsets.UTF_8);
+      String renamedExports =
+          exportsSource.replaceAll("\\bpublic class Exports\\b", "public class " + exportsClassName);
+      return "package " + packageName + ";\n\n" + rewrittenSource.trim() + "\n\n" + renamedExports.trim() + "\n";
+    } finally {
+      try (var paths = Files.walk(workDir)) {
+        paths
+            .sorted((left, right) -> right.getNameCount() - left.getNameCount())
+            .forEach(
+                path -> {
+                  try {
+                    Files.deleteIfExists(path);
+                  } catch (Exception ignored) {
+                  }
+                });
+      }
+    }
+  }
+
+  private static String normalizeTopLevelPublicClasses(String source) {
+    return source.replaceAll("(^|\\n)\\s*public\\s+class\\s+", "$1class ");
+  }
+}

package/workers/javascript/javascript-worker.js

@@ -118,27 +118,14 @@ function createConsoleProxy(output) {
 
 function isLikelyTreeNodeValue(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const hasValue =
-    Object.prototype.hasOwnProperty.call(value, 'val') ||
-    Object.prototype.hasOwnProperty.call(value, 'value');
-  const hasTreeLinks =
-    Object.prototype.hasOwnProperty.call(value, 'left') ||
-    Object.prototype.hasOwnProperty.call(value, 'right');
-  return hasValue && hasTreeLinks;
+  if (value.__type__ === 'TreeNode') return true;
+  return value?.constructor?.name === 'TreeNode';
 }
 
 function isLikelyListNodeValue(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const hasValue =
-    Object.prototype.hasOwnProperty.call(value, 'val') ||
-    Object.prototype.hasOwnProperty.call(value, 'value');
-  const hasTreeLinks =
-    Object.prototype.hasOwnProperty.call(value, 'left') ||
-    Object.prototype.hasOwnProperty.call(value, 'right');
-  const hasListLinks =
-    Object.prototype.hasOwnProperty.call(value, 'next') ||
-    Object.prototype.hasOwnProperty.call(value, 'prev');
-  return hasValue && hasListLinks && !hasTreeLinks;
+  if (value.__type__ === 'ListNode') return true;
+  return value?.constructor?.name === 'ListNode';
 }
 
 function getCustomClassName(value) {
@@ -199,25 +186,33 @@ function serializeValue(
       const nodeId = `${nodePrefix}-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(value, nodeId);
 
-      if (nodePrefix === 'tree') {
-        return {
-          __type__: 'TreeNode',
-          __id__: nodeId,
-          val: serializeValue(value.val ?? value.value ?? null, depth + 1, seen, nodeRefState),
-          left: serializeValue(value.left ?? null, depth + 1, seen, nodeRefState),
-          right: serializeValue(value.right ?? null, depth + 1, seen, nodeRefState),
-        };
+      const out =
+        nodePrefix === 'tree'
+          ? {
+              __type__: 'TreeNode',
+              __id__: nodeId,
+              val: serializeValue(value.val ?? value.value ?? null, depth + 1, seen, nodeRefState),
+              left: serializeValue(value.left ?? null, depth + 1, seen, nodeRefState),
+              right: serializeValue(value.right ?? null, depth + 1, seen, nodeRefState),
+            }
+          : {
+              __type__: 'ListNode',
+              __id__: nodeId,
+              val: serializeValue(value.val ?? value.value ?? null, depth + 1, seen, nodeRefState),
+              next: serializeValue(value.next ?? null, depth + 1, seen, nodeRefState),
+              ...(Object.prototype.hasOwnProperty.call(value, 'prev')
+                ? { prev: serializeValue(value.prev ?? null, depth + 1, seen, nodeRefState) }
+                : {}),
+            };
+      const skipped =
+        nodePrefix === 'tree'
+          ? new Set(['__id__', '__type__', '__class__', 'val', 'value', 'left', 'right'])
+          : new Set(['__id__', '__type__', '__class__', 'val', 'value', 'next', 'prev']);
+      for (const [k, v] of Object.entries(value)) {
+        if (skipped.has(k)) continue;
+        out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
       }
-
-      return {
-        __type__: 'ListNode',
-        __id__: nodeId,
-        val: serializeValue(value.val ?? value.value ?? null, depth + 1, seen, nodeRefState),
-        next: serializeValue(value.next ?? null, depth + 1, seen, nodeRefState),
-        ...(Object.prototype.hasOwnProperty.call(value, 'prev')
-          ? { prev: serializeValue(value.prev ?? null, depth + 1, seen, nodeRefState) }
-          : {}),
-      };
+      return out;
     }
 
     const customClassName = getCustomClassName(value);
@@ -273,25 +268,32 @@ function serializeTopLevelValue(value, nodeRefState) {
       nodeRefState.ids.set(objectValue, nodeId);
     }
 
-    if (isTree) {
-      return {
-        __type__: 'TreeNode',
-        __id__: nodeId,
-        val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
-        left: serializeValue(nodeValue.left ?? null, 1, new WeakSet(), nodeRefState),
-        right: serializeValue(nodeValue.right ?? null, 1, new WeakSet(), nodeRefState),
-      };
+    const out =
+      isTree
+        ? {
+            __type__: 'TreeNode',
+            __id__: nodeId,
+            val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
+            left: serializeValue(nodeValue.left ?? null, 1, new WeakSet(), nodeRefState),
+            right: serializeValue(nodeValue.right ?? null, 1, new WeakSet(), nodeRefState),
+          }
+        : {
+            __type__: 'ListNode',
+            __id__: nodeId,
+            val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
+            next: serializeValue(nodeValue.next ?? null, 1, new WeakSet(), nodeRefState),
+            ...('prev' in nodeValue
+              ? { prev: serializeValue(nodeValue.prev ?? null, 1, new WeakSet(), nodeRefState) }
+              : {}),
+          };
+    const skipped = isTree
+      ? new Set(['__id__', '__type__', '__class__', 'val', 'value', 'left', 'right'])
+      : new Set(['__id__', '__type__', '__class__', 'val', 'value', 'next', 'prev']);
+    for (const [k, v] of Object.entries(nodeValue)) {
+      if (skipped.has(k)) continue;
+      out[k] = serializeValue(v, 1, new WeakSet(), nodeRefState);
     }
-
-    return {
-      __type__: 'ListNode',
-      __id__: nodeId,
-      val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
-      next: serializeValue(nodeValue.next ?? null, 1, new WeakSet(), nodeRefState),
-      ...('prev' in nodeValue
-        ? { prev: serializeValue(nodeValue.prev ?? null, 1, new WeakSet(), nodeRefState) }
-        : {}),
-    };
+    return out;
   }
 
   const customClassName = getCustomClassName(value);
@@ -450,12 +452,17 @@ function materializeTreeInput(value) {
   }
   if (isLikelyTreeNodeValue(value) || value.__type__ === 'TreeNode') {
     const nodeValue = value;
-    return {
+    const node = {
       val: nodeValue.val ?? nodeValue.value ?? null,
       value: nodeValue.val ?? nodeValue.value ?? null,
       left: materializeTreeInput(nodeValue.left ?? null),
       right: materializeTreeInput(nodeValue.right ?? null),
     };
+    for (const [key, nested] of Object.entries(value)) {
+      if (key === '__id__' || key === '__type__' || key === '__class__' || key === 'val' || key === 'value' || key === 'left' || key === 'right') continue;
+      node[key] = materializeTreeInput(nested);
+    }
+    return node;
   }
   return value;
 }
@@ -493,6 +500,10 @@ function materializeListInput(value, refs = new Map(), materialized = new WeakMa
       refs.set(value.__id__, node);
     }
     node.next = materializeListInput(value.next ?? null, refs, materialized);
+    for (const [key, nested] of Object.entries(value)) {
+      if (key === '__id__' || key === '__type__' || key === '__class__' || key === 'val' || key === 'value' || key === 'next') continue;
+      node[key] = materializeListInput(nested, refs, materialized);
+    }
     return node;
   }
   return value;
@@ -571,6 +582,7 @@ function applyInputMaterializers(inputs, materializers) {
 function inferFallbackInputMaterializers(inputs) {
   if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) return {};
   const inferred = {};
+  const LINKED_LIST_FALLBACK_NAMES = new Set(['head', 'l1', 'l2', 'list1', 'list2', 'node']);
   for (const [name, value] of Object.entries(inputs)) {
     const lowerName = String(name || '').toLowerCase();
     if (!Array.isArray(value)) continue;
@@ -578,7 +590,7 @@ function inferFallbackInputMaterializers(inputs) {
       inferred[name] = 'tree';
       continue;
     }
-    if (lowerName === 'head' || lowerName.endsWith('head') || lowerName.includes('list')) {
+    if (lowerName === 'head' || lowerName.endsWith('head') || LINKED_LIST_FALLBACK_NAMES.has(lowerName)) {
       inferred[name] = 'list';
       continue;
     }
@@ -799,9 +811,12 @@ function createTraceRecorder(options = {}) {
   const trace = [];
   const callStack = [];
   const pendingAccessesByFrame = new Map();
+  const deferredAccessesByFrame = new Map();
   const lineHitCount = new Map();
   const stableNodeRefState = { ids: new Map(), nextId: 1 };
   const maxTraceSteps = getNumericOption(options.maxTraceSteps, 4000);
+  const maxStoredEvents = getNumericOption(options.maxStoredEvents, maxTraceSteps);
+  const effectiveMaxTraceSteps = Math.min(maxTraceSteps, maxStoredEvents);
   const maxLineEvents = getNumericOption(options.maxLineEvents, 12000);
   const maxSingleLineHits = getNumericOption(options.maxSingleLineHits, 1000);
   const maxCallDepth = getNumericOption(options.maxCallDepth, 2000);
@@ -1099,11 +1114,22 @@ function createTraceRecorder(options = {}) {
       return undefined;
     }
     const pending = pendingAccessesByFrame.get(frameId);
-    if (!Array.isArray(pending) || pending.length === 0) {
+    const deferred = deferredAccessesByFrame.get(frameId);
+    let deferredReady = [];
+    if (deferred && Array.isArray(deferred.accesses) && deferred.accesses.length > 0) {
+      if (deferred.skipLineFlushes > 0) {
+        deferred.skipLineFlushes -= 1;
+        deferredAccessesByFrame.set(frameId, deferred);
+      } else {
+        deferredReady = deferred.accesses;
+        deferredAccessesByFrame.delete(frameId);
+      }
+    }
+    if ((!Array.isArray(pending) || pending.length === 0) && deferredReady.length === 0) {
       return undefined;
     }
     pendingAccessesByFrame.delete(frameId);
-    return pending.map((access) => ({
+    return [...(Array.isArray(pending) ? pending : []), ...deferredReady].map((access) => ({
       variable: access.variable,
       kind: access.kind,
       ...(Array.isArray(access.indices) && access.indices.length > 0
@@ -1115,13 +1141,13 @@ function createTraceRecorder(options = {}) {
   }
 
   function appendTrace(step, frameId = getCurrentFrameId()) {
-    if (trace.length >= maxTraceSteps) {
+    if (trace.length >= effectiveMaxTraceSteps) {
       const lineNumber = normalizeLine(step?.line, 1);
       if (!traceLimitExceeded) {
         traceLimitExceeded = true;
         timeoutReason = 'trace-limit';
       }
-      if (!timeoutRecorded && trace.length < maxTraceSteps) {
+      if (!timeoutRecorded && trace.length < effectiveMaxTraceSteps) {
         trace.push({
           line: lineNumber,
           event: 'timeout',
@@ -1131,13 +1157,51 @@ function createTraceRecorder(options = {}) {
         });
         timeoutRecorded = true;
       }
-      throw createLimitError('trace-limit', lineNumber, `Exceeded ${maxTraceSteps} trace steps`);
+      throw createLimitError('trace-limit', lineNumber, `Exceeded ${effectiveMaxTraceSteps} trace steps`);
     }
     const accesses = flushPendingAccesses(frameId);
-    trace.push({
+    const nextStep = {
       ...step,
       ...(accesses ? { accesses } : {}),
-    });
+    };
+    const previous = trace[trace.length - 1];
+    if (canMergeConsecutiveLineSteps(previous, nextStep)) {
+      previous.variables = {
+        ...(previous.variables || {}),
+        ...(nextStep.variables || {}),
+      };
+      if (nextStep.accesses?.length) {
+        previous.accesses = [...(previous.accesses || []), ...nextStep.accesses];
+      }
+      if (nextStep.visualization !== undefined) {
+        previous.visualization = nextStep.visualization;
+      }
+      previous.callStack = nextStep.callStack;
+      previous.function = nextStep.function;
+      return;
+    }
+    trace.push(nextStep);
+  }
+
+  function canMergeConsecutiveLineSteps(previous, nextStep) {
+    if (!previous || !nextStep) return false;
+    if (previous.event !== 'line' || nextStep.event !== 'line') return false;
+    if (previous.line !== nextStep.line) return false;
+    if (previous.function !== nextStep.function) return false;
+    return sameCallStackVisit(previous.callStack, nextStep.callStack);
+  }
+
+  function sameCallStackVisit(left, right) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    if (left.length !== right.length) return false;
+    for (let index = 0; index < left.length; index += 1) {
+      const leftFrame = left[index];
+      const rightFrame = right[index];
+      if (!leftFrame || !rightFrame) return false;
+      if (leftFrame.function !== rightFrame.function) return false;
+      if (leftFrame.line !== rightFrame.line) return false;
+    }
+    return true;
   }
 
   function markTimeout(reason, lineNumber, message) {
@@ -1146,7 +1210,7 @@ function createTraceRecorder(options = {}) {
       traceLimitExceeded = true;
       timeoutReason = reason;
     }
-    if (!timeoutRecorded && trace.length < maxTraceSteps) {
+    if (!timeoutRecorded && trace.length < effectiveMaxTraceSteps) {
       appendTrace({
         line: normalizedLine,
         event: 'timeout',
@@ -1209,6 +1273,7 @@ function createTraceRecorder(options = {}) {
         const frame = callStack.pop();
         if (frame?.id !== undefined) {
           pendingAccessesByFrame.delete(frame.id);
+          deferredAccessesByFrame.delete(frame.id);
         }
       }
     }
@@ -1324,6 +1389,25 @@ function createTraceRecorder(options = {}) {
       existing.push(normalized);
       pendingAccessesByFrame.set(frameId, existing);
     },
+    deferPendingAccesses(lineFlushes = 1) {
+      const frameId = getCurrentFrameId();
+      if (frameId === undefined) {
+        return;
+      }
+      const pending = pendingAccessesByFrame.get(frameId);
+      if (!Array.isArray(pending) || pending.length === 0) {
+        return;
+      }
+      pendingAccessesByFrame.delete(frameId);
+      const existing = deferredAccessesByFrame.get(frameId);
+      deferredAccessesByFrame.set(frameId, {
+        accesses: [...(Array.isArray(existing?.accesses) ? existing.accesses : []), ...pending],
+        skipLineFlushes: Math.max(
+          typeof existing?.skipLineFlushes === 'number' ? existing.skipLineFlushes : 0,
+          Math.max(0, Math.trunc(lineFlushes))
+        ),
+      });
+    },
     line(lineNumber, snapshotFactory, functionNameOverride, functionStartLine) {
       const normalizedLine = normalizeLine(lineNumber, callStack[callStack.length - 1]?.line ?? 1);
 
@@ -1412,6 +1496,7 @@ function createTraceRecorder(options = {}) {
         const frame = callStack.pop();
         if (frame?.id !== undefined) {
           pendingAccessesByFrame.delete(frame.id);
+          deferredAccessesByFrame.delete(frame.id);
         }
       }
     },
@@ -1421,6 +1506,7 @@ function createTraceRecorder(options = {}) {
         const frame = callStack.pop();
         if (frame?.id !== undefined) {
           pendingAccessesByFrame.delete(frame.id);
+          deferredAccessesByFrame.delete(frame.id);
         }
       }
     },
@@ -1724,6 +1810,8 @@ function shouldTraceStatement(ts, statement) {
   return !(
     ts.isFunctionDeclaration(statement) ||
     ts.isClassDeclaration(statement) ||
+    ts.isWhileStatement(statement) ||
+    ts.isForStatement(statement) ||
     ts.isEmptyStatement(statement) ||
     ts.isBlock(statement)
   );
@@ -2134,6 +2222,162 @@ function createTraceLineStatement(ts, sourceFile, statement, variableNames, line
   );
 }
 
+function ensureBlockStatement(ts, statement) {
+  if (ts.isBlock(statement)) {
+    return statement;
+  }
+  return ts.factory.createBlock([statement], true);
+}
+
+function rewriteWhileStatementForTracing(ts, sourceFile, whileStatement, variableNames, lineFunctionMap, defaultFunctionName) {
+  const originalNode = ts.getOriginalNode(whileStatement) ?? whileStatement;
+  const tracedLine = createTraceLineStatement(
+    ts,
+    sourceFile,
+    originalNode,
+    variableNames,
+    lineFunctionMap,
+    defaultFunctionName
+  );
+  const visitedBodyBlock = ensureBlockStatement(ts, whileStatement.statement);
+  const guardedBreak = ts.factory.createIfStatement(
+    ts.factory.createPrefixUnaryExpression(
+      ts.SyntaxKind.ExclamationToken,
+      whileStatement.expression
+    ),
+    ts.factory.createBreakStatement(),
+    undefined
+  );
+  return ts.factory.createWhileStatement(
+    ts.factory.createTrue(),
+    ts.factory.createBlock(
+      [
+        tracedLine,
+        guardedBreak,
+        ...visitedBodyBlock.statements,
+      ],
+      true
+    )
+  );
+}
+
+function rewriteForStatementForTracing(ts, sourceFile, forStatement, variableNames, lineFunctionMap, defaultFunctionName) {
+  const originalNode = ts.getOriginalNode(forStatement) ?? forStatement;
+  const tracedLineCall = createTraceLineStatement(
+    ts,
+    sourceFile,
+    originalNode,
+    variableNames,
+    lineFunctionMap,
+    defaultFunctionName
+  ).expression;
+  const condition = forStatement.condition ?? ts.factory.createTrue();
+  const tracedCondition = ts.factory.createParenthesizedExpression(
+    ts.factory.createBinaryExpression(
+      tracedLineCall,
+      ts.SyntaxKind.CommaToken,
+      condition
+    )
+  );
+  return ts.factory.updateForStatement(
+    forStatement,
+    forStatement.initializer,
+    tracedCondition,
+    forStatement.incrementor,
+    forStatement.statement
+  );
+}
+
+function rewriteForOfStatementForTracing(ts, sourceFile, forOfStatement, variableNames, lineFunctionMap, defaultFunctionName) {
+  const originalNode = ts.getOriginalNode(forOfStatement) ?? forOfStatement;
+  const lineNumber = ts.getLineAndCharacterOfPosition(sourceFile, originalNode.getStart(sourceFile)).line + 1;
+  const tempIndexName = `__traceForOfIndex_${lineNumber}_${originalNode.pos < 0 ? 0 : originalNode.pos}`;
+  const tempArrayName = `__traceForOfArray_${lineNumber}_${originalNode.pos < 0 ? 0 : originalNode.pos}`;
+  const arrayId = ts.factory.createIdentifier(tempArrayName);
+  const indexId = ts.factory.createIdentifier(tempIndexName);
+  const visitedBodyBlock = ensureBlockStatement(ts, forOfStatement.statement);
+  const tracedLine = createTraceLineStatement(
+    ts,
+    sourceFile,
+    originalNode,
+    variableNames,
+    lineFunctionMap,
+    defaultFunctionName
+  );
+  const tracedLineCall = createTraceLineStatement(
+    ts,
+    sourceFile,
+    originalNode,
+    variableNames,
+    lineFunctionMap,
+    defaultFunctionName
+  ).expression;
+
+  let bindingStatement;
+  if (ts.isVariableDeclarationList(forOfStatement.initializer)) {
+    const declaration = forOfStatement.initializer.declarations[0];
+    bindingStatement = ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.updateVariableDeclarationList(forOfStatement.initializer, [
+        ts.factory.updateVariableDeclaration(
+          declaration,
+          declaration.name,
+          declaration.exclamationToken,
+          declaration.type,
+          ts.factory.createElementAccessExpression(arrayId, indexId)
+        ),
+      ])
+    );
+  } else {
+    bindingStatement = ts.factory.createExpressionStatement(
+      ts.factory.createAssignment(forOfStatement.initializer, ts.factory.createElementAccessExpression(arrayId, indexId))
+    );
+  }
+
+  return ts.factory.createBlock(
+    [
+      tracedLine,
+      ts.factory.createVariableStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(arrayId, undefined, undefined, forOfStatement.expression)],
+          ts.NodeFlags.Const
+        )
+      ),
+      ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createIdentifier('__traceRecorder'),
+            ts.factory.createIdentifier('deferPendingAccesses')
+          ),
+          undefined,
+          [ts.factory.createNumericLiteral(1)]
+        )
+      ),
+      ts.factory.createForStatement(
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(indexId, undefined, undefined, ts.factory.createNumericLiteral(0))],
+          ts.NodeFlags.Let
+        ),
+        ts.factory.createParenthesizedExpression(
+          ts.factory.createBinaryExpression(
+            tracedLineCall,
+            ts.SyntaxKind.CommaToken,
+            ts.factory.createBinaryExpression(
+              indexId,
+              ts.SyntaxKind.LessThanToken,
+              ts.factory.createPropertyAccessExpression(arrayId, 'length')
+            )
+          )
+        ),
+        ts.factory.createPostfixIncrement(indexId),
+        ts.factory.createBlock([bindingStatement, ...visitedBodyBlock.statements], true)
+      ),
+    ],
+    true
+  );
+}
+
 function instrumentStatementList(
   ts,
   sourceFile,
@@ -2530,6 +2774,42 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
         );
       }
 
+      if (ts.isWhileStatement(node)) {
+        const visited = ts.visitEachChild(node, visit, context);
+        return rewriteWhileStatementForTracing(
+          ts,
+          sourceFile,
+          visited,
+          variableNames,
+          lineFunctionMap,
+          effectiveFunctionName
+        );
+      }
+
+      if (ts.isForStatement(node)) {
+        const visited = ts.visitEachChild(node, visit, context);
+        return rewriteForStatementForTracing(
+          ts,
+          sourceFile,
+          visited,
+          variableNames,
+          lineFunctionMap,
+          effectiveFunctionName
+        );
+      }
+
+      if (ts.isForOfStatement(node)) {
+        const visited = ts.visitEachChild(node, visit, context);
+        return rewriteForOfStatementForTracing(
+          ts,
+          sourceFile,
+          visited,
+          variableNames,
+          lineFunctionMap,
+          effectiveFunctionName
+        );
+      }
+
       if (ts.isCaseClause(node)) {
         const visited = ts.visitEachChild(node, visit, context);
         return ts.factory.updateCaseClause(

package/workers/python/generated-python-harness-snippets.js

@@ -11,9 +11,9 @@
   scope.__TRACECODE_PYTHON_HARNESS__ = Object.freeze({
     PYTHON_CLASS_DEFINITIONS: "\nclass TreeNode:\n    def __init__(self, val=0, left=None, right=None):\n        self.val = val\n        self.value = val\n        self.left = left\n        self.right = right\n    def __getitem__(self, key):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))\n        if key == 'left': return self.left\n        if key == 'right': return self.right\n        raise KeyError(key)\n    def get(self, key, default=None):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))\n        if key == 'left': return self.left\n        if key == 'right': return self.right\n        return default\n    def __repr__(self):\n        return f\"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})\"\n\nclass ListNode:\n    def __init__(self, val=0, next=None):\n        self.val = val\n        self.value = val\n        self.next = next\n    def __getitem__(self, key):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))\n        if key == 'next': return self.next\n        raise KeyError(key)\n    def get(self, key, default=None):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))\n        if key == 'next': return self.next\n        return default\n    def __repr__(self):\n        return f\"ListNode({getattr(self, 'val', getattr(self, 'value', None))})\"\n",
     PYTHON_CONVERSION_HELPERS: "\ndef _ensure_node_value_aliases(node):\n    if node is None:\n        return node\n    try:\n        has_val = hasattr(node, 'val')\n        has_value = hasattr(node, 'value')\n        if has_value and not has_val:\n            try:\n                setattr(node, 'val', getattr(node, 'value'))\n            except Exception:\n                pass\n        elif has_val and not has_value:\n            try:\n                setattr(node, 'value', getattr(node, 'val'))\n            except Exception:\n                pass\n    except Exception:\n        pass\n    return node\n\ndef _dict_to_tree(d):\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = TreeNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node.left = _dict_to_tree(d.get('left'))\n    node.right = _dict_to_tree(d.get('right'))\n    return node\n\ndef _dict_to_list(d, _refs=None):\n    if _refs is None:\n        _refs = {}\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if '__ref__' in d:\n        return _refs.get(d.get('__ref__'))\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = ListNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node_id = d.get('__id__')\n    if isinstance(node_id, str) and node_id:\n        _refs[node_id] = node\n    node.next = _dict_to_list(d.get('next'), _refs)\n    return node\n",
-    PYTHON_TRACE_SERIALIZE_FUNCTION: "\n# Sentinel to mark skipped values (functions, etc.) - distinct from None\n_SKIP_SENTINEL = \"__TRACECODE_SKIP__\"\n_MAX_SERIALIZE_DEPTH = 48\n_MAX_OBJECT_FIELDS = 32\n\ndef _serialize(obj, depth=0, node_refs=None):\n    if node_refs is None:\n        node_refs = {}\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1, node_refs) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1, node_refs) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        # Use try/except for sorting to handle heterogeneous sets\n        try:\n            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])\n        except TypeError:\n            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]\n        return {\"__type__\": \"set\", \"values\": sorted_vals}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"tree-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        result = {\n            \"__type__\": \"TreeNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1, node_refs)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1, node_refs)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"list-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        result = {\n            \"__type__\": \"ListNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        result[\"next\"] = _serialize(obj.next, depth + 1, node_refs)\n        return result\n    elif hasattr(obj, '__dict__'):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"object-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\n            \"__type__\": \"object\",\n            \"__class__\": class_name,\n            \"__id__\": node_id,\n        }\n        try:\n            raw_fields = getattr(obj, '__dict__', None)\n        except Exception:\n            raw_fields = None\n        if isinstance(raw_fields, dict):\n            added = 0\n            for key, value in raw_fields.items():\n                key_str = str(key)\n                if key_str.startswith('_'):\n                    continue\n                if callable(value):\n                    continue\n                result[key_str] = _serialize(value, depth + 1, node_refs)\n                added += 1\n                if added >= _MAX_OBJECT_FIELDS:\n                    result[\"__truncated__\"] = True\n                    break\n        return result\n    elif callable(obj):\n        # Skip functions entirely - return sentinel\n        return _SKIP_SENTINEL\n    else:\n        repr_str = repr(obj)\n        # Filter out function-like representations (e.g., <function foo at 0x...>)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return _SKIP_SENTINEL\n        return repr_str\n",
-    PYTHON_EXECUTE_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        try:\n            return {\"__type__\": \"set\", \"values\": sorted([_serialize(x, depth + 1) for x in obj])}\n        except TypeError:\n            return {\"__type__\": \"set\", \"values\": [_serialize(x, depth + 1) for x in obj]}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    elif callable(obj):\n        return None\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
-    PYTHON_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        try:\n            return {\"__type__\": \"set\", \"values\": sorted([_serialize(x, depth + 1) for x in obj])}\n        except TypeError:\n            return {\"__type__\": \"set\", \"values\": [_serialize(x, depth + 1) for x in obj]}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    elif callable(obj):\n        return None\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
+    PYTHON_TRACE_SERIALIZE_FUNCTION: "\n# Sentinel to mark skipped values (functions, etc.) - distinct from None\n_SKIP_SENTINEL = \"__TRACECODE_SKIP__\"\n_MAX_SERIALIZE_DEPTH = 48\n_MAX_OBJECT_FIELDS = 32\n\ndef _serialize(obj, depth=0, node_refs=None):\n    if node_refs is None:\n        node_refs = {}\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1, node_refs) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1, node_refs) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        # Use try/except for sorting to handle heterogeneous sets\n        try:\n            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])\n        except TypeError:\n            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]\n        return {\"__type__\": \"set\", \"values\": sorted_vals}\n    elif isinstance(obj, TreeNode):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"tree-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        result = {\n            \"__type__\": \"TreeNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1, node_refs)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1, node_refs)\n        return result\n    elif isinstance(obj, ListNode):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"list-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        result = {\n            \"__type__\": \"ListNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        result[\"next\"] = _serialize(obj.next, depth + 1, node_refs)\n        return result\n    elif hasattr(obj, '__dict__'):\n        obj_ref = id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = f\"object-{obj_ref}\"\n        node_refs[obj_ref] = node_id\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\n            \"__type__\": \"object\",\n            \"__class__\": class_name,\n            \"__id__\": node_id,\n        }\n        try:\n            raw_fields = getattr(obj, '__dict__', None)\n        except Exception:\n            raw_fields = None\n        if isinstance(raw_fields, dict):\n            added = 0\n            for key, value in raw_fields.items():\n                key_str = str(key)\n                if key_str.startswith('_'):\n                    continue\n                if callable(value):\n                    continue\n                result[key_str] = _serialize(value, depth + 1, node_refs)\n                added += 1\n                if added >= _MAX_OBJECT_FIELDS:\n                    result[\"__truncated__\"] = True\n                    break\n        return result\n    elif callable(obj):\n        # Skip functions entirely - return sentinel\n        return _SKIP_SENTINEL\n    else:\n        repr_str = repr(obj)\n        # Filter out function-like representations (e.g., <function foo at 0x...>)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return _SKIP_SENTINEL\n        return repr_str\n",
+    PYTHON_EXECUTE_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        try:\n            return {\"__type__\": \"set\", \"values\": sorted([_serialize(x, depth + 1) for x in obj])}\n        except TypeError:\n            return {\"__type__\": \"set\", \"values\": [_serialize(x, depth + 1) for x in obj]}\n    elif isinstance(obj, TreeNode):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1)\n        return result\n    elif isinstance(obj, ListNode):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    elif callable(obj):\n        return None\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
+    PYTHON_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize(x, depth + 1) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        try:\n            return {\"__type__\": \"set\", \"values\": sorted([_serialize(x, depth + 1) for x in obj])}\n        except TypeError:\n            return {\"__type__\": \"set\", \"values\": [_serialize(x, depth + 1) for x in obj]}\n    elif isinstance(obj, TreeNode):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1)\n        return result\n    elif isinstance(obj, ListNode):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    elif callable(obj):\n        return None\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
   });
 
   scope.__TRACECODE_toPythonLiteral = __tracecodeToPythonLiteral;