@tracecode/harness 0.6.6 → 0.7.0-beta8

package/workers/javascript/javascript-worker.js

@@ -14,6 +14,20 @@ const WORKER_DEBUG = (() => {
   }
 })();
 
+function emitRuntimeDiagnostic(level, phase, message, detail) {
+  if (!WORKER_DEBUG && level !== 'error') return;
+  const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : level === 'debug' ? 'debug' : 'info';
+  console[method]('[TraceRuntime]', {
+    schema: 'tracecode.runtime-diagnostic.v1',
+    source: 'harness',
+    component: 'JavaScriptWorker',
+    runtime: 'javascript',
+    phase,
+    message,
+    ...(detail === undefined ? {} : { detail }),
+  });
+}
+
 let isInitialized = false;
 let isLoading = false;
 let typeScriptLoadPromise = null;
@@ -28,12 +42,23 @@ const TYPESCRIPT_COMPILER_URLS = [
   'https://cdn.jsdelivr.net/npm/typescript@5.9.2/lib/typescript.js',
   'https://unpkg.com/typescript@5.9.2/lib/typescript.js',
 ];
+const JAVASCRIPT_LIBRARY_URLS = [
+  './vendor/javascript-libraries.js',
+];
+let javascriptLibrariesLoadAttempted = false;
 
 const JAVASCRIPT_RUNTIME_PRELUDE = `
+if (typeof globalThis.module === 'undefined') {
+  globalThis.module = { exports: {} };
+}
+if (typeof globalThis.exports === 'undefined') {
+  globalThis.exports = globalThis.module.exports || {};
+}
 if (typeof globalThis.ListNode !== 'function') {
   globalThis.ListNode = class ListNode {
     constructor(val = 0, next = null) {
       this.val = val;
+      this.value = val;
       this.next = next;
     }
   };
@@ -42,6 +67,7 @@ if (typeof globalThis.TreeNode !== 'function') {
   globalThis.TreeNode = class TreeNode {
     constructor(val = 0, left = null, right = null) {
       this.val = val;
+      this.value = val;
       this.left = left;
       this.right = right;
     }
@@ -49,9 +75,45 @@ if (typeof globalThis.TreeNode !== 'function') {
 }
 `;
 
+function ensureJavaScriptLibraries() {
+  if (
+    typeof globalThis !== 'undefined' &&
+    globalThis.__TRACECODE_JAVASCRIPT_LIBRARIES__ &&
+    typeof globalThis.require === 'function'
+  ) {
+    return;
+  }
+  if (javascriptLibrariesLoadAttempted) return;
+  javascriptLibrariesLoadAttempted = true;
+  if (typeof importScripts !== 'function') return;
+
+  const errors = [];
+  for (const libraryUrl of JAVASCRIPT_LIBRARY_URLS) {
+    try {
+      importScripts(libraryUrl);
+      if (
+        typeof globalThis !== 'undefined' &&
+        globalThis.__TRACECODE_JAVASCRIPT_LIBRARIES__ &&
+        typeof globalThis.require === 'function'
+      ) {
+        return;
+      }
+      errors.push(`${libraryUrl} (loaded but module registry was missing)`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${libraryUrl} (${message})`);
+    }
+  }
+
+  if (errors.length > 0) {
+    emitRuntimeDiagnostic('warn', 'library-preload-skipped', 'JavaScript library preload skipped.', { errors });
+  }
+}
+
 const TYPESCRIPT_RUNTIME_DECLARATIONS = `
 declare class ListNode {
   val: any;
+  value: any;
   next: ListNode | SerializedListNode | SerializedRef | null;
   prev?: ListNode | SerializedListNode | SerializedRef | null;
   constructor(val?: any, next?: ListNode | null);
@@ -59,6 +121,7 @@ declare class ListNode {
 
 declare class TreeNode {
   val: any;
+  value: any;
   left: TreeNode | SerializedTreeNode | SerializedRef | null;
   right: TreeNode | SerializedTreeNode | SerializedRef | null;
   constructor(val?: any, left?: TreeNode | null, right?: TreeNode | null);
@@ -70,6 +133,7 @@ type SerializedListNode = {
   __id__?: string;
   __type__?: 'ListNode';
   val?: any;
+  value?: any;
   next?: SerializedListNode | SerializedRef | ListNode | null;
   prev?: SerializedListNode | SerializedRef | ListNode | null;
 };
@@ -78,11 +142,48 @@ type SerializedTreeNode = {
   __id__?: string;
   __type__?: 'TreeNode';
   val?: any;
+  value?: any;
   left?: SerializedTreeNode | SerializedRef | TreeNode | null;
   right?: SerializedTreeNode | SerializedRef | TreeNode | null;
 };
 `;
 
+const CUSTOM_OBJECT_MATERIALIZER_SOURCE = `
+function __tracecodeMaterializeCustomObject(value) {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) return value.map((item) => __tracecodeMaterializeCustomObject(item));
+  if (typeof value !== 'object') return value;
+  if (value.__type__ === 'TreeNode' || value.__type__ === 'ListNode' || value.__ref__) return value;
+  const __typeName = typeof value.__type__ === 'string'
+    ? value.__type__
+    : (typeof value.__class__ === 'string' ? value.__class__ : null);
+  if (!__typeName) return value;
+  const __fields = { __type__: __typeName };
+  if (typeof value.__class__ === 'string') __fields.__class__ = value.__class__;
+  for (const [__key, __child] of Object.entries(value)) {
+    if (__key === '__type__' || __key === '__class__' || __key === '__id__') continue;
+    __fields[__key] = __tracecodeMaterializeCustomObject(__child);
+  }
+  let __ctor;
+  try {
+    __ctor = eval(__typeName);
+  } catch (_err) {
+    __ctor = undefined;
+  }
+  if (typeof __ctor !== 'function') return __fields;
+  const __args = Object.entries(__fields)
+    .filter(([__key]) => __key !== '__type__' && __key !== '__class__')
+    .map(([, __value]) => __value);
+  try {
+    return new __ctor(...__args);
+  } catch (_err) {
+    const __instance = Object.create(__ctor.prototype);
+    Object.assign(__instance, __fields);
+    return __instance;
+  }
+}
+`;
+
 function performanceNow() {
   if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
     return performance.now();
@@ -139,17 +240,41 @@ function getCustomClassName(value) {
   return name;
 }
 
+const RUNTIME_VALUE_MAX_DEPTH = 48;
+const RUNTIME_VALUE_MAX_ITEMS = 64;
+const RUNTIME_VALUE_MAX_OBJECT_FIELDS = 32;
+const TRACE_SERIALIZATION_LIMITS = { maxItems: RUNTIME_VALUE_MAX_ITEMS, maxFields: RUNTIME_VALUE_MAX_OBJECT_FIELDS };
+const OUTPUT_SERIALIZATION_LIMITS = { maxItems: Number.POSITIVE_INFINITY, maxFields: Number.POSITIVE_INFINITY };
+let activeSerializationLimits = TRACE_SERIALIZATION_LIMITS;
+
+function truncationMarker(total, emitted) {
+  return { __truncated__: true, remaining: Math.max(0, total - emitted) };
+}
+
+function limitedEntries(items, maxItems) {
+  return {
+    values: items.slice(0, maxItems),
+    remaining: Math.max(0, items.length - maxItems),
+  };
+}
+
 function serializeValue(
   value,
   depth = 0,
   seen = new WeakSet(),
   nodeRefState = { ids: new Map(), nextId: 1 }
 ) {
-  if (depth > 48) return '<max depth>';
+  if (depth > RUNTIME_VALUE_MAX_DEPTH) return '<max depth>';
   if (value === null || value === undefined) return value;
 
   const valueType = typeof value;
-  if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+  if (valueType === 'number') {
+    if (Number.isNaN(value)) return 'NaN';
+    if (value === Infinity) return 'Infinity';
+    if (value === -Infinity) return '-Infinity';
+    return value;
+  }
+  if (valueType === 'string' || valueType === 'boolean') {
     return value;
   }
   if (valueType === 'bigint') {
@@ -159,22 +284,39 @@ function serializeValue(
     return '<function>';
   }
   if (Array.isArray(value)) {
-    return value.map((item) => serializeValue(item, depth + 1, seen, nodeRefState));
+    const limited = limitedEntries(value, activeSerializationLimits.maxItems);
+    const result = limited.values.map((item) => serializeValue(item, depth + 1, seen, nodeRefState));
+    if (limited.remaining > 0) result.push(truncationMarker(value.length, limited.values.length));
+    return result;
   }
   if (value instanceof Set) {
-    return {
+    const items = [...value];
+    const limited = limitedEntries(items, activeSerializationLimits.maxItems);
+    const result = {
       __type__: 'set',
-      values: [...value].map((item) => serializeValue(item, depth + 1, seen, nodeRefState)),
+      values: limited.values.map((item) => serializeValue(item, depth + 1, seen, nodeRefState)),
     };
+    if (limited.remaining > 0) {
+      result.__truncated__ = true;
+      result.remaining = limited.remaining;
+    }
+    return result;
   }
   if (value instanceof Map) {
-    return {
+    const entries = [...value.entries()];
+    const limited = limitedEntries(entries, activeSerializationLimits.maxItems);
+    const result = {
       __type__: 'map',
-      entries: [...value.entries()].map(([k, v]) => [
+      entries: limited.values.map(([k, v]) => [
         serializeValue(k, depth + 1, seen, nodeRefState),
         serializeValue(v, depth + 1, seen, nodeRefState),
       ]),
     };
+    if (limited.remaining > 0) {
+      result.__truncated__ = true;
+      result.remaining = limited.remaining;
+    }
+    return result;
   }
   if (valueType === 'object') {
     if (isLikelyTreeNodeValue(value) || isLikelyListNodeValue(value)) {
@@ -182,12 +324,12 @@ function serializeValue(
       if (existingId) {
         return { __ref__: existingId };
       }
-      const nodePrefix = isLikelyTreeNodeValue(value) ? 'tree' : 'list';
-      const nodeId = `${nodePrefix}-${nodeRefState.nextId++}`;
+      const isTree = isLikelyTreeNodeValue(value);
+      const nodeId = `ref-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(value, nodeId);
 
       const out =
-        nodePrefix === 'tree'
+        isTree
           ? {
               __type__: 'TreeNode',
               __id__: nodeId,
@@ -205,13 +347,17 @@ function serializeValue(
                 : {}),
             };
       const skipped =
-        nodePrefix === 'tree'
+        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(value)) {
-        if (skipped.has(k)) continue;
+      const fields = Object.entries(value).filter(([k]) => !skipped.has(k));
+      for (const [k, v] of fields.slice(0, activeSerializationLimits.maxFields)) {
         out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
       }
+      if (fields.length > activeSerializationLimits.maxFields) {
+        out.__truncated__ = true;
+        out.remaining = fields.length - activeSerializationLimits.maxFields;
+      }
       return out;
     }
 
@@ -222,19 +368,24 @@ function serializeValue(
         return { __ref__: existingId };
       }
 
-      const objectId = `object-${nodeRefState.nextId++}`;
+      const objectId = `ref-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(value, objectId);
 
       if (seen.has(value)) return { __ref__: objectId };
       seen.add(value);
       const out = {
-        __type__: 'object',
+        __type__: customClassName,
         __class__: customClassName,
         __id__: objectId,
       };
-      for (const [k, v] of Object.entries(value)) {
+      const fields = Object.entries(value);
+      for (const [k, v] of fields.slice(0, activeSerializationLimits.maxFields)) {
         out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
       }
+      if (fields.length > activeSerializationLimits.maxFields) {
+        out.__truncated__ = true;
+        out.remaining = fields.length - activeSerializationLimits.maxFields;
+      }
       seen.delete(value);
       return out;
     }
@@ -242,9 +393,14 @@ function serializeValue(
     if (seen.has(value)) return '<cycle>';
     seen.add(value);
     const out = {};
-    for (const [k, v] of Object.entries(value)) {
+    const fields = Object.entries(value);
+    for (const [k, v] of fields.slice(0, activeSerializationLimits.maxFields)) {
       out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
     }
+    if (fields.length > activeSerializationLimits.maxFields) {
+      out.__truncated__ = true;
+      out.remaining = fields.length - activeSerializationLimits.maxFields;
+    }
     seen.delete(value);
     return out;
   }
@@ -252,6 +408,20 @@ function serializeValue(
   return String(value);
 }
 
+function withSerializationLimits(limits, serialize) {
+  const previous = activeSerializationLimits;
+  activeSerializationLimits = limits;
+  try {
+    return serialize();
+  } finally {
+    activeSerializationLimits = previous;
+  }
+}
+
+function serializeOutputValue(value) {
+  return withSerializationLimits(OUTPUT_SERIALIZATION_LIMITS, () => serializeValue(value));
+}
+
 function serializeTopLevelValue(value, nodeRefState) {
   if (value === null || value === undefined) return value;
   if (typeof value !== 'object' || Array.isArray(value)) {
@@ -264,7 +434,7 @@ function serializeTopLevelValue(value, nodeRefState) {
     const isTree = isLikelyTreeNodeValue(value);
     let nodeId = nodeRefState.ids.get(objectValue);
     if (!nodeId) {
-      nodeId = `${isTree ? 'tree' : 'list'}-${nodeRefState.nextId++}`;
+      nodeId = `ref-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(objectValue, nodeId);
     }
 
@@ -289,10 +459,14 @@ function serializeTopLevelValue(value, 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;
+    const fields = Object.entries(nodeValue).filter(([k]) => !skipped.has(k));
+    for (const [k, v] of fields.slice(0, activeSerializationLimits.maxFields)) {
       out[k] = serializeValue(v, 1, new WeakSet(), nodeRefState);
     }
+    if (fields.length > activeSerializationLimits.maxFields) {
+      out.__truncated__ = true;
+      out.remaining = fields.length - activeSerializationLimits.maxFields;
+    }
     return out;
   }
 
@@ -301,7 +475,7 @@ function serializeTopLevelValue(value, nodeRefState) {
     const objectValue = value;
     let objectId = nodeRefState.ids.get(objectValue);
     if (!objectId) {
-      objectId = `object-${nodeRefState.nextId++}`;
+      objectId = `ref-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(objectValue, objectId);
     }
     const seen = new WeakSet();
@@ -311,9 +485,14 @@ function serializeTopLevelValue(value, nodeRefState) {
       __class__: customClassName,
       __id__: objectId,
     };
-    for (const [k, v] of Object.entries(value)) {
+    const fields = Object.entries(value);
+    for (const [k, v] of fields.slice(0, activeSerializationLimits.maxFields)) {
       out[k] = serializeValue(v, 1, seen, nodeRefState);
     }
+    if (fields.length > activeSerializationLimits.maxFields) {
+      out.__truncated__ = true;
+      out.remaining = fields.length - activeSerializationLimits.maxFields;
+    }
     return out;
   }
 
@@ -398,16 +577,45 @@ function resolveReferenceGraph(value, byId, resolved) {
   return out;
 }
 
+function cloneInputGraph(value, cloned = new WeakMap()) {
+  if (value === null || value === undefined) return value;
+  if (typeof value !== 'object') return value;
+
+  if (cloned.has(value)) {
+    return cloned.get(value);
+  }
+
+  if (Array.isArray(value)) {
+    const out = [];
+    cloned.set(value, out);
+    for (const item of value) {
+      out.push(cloneInputGraph(item, cloned));
+    }
+    return out;
+  }
+
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+
+  const out = {};
+  cloned.set(value, out);
+  for (const [key, nested] of Object.entries(value)) {
+    out[key] = cloneInputGraph(nested, cloned);
+  }
+  return out;
+}
+
 function normalizeInputs(inputs) {
   if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) return {};
   const byId = new Map();
   collectReferenceTargets(inputs, byId, new WeakSet());
   if (byId.size === 0) {
-    return inputs;
+    return cloneInputGraph(inputs);
   }
   const hydrated = resolveReferenceGraph(inputs, byId, new WeakMap());
   if (!hydrated || typeof hydrated !== 'object' || Array.isArray(hydrated)) {
-    return inputs;
+    return cloneInputGraph(inputs);
   }
   return hydrated;
 }
@@ -675,12 +883,168 @@ function findFunctionLikeNode(ts, sourceFile, functionName, executionStyle) {
   return found;
 }
 
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function stripJavaScriptTriviaForSignatureScan(code) {
+  let output = '';
+  let i = 0;
+
+  while (i < code.length) {
+    const current = code[i];
+    const next = code[i + 1];
+
+    if (current === '/' && next === '/') {
+      output += '  ';
+      i += 2;
+      while (i < code.length && code[i] !== '\n') {
+        output += ' ';
+        i += 1;
+      }
+      continue;
+    }
+
+    if (current === '/' && next === '*') {
+      output += '  ';
+      i += 2;
+      while (i < code.length) {
+        if (code[i] === '*' && code[i + 1] === '/') {
+          output += '  ';
+          i += 2;
+          break;
+        }
+        output += code[i] === '\n' ? '\n' : ' ';
+        i += 1;
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'" || current === '`') {
+      const quote = current;
+      output += quote;
+      i += 1;
+      while (i < code.length) {
+        const char = code[i];
+        if (char === '\\') {
+          output += ' ';
+          if (i + 1 < code.length) output += code[i + 1] === '\n' ? '\n' : ' ';
+          i += 2;
+          continue;
+        }
+        output += char === '\n' ? '\n' : ' ';
+        i += 1;
+        if (char === quote) break;
+      }
+      continue;
+    }
+
+    output += current;
+    i += 1;
+  }
+
+  return output;
+}
+
+function findMatchingBraceIndex(code, openBraceIndex) {
+  let depth = 0;
+  for (let i = openBraceIndex; i < code.length; i += 1) {
+    const char = code[i];
+    if (char === '{') {
+      depth += 1;
+    } else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function extractClassBodyForSignatureScan(code, className) {
+  const classMatch = new RegExp(`\\bclass\\s+${escapeRegExp(className)}\\b[^{}]*\\{`, 'm').exec(code);
+  if (!classMatch) return null;
+  const openBraceIndex = classMatch.index + classMatch[0].lastIndexOf('{');
+  const closeBraceIndex = findMatchingBraceIndex(code, openBraceIndex);
+  if (closeBraceIndex < 0) return null;
+  return code.slice(openBraceIndex + 1, closeBraceIndex);
+}
+
+function parseSimpleJavaScriptParameterNames(parameterText) {
+  const names = [];
+  const rawParameters = String(parameterText ?? '').split(',');
+
+  for (const rawParameter of rawParameters) {
+    const trimmed = rawParameter.trim();
+    if (!trimmed) continue;
+    const withoutDefault = trimmed.split('=')[0].trim();
+    const name = withoutDefault.startsWith('...') ? withoutDefault.slice(3).trim() : withoutDefault;
+    if (name === 'this') continue;
+    if (!/^[A-Za-z_$][\w$]*$/.test(name)) {
+      return null;
+    }
+    names.push(name);
+  }
+
+  return names;
+}
+
+function extractSimpleJavaScriptParameterNames(code, functionName, executionStyle) {
+  const strippedCode = stripJavaScriptTriviaForSignatureScan(code);
+  const escapedName = escapeRegExp(functionName);
+  const exportPrefix = String.raw`(?:export\s+default\s+|export\s+)?`;
+  const functionPatterns = [
+    new RegExp(String.raw`(?:^|[^\w$])${exportPrefix}(?:async\s+)?function\s+${escapedName}\s*\(([^)]*)\)`, 'm'),
+    new RegExp(String.raw`(?:^|[^\w$])${exportPrefix}(?:const|let|var)\s+${escapedName}\s*=\s*(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\(([^)]*)\)`, 'm'),
+    new RegExp(String.raw`(?:^|[^\w$])${exportPrefix}(?:const|let|var)\s+${escapedName}\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>`, 'm'),
+    new RegExp(String.raw`(?:^|[^\w$])${exportPrefix}(?:const|let|var)\s+${escapedName}\s*=\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>`, 'm'),
+  ];
+  const methodBody =
+    executionStyle === 'solution-method'
+      ? extractClassBodyForSignatureScan(strippedCode, 'Solution') ?? strippedCode
+      : strippedCode;
+  const methodPatterns = [
+    new RegExp(String.raw`(?:^|[;{}\s])(?:async\s+)?${escapedName}\s*\(([^)]*)\)\s*\{`, 'm'),
+    new RegExp(String.raw`(?:^|[;{}\s])${escapedName}\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>`, 'm'),
+    new RegExp(String.raw`(?:^|[;{}\s])${escapedName}\s*=\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>`, 'm'),
+    new RegExp(String.raw`(?:^|[;{}\s])${escapedName}\s*=\s*(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\(([^)]*)\)`, 'm'),
+  ];
+  const patterns = executionStyle === 'solution-method' ? methodPatterns : functionPatterns;
+  const scanCode = executionStyle === 'solution-method' ? methodBody : strippedCode;
+
+  for (const pattern of patterns) {
+    const match = pattern.exec(scanCode);
+    if (!match) continue;
+    return parseSimpleJavaScriptParameterNames(match[1] ?? '');
+  }
+
+  return null;
+}
+
+function orderInputKeysByParameterNames(parameterNames, inputs, fallbackKeys) {
+  if (!parameterNames || parameterNames.length === 0) {
+    return fallbackKeys;
+  }
+
+  const matchedKeys = parameterNames.filter((name) => Object.prototype.hasOwnProperty.call(inputs, name));
+  if (matchedKeys.length === 0) {
+    return fallbackKeys;
+  }
+
+  const extras = fallbackKeys.filter((key) => !matchedKeys.includes(key));
+  return [...matchedKeys, ...extras];
+}
+
 async function resolveOrderedInputKeys(code, functionName, inputs, executionStyle, language = 'javascript') {
   const fallbackKeys = Object.keys(inputs ?? {});
   if (!functionName || executionStyle === 'ops-class' || fallbackKeys.length <= 1) {
     return fallbackKeys;
   }
 
+  if (language !== 'typescript') {
+    const parameterNames = extractSimpleJavaScriptParameterNames(code, functionName, executionStyle);
+    return orderInputKeysByParameterNames(parameterNames, inputs, fallbackKeys);
+  }
+
   try {
     await ensureTypeScriptCompiler();
     const ts = getTypeScriptCompiler();
@@ -701,17 +1065,7 @@ async function resolveOrderedInputKeys(code, functionName, inputs, executionStyl
     }
 
     const parameterNames = collectSimpleParameterNames(ts, target);
-    if (!parameterNames || parameterNames.length === 0) {
-      return fallbackKeys;
-    }
-
-    const matchedKeys = parameterNames.filter((name) => Object.prototype.hasOwnProperty.call(inputs, name));
-    if (matchedKeys.length === 0) {
-      return fallbackKeys;
-    }
-
-    const extras = fallbackKeys.filter((key) => !matchedKeys.includes(key));
-    return [...matchedKeys, ...extras];
+    return orderInputKeysByParameterNames(parameterNames, inputs, fallbackKeys);
   } catch (_error) {
     return fallbackKeys;
   }
@@ -759,22 +1113,30 @@ function getNumericOption(value, fallback) {
   return Math.floor(value);
 }
 
-function isTraceableIntegerIndex(value) {
-  return typeof value === 'number' && Number.isInteger(value);
+function isTraceablePathSegment(value) {
+  return (typeof value === 'number' && Number.isInteger(value)) ||
+    (typeof value === 'string' && value.length > 0);
 }
 
 function normalizeTraceIndices(indices, maxDepth = 2) {
   if (!Array.isArray(indices) || indices.length === 0 || indices.length > maxDepth) {
     return null;
   }
-  if (!indices.every(isTraceableIntegerIndex)) {
+  if (!indices.every(isTraceablePathSegment)) {
+    return null;
+  }
+  return indices.map((index) => typeof index === 'number' ? Math.trunc(index) : index);
+}
+
+function normalizeTraceIndexSources(indexSources, maxDepth = 2) {
+  if (!Array.isArray(indexSources) || indexSources.length === 0 || indexSources.length > maxDepth) {
     return null;
   }
-  return indices.map((index) => Math.trunc(index));
+  return indexSources.map((source) => typeof source === 'string' && source.length > 0 ? source : null);
 }
 
 function isTraceableMutatingMethod(methodName) {
-  return ['push', 'pop', 'shift', 'unshift', 'splice'].includes(methodName);
+  return ['push', 'pop', 'shift', 'unshift', 'splice', 'set', 'get', 'has', 'add', 'delete', 'clear'].includes(methodName);
 }
 
 function readValueAtIndices(container, indices) {
@@ -809,14 +1171,17 @@ function writeValueAtIndices(container, indices, value) {
 
 function createTraceRecorder(options = {}) {
   const trace = [];
+  const runtimeTraceEvents = [];
   const callStack = [];
   const pendingAccessesByFrame = new Map();
   const deferredAccessesByFrame = new Map();
+  const runtimeTraceAccessStatsByVariable = 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 effectiveMaxRuntimeTraceEvents = maxStoredEvents;
   const maxLineEvents = getNumericOption(options.maxLineEvents, 12000);
   const maxSingleLineHits = getNumericOption(options.maxSingleLineHits, 1000);
   const maxCallDepth = getNumericOption(options.maxCallDepth, 2000);
@@ -827,6 +1192,27 @@ function createTraceRecorder(options = {}) {
   let timeoutRecorded = false;
   let nextFrameId = 1;
 
+  function markTraceCaptureLimit(lineNumber, functionName) {
+    if (!traceLimitExceeded) {
+      traceLimitExceeded = true;
+      timeoutReason = 'trace-limit';
+    }
+    pendingAccessesByFrame.clear();
+    deferredAccessesByFrame.clear();
+    if (!timeoutRecorded && trace.length < effectiveMaxTraceSteps && runtimeTraceEvents.length < effectiveMaxRuntimeTraceEvents) {
+      const timeoutStep = {
+        line: normalizeLine(lineNumber, 1),
+        event: 'timeout',
+        variables: { timeoutReason: 'trace-limit' },
+        function: functionName ?? callStack[callStack.length - 1]?.function ?? '<module>',
+        callStack: snapshotCallStack(),
+      };
+      timeoutRecorded = true;
+      trace.push(timeoutStep);
+      appendRuntimeTraceEventsForStep(timeoutStep);
+    }
+  }
+
   function normalizeLine(lineNumber, fallback = 1) {
     const parsed = Number(lineNumber);
     if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
@@ -835,6 +1221,7 @@ function createTraceRecorder(options = {}) {
 
   function snapshotCallStack() {
     return callStack.map((frame) => ({
+      id: frame.id,
       function: frame.function,
       args: frame.args,
       line: frame.line,
@@ -848,11 +1235,7 @@ function createTraceRecorder(options = {}) {
       if (variableValue === undefined) continue;
       if (typeof variableValue === 'function') continue;
       try {
-        const refState =
-          key === 'this' && variableValue && typeof variableValue === 'object'
-            ? { ids: new Map(), nextId: 1 }
-            : stableNodeRefState;
-        result[key] = serializeTopLevelValue(variableValue, refState);
+        result[key] = serializeTopLevelValue(variableValue, stableNodeRefState);
       } catch {
         // Skip variables that throw during serialization (e.g. transient proxy/getter failures).
       }
@@ -860,6 +1243,24 @@ function createTraceRecorder(options = {}) {
     return result;
   }
 
+  function sanitizeCallArgs(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+    const result = {};
+    for (const [key, variableValue] of Object.entries(value)) {
+      if (typeof variableValue === 'function') continue;
+      if (variableValue === undefined) {
+        result[key] = '<undefined>';
+        continue;
+      }
+      try {
+        result[key] = serializeTopLevelValue(variableValue, stableNodeRefState);
+      } catch {
+        result[key] = '<unserializable>';
+      }
+    }
+    return result;
+  }
+
   function isLikelyTreeObject(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');
@@ -916,178 +1317,6 @@ function createTraceRecorder(options = {}) {
     return true;
   }
 
-  function shouldVisualizeObjectAsHashMap(name, value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-    if (isLikelyTreeObject(value) || isLikelyLinkedListObject(value)) return false;
-    if (value.__type__ === 'object') return false;
-    if (Object.keys(value).length === 1 && typeof value.__ref__ === 'string') return false;
-    if (isLikelyAdjacencyListObject(value)) return false;
-
-    const lowerName = String(name).toLowerCase();
-    if (lowerName.includes('map') || lowerName.includes('seen') || lowerName.includes('dict')) {
-      return true;
-    }
-    return Object.keys(value).length > 0;
-  }
-
-  function collectRuntimeVisualizations(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-      return { hashMaps: [], objectKinds: {} };
-    }
-
-    const visualizations = [];
-    const objectKinds = {};
-    for (const [name, variableValue] of Object.entries(value)) {
-      if (variableValue === undefined) continue;
-
-      if (variableValue instanceof Map) {
-        objectKinds[name] = 'map';
-        visualizations.push({
-          name,
-          kind: 'map',
-          entries: [...variableValue.entries()].map(([key, mapValue]) => ({
-            key: serializeValue(key),
-            value: serializeValue(mapValue),
-          })),
-        });
-        continue;
-      }
-
-      if (variableValue instanceof Set) {
-        objectKinds[name] = 'set';
-        visualizations.push({
-          name,
-          kind: 'set',
-          entries: [...variableValue.values()].map((item) => ({
-            key: serializeValue(item),
-            value: true,
-          })),
-        });
-        continue;
-      }
-
-      if (isLikelyIndexedAdjacencyListArray(variableValue)) {
-        objectKinds[name] = 'graph-adjacency';
-        continue;
-      }
-
-      if (variableValue && typeof variableValue === 'object' && !Array.isArray(variableValue)) {
-        const customClassName = getCustomClassName(variableValue);
-        if (customClassName) {
-          const serializedObject = serializeValue(variableValue);
-          objectKinds[name] = 'object';
-          visualizations.push({
-            name,
-            kind: 'object',
-            objectClassName: customClassName,
-            objectId:
-              serializedObject && typeof serializedObject === 'object' && typeof serializedObject.__id__ === 'string'
-                ? serializedObject.__id__
-                : undefined,
-            entries: Object.entries(serializedObject)
-              .filter(([key]) => key !== '__type__' && key !== '__class__' && key !== '__id__')
-              .map(([key, entryValue]) => ({
-                key,
-                value: entryValue,
-              })),
-          });
-          continue;
-        }
-
-        const serializedValue = variableValue;
-
-        if (serializedValue.__type__ === 'object') {
-          objectKinds[name] = 'object';
-          visualizations.push({
-            name,
-            kind: 'object',
-            objectClassName:
-              typeof serializedValue.__class__ === 'string' && serializedValue.__class__.length > 0
-                ? serializedValue.__class__
-                : undefined,
-            objectId:
-              typeof serializedValue.__id__ === 'string' && serializedValue.__id__.length > 0
-                ? serializedValue.__id__
-                : undefined,
-            entries: Object.entries(serializedValue)
-              .filter(([key]) => key !== '__type__' && key !== '__class__' && key !== '__id__')
-              .map(([key, entryValue]) => ({
-                key,
-                value: entryValue,
-              })),
-          });
-          continue;
-        }
-
-        if (serializedValue.__type__ === 'map' && Array.isArray(serializedValue.entries)) {
-          objectKinds[name] = 'map';
-          visualizations.push({
-            name,
-            kind: 'map',
-            entries: serializedValue.entries
-              .filter((entry) => Array.isArray(entry) && entry.length >= 2)
-              .map((entry) => ({
-                key: entry[0],
-                value: entry[1],
-              })),
-          });
-          continue;
-        }
-
-        if (serializedValue.__type__ === 'set' && Array.isArray(serializedValue.values)) {
-          objectKinds[name] = 'set';
-          visualizations.push({
-            name,
-            kind: 'set',
-            entries: serializedValue.values.map((item) => ({
-              key: item,
-              value: true,
-            })),
-          });
-          continue;
-        }
-
-        if (isLikelyTreeObject(serializedValue)) {
-          objectKinds[name] = 'tree';
-          continue;
-        }
-
-        if (isLikelyLinkedListObject(serializedValue)) {
-          objectKinds[name] = 'linked-list';
-          continue;
-        }
-
-        if (isLikelyAdjacencyListObject(serializedValue)) {
-          objectKinds[name] = 'graph-adjacency';
-          continue;
-        }
-
-        if (shouldVisualizeObjectAsHashMap(name, serializedValue)) {
-          objectKinds[name] = 'hashmap';
-          visualizations.push({
-            name,
-            kind: 'hashmap',
-            entries: Object.entries(serializedValue).map(([key, entryValue]) => ({
-              key,
-              value: serializeValue(entryValue),
-            })),
-          });
-        }
-      }
-    }
-
-    return { hashMaps: visualizations, objectKinds };
-  }
-
-  function buildVisualizationPayload(value) {
-    const { hashMaps, objectKinds } = collectRuntimeVisualizations(value);
-    if (hashMaps.length === 0 && Object.keys(objectKinds).length === 0) return undefined;
-    return {
-      ...(hashMaps.length > 0 ? { hashMaps } : {}),
-      ...(Object.keys(objectKinds).length > 0 ? { objectKinds } : {}),
-    };
-  }
-
   function createLimitError(reason, lineNumber, message) {
     const error = new Error(message);
     error.__traceLimitExceeded = true;
@@ -1135,29 +1364,27 @@ function createTraceRecorder(options = {}) {
       ...(Array.isArray(access.indices) && access.indices.length > 0
         ? { indices: access.indices }
         : {}),
+      ...(Array.isArray(access.indexSources) && access.indexSources.length > 0
+        ? { indexSources: access.indexSources }
+        : {}),
       ...(access.method ? { method: access.method } : {}),
+      ...(Array.isArray(access.args) ? { args: access.args } : {}),
       ...(access.pathDepth ? { pathDepth: access.pathDepth } : {}),
+      ...(access.scope ? { scope: access.scope } : {}),
+      ...(access.binding ? { binding: access.binding } : {}),
+      ...(Number.isFinite(access.line) && access.line > 0 ? { line: access.line } : {}),
+      ...(Number.isFinite(access.column) && access.column >= 0 ? { column: access.column } : {}),
+      ...(Object.prototype.hasOwnProperty.call(access, 'value') ? { value: access.value } : {}),
     }));
   }
 
   function appendTrace(step, frameId = getCurrentFrameId()) {
+    if (traceLimitExceeded) {
+      return;
+    }
     if (trace.length >= effectiveMaxTraceSteps) {
-      const lineNumber = normalizeLine(step?.line, 1);
-      if (!traceLimitExceeded) {
-        traceLimitExceeded = true;
-        timeoutReason = 'trace-limit';
-      }
-      if (!timeoutRecorded && trace.length < effectiveMaxTraceSteps) {
-        trace.push({
-          line: lineNumber,
-          event: 'timeout',
-          variables: {},
-          function: step?.function ?? callStack[callStack.length - 1]?.function ?? '<module>',
-          callStack: snapshotCallStack(),
-        });
-        timeoutRecorded = true;
-      }
-      throw createLimitError('trace-limit', lineNumber, `Exceeded ${effectiveMaxTraceSteps} trace steps`);
+      markTraceCaptureLimit(step?.line, step?.function);
+      return;
     }
     const accesses = flushPendingAccesses(frameId);
     const nextStep = {
@@ -1173,35 +1400,185 @@ function createTraceRecorder(options = {}) {
       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;
+      appendRuntimeTraceEventsForStep({
+        ...nextStep,
+        event: '__merge_only__',
+      });
       return;
     }
     trace.push(nextStep);
+    appendRuntimeTraceEventsForStep(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 runtimeTraceFrameIdForStep(step) {
+    const stack = Array.isArray(step?.callStack) ? step.callStack : [];
+    if (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      return `${frame.function}:${frame.line}:${frame.id ?? 'unknown'}`;
+    }
+    return `${step.function}:${step.line}:root`;
   }
 
-  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;
+  function runtimeTraceTargetForAccess(access) {
+    const indices = Array.isArray(access?.indices) ? access.indices : [];
+    const indexSources = Array.isArray(access?.indexSources) ? access.indexSources : [];
+    const scope = typeof access?.scope === 'string' && access.scope.length > 0
+      ? access.scope
+      : undefined;
+    const base = {
+      variable: access.variable,
+      ...(scope ? { scope } : {}),
+    };
+    if (indices.length > 0) {
+      return {
+        ...base,
+        path: indices,
+        ...(indexSources.length > 0 ? { indexSources } : {}),
+      };
     }
-    return true;
+    return base;
+  }
+
+  function runtimeTraceKindForAccess(access) {
+    if (access.kind === 'indexed-read' || access.kind === 'cell-read') return 'read';
+    if (access.kind === 'indexed-write' || access.kind === 'cell-write') return 'write';
+    return 'mutate';
+  }
+
+  function runtimeTraceAccessValue(step, access) {
+    if (access && Object.prototype.hasOwnProperty.call(access, 'value')) return access.value;
+    return valueAtPath(step?.variables?.[access.variable], access.indices);
+  }
+
+  function traceStepFrameId(step) {
+    const stack = Array.isArray(step?.callStack) ? step.callStack : [];
+    return stack.length > 0 ? stack[stack.length - 1]?.id : undefined;
+  }
+
+  function updateRuntimeTraceAccessStats(access) {
+    const variable = access?.variable;
+    if (typeof variable !== 'string' || variable.length === 0) return;
+    const stats = runtimeTraceAccessStatsByVariable.get(variable) ?? {
+      hasCellRead: false,
+      hasCellWrite: false,
+      hasMutatingCall: false,
+      hasNestedMutatingCall: false,
+      hasIndexedWrite: false,
+    };
+    if (access.kind === 'cell-read') stats.hasCellRead = true;
+    if (access.kind === 'cell-write') stats.hasCellWrite = true;
+    if (access.kind === 'mutating-call') stats.hasMutatingCall = true;
+    if (access.kind === 'mutating-call' && (access.pathDepth ?? 0) > 0) stats.hasNestedMutatingCall = true;
+    if (access.kind === 'indexed-write') stats.hasIndexedWrite = true;
+    runtimeTraceAccessStatsByVariable.set(variable, stats);
+  }
+
+  function appendRuntimeTraceEventsForStep(step) {
+    if (traceLimitExceeded && timeoutReason === 'trace-limit' && step?.event !== 'timeout') {
+      return;
+    }
+    const base = {
+      runId: 'javascript:run',
+      line: step.line,
+      frameId: runtimeTraceFrameIdForStep(step),
+    };
+    const pushRuntimeTraceEvent = (event) => {
+      if (runtimeTraceEvents.length >= effectiveMaxRuntimeTraceEvents) {
+        markTraceCaptureLimit(step?.line, step?.function);
+        return false;
+      }
+      runtimeTraceEvents.push(event);
+      return true;
+    };
+
+    if (step.event === 'line') {
+      pushRuntimeTraceEvent({ ...base, kind: 'line', function: step.function });
+    } else if (step.event === 'call') {
+      const stack = Array.isArray(step.callStack) ? step.callStack : [];
+      pushRuntimeTraceEvent({ ...base, kind: 'call', function: step.function, args: stack.at(-1)?.args });
+    } else if (step.event === 'return') {
+      pushRuntimeTraceEvent({
+        ...base,
+        kind: 'return',
+        function: step.function,
+        ...(step.returnValue !== undefined ? { value: step.returnValue } : {}),
+      });
+    } else if (step.event === 'exception') {
+      pushRuntimeTraceEvent({ ...base, kind: 'exception', message: String(step.returnValue ?? 'Runtime exception') });
+    } else if (step.event === 'timeout') {
+      pushRuntimeTraceEvent({ ...base, kind: 'timeout', message: 'Runtime timeout' });
+    } else if (step.event === 'stdout') {
+      pushRuntimeTraceEvent({
+        kind: 'stdout',
+        runId: 'javascript:run',
+        ...(step.line ? { line: step.line } : {}),
+        text: String(step.returnValue ?? ''),
+      });
+    }
+
+    if (step.event !== '__merge_only__') {
+      for (const [variable, value] of Object.entries(step.variables ?? {})) {
+        if (!pushRuntimeTraceEvent({ ...base, kind: 'snapshot', target: { variable }, value })) return;
+      }
+    } else {
+      for (const [variable, value] of Object.entries(step.variables ?? {})) {
+        if (!pushRuntimeTraceEvent({ ...base, kind: 'snapshot', target: { variable }, value })) return;
+      }
+    }
+
+    for (const access of step.accesses ?? []) {
+      updateRuntimeTraceAccessStats(access);
+      const kind = runtimeTraceKindForAccess(access);
+      const target = runtimeTraceTargetForAccess(access);
+      const accessBase = {
+        ...base,
+        ...(Number.isFinite(access.line) && access.line > 0 ? { line: access.line } : {}),
+        ...(Number.isFinite(access.column) && access.column >= 0 ? { column: access.column } : {}),
+      };
+      if (kind === 'mutate') {
+        const event = {
+          ...accessBase,
+          kind,
+          target,
+          ...(access.method ? { method: access.method } : {}),
+          ...(Array.isArray(access.args) ? { args: access.args } : {}),
+        };
+        if (!pushRuntimeTraceEvent(event)) return;
+      } else {
+        const event = {
+          ...accessBase,
+          kind,
+          target,
+          value: runtimeTraceAccessValue(step, access),
+          ...(access.binding ? { binding: access.binding } : {}),
+        };
+        if (!pushRuntimeTraceEvent(event)) return;
+      }
+    }
+  }
+
+  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;
+    if ((previous.accesses?.length ?? 0) > 0 || (nextStep.accesses?.length ?? 0) > 0) 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) {
@@ -1312,7 +1689,6 @@ function createTraceRecorder(options = {}) {
         variables: inferredFrame.args,
         function: normalizedFunctionName,
         callStack: snapshotCallStack(),
-        visualization: buildVisualizationPayload(inferredArgs),
       });
       return normalizedFunctionName;
     }
@@ -1333,7 +1709,6 @@ function createTraceRecorder(options = {}) {
     },
     pushCall(functionName, args, lineNumber) {
       const normalizedLine = normalizeLine(lineNumber, 1);
-      const normalizedArgs = sanitizeVariables(args);
       if (callStack.length + 1 > maxCallDepth) {
         markTimeout(
           'recursion-limit',
@@ -1341,6 +1716,11 @@ function createTraceRecorder(options = {}) {
           `Exceeded max call depth (${maxCallDepth})`
         );
       }
+      if (traceLimitExceeded) {
+        return;
+      }
+      this.attachPendingAccessesToPreviousLine();
+      const normalizedArgs = sanitizeCallArgs(args);
       const frame = {
         id: nextFrameId++,
         function: functionName || '<module>',
@@ -1354,10 +1734,12 @@ function createTraceRecorder(options = {}) {
         variables: normalizedArgs,
         function: frame.function,
         callStack: snapshotCallStack(),
-        visualization: buildVisualizationPayload(args),
       });
     },
     recordAccess(event) {
+      if (traceLimitExceeded) {
+        return;
+      }
       if (!event || typeof event !== 'object') {
         return;
       }
@@ -1377,12 +1759,41 @@ function createTraceRecorder(options = {}) {
         variable,
         kind,
         ...(Array.isArray(event.indices) && event.indices.length > 0
-          ? { indices: event.indices.map((index) => Math.trunc(index)) }
+          ? { indices: normalizeTraceIndices(event.indices) ?? undefined }
+          : {}),
+        ...(Array.isArray(event.indexSources) && event.indexSources.length > 0
+          ? { indexSources: normalizeTraceIndexSources(event.indexSources) ?? undefined }
           : {}),
         ...(typeof event.method === 'string' && event.method.length > 0
           ? { method: event.method }
           : {}),
-        ...(event.pathDepth === 1 || event.pathDepth === 2 ? { pathDepth: event.pathDepth } : {}),
+        ...(Array.isArray(event.args)
+          ? { args: event.args.map((arg) => this.serialize(arg)) }
+          : {}),
+        ...(event.pathDepth === 1 || event.pathDepth === 2 || event.pathDepth === 3 ? { pathDepth: event.pathDepth } : {}),
+        ...(typeof event.scope === 'string' && event.scope.length > 0
+          ? { scope: event.scope }
+          : {}),
+        ...(event.binding &&
+        typeof event.binding === 'object' &&
+        typeof event.binding.variable === 'string' &&
+        event.binding.variable.length > 0
+          ? {
+              binding: {
+                ...(event.binding.kind === 'iteration' ? { kind: 'iteration' } : {}),
+                variable: event.binding.variable,
+              },
+            }
+          : {}),
+        ...(Number.isFinite(event.line) && event.line > 0
+          ? { line: Math.trunc(event.line) }
+          : {}),
+        ...(Number.isFinite(event.column) && event.column >= 0
+          ? { column: Math.trunc(event.column) }
+          : {}),
+        ...(Object.prototype.hasOwnProperty.call(event, 'value')
+          ? { value: this.serialize(event.value) }
+          : {}),
       };
 
       const existing = pendingAccessesByFrame.get(frameId) ?? [];
@@ -1390,6 +1801,9 @@ function createTraceRecorder(options = {}) {
       pendingAccessesByFrame.set(frameId, existing);
     },
     deferPendingAccesses(lineFlushes = 1) {
+      if (traceLimitExceeded) {
+        return;
+      }
       const frameId = getCurrentFrameId();
       if (frameId === undefined) {
         return;
@@ -1408,9 +1822,54 @@ function createTraceRecorder(options = {}) {
         ),
       });
     },
+    attachPendingAccessesToPreviousLine() {
+      if (traceLimitExceeded) {
+        return;
+      }
+      const frameId = getCurrentFrameId();
+      if (frameId === undefined) {
+        return;
+      }
+      const pending = pendingAccessesByFrame.get(frameId);
+      if (!Array.isArray(pending) || pending.length === 0) {
+        return;
+      }
+      const attachable = pending;
+      pendingAccessesByFrame.delete(frameId);
+      if (attachable.length === 0) {
+        return;
+      }
+      for (let index = trace.length - 1; index >= 0; index -= 1) {
+        const step = trace[index];
+        if (!step || step.event !== 'line') continue;
+        if (traceStepFrameId(step) !== frameId) continue;
+        step.accesses = [...(step.accesses ?? []), ...attachable];
+        appendRuntimeTraceEventsForStep({
+          ...step,
+          event: '__access_only__',
+          accesses: attachable,
+        });
+        return;
+      }
+      pendingAccessesByFrame.set(frameId, attachable);
+    },
+    traceCondition(value) {
+      this.attachPendingAccessesToPreviousLine();
+      return value;
+    },
+    tracePostLineCondition(evaluate) {
+      if (typeof evaluate !== 'function') {
+        return evaluate;
+      }
+      return evaluate();
+    },
     line(lineNumber, snapshotFactory, functionNameOverride, functionStartLine) {
       const normalizedLine = normalizeLine(lineNumber, callStack[callStack.length - 1]?.line ?? 1);
 
+      if (traceLimitExceeded) {
+        return;
+      }
+
       lineEventCount += 1;
       if (lineEventCount > maxLineEvents) {
         markTimeout('line-limit', normalizedLine, `Exceeded ${maxLineEvents} line events`);
@@ -1427,15 +1886,12 @@ function createTraceRecorder(options = {}) {
       }
 
       let variables = {};
-      let visualization;
       if (typeof snapshotFactory === 'function') {
         try {
           const snapshot = snapshotFactory();
           variables = sanitizeVariables(snapshot);
-          visualization = buildVisualizationPayload(snapshot);
         } catch {
           variables = {};
-          visualization = undefined;
         }
       }
 
@@ -1452,10 +1908,12 @@ function createTraceRecorder(options = {}) {
         variables,
         function: traceFunctionName,
         callStack: snapshotCallStack(),
-        visualization,
       });
     },
     recordReturn(lineNumber, returnValue, functionNameOverride) {
+      if (traceLimitExceeded) {
+        return;
+      }
       const normalizedLine = normalizeLine(lineNumber, callStack[callStack.length - 1]?.line ?? 1);
       const functionName =
         typeof functionNameOverride === 'string' && functionNameOverride.length > 0
@@ -1463,9 +1921,6 @@ function createTraceRecorder(options = {}) {
           : callStack[callStack.length - 1]?.function ?? '<module>';
       const serializedReturnValue = serializeValue(returnValue);
       const variables = functionName === '<module>' ? { result: serializedReturnValue } : {};
-      const visualization = functionName === '<module>'
-        ? buildVisualizationPayload({ result: returnValue })
-        : undefined;
 
       appendTrace({
         line: normalizedLine,
@@ -1474,10 +1929,12 @@ function createTraceRecorder(options = {}) {
         function: functionName,
         callStack: snapshotCallStack(),
         returnValue: serializedReturnValue,
-        visualization,
       });
     },
     recordException(lineNumber, error, functionNameOverride) {
+      if (traceLimitExceeded) {
+        return;
+      }
       const normalizedLine = normalizeLine(lineNumber, callStack[callStack.length - 1]?.line ?? 1);
       appendTrace({
         line: normalizedLine,
@@ -1491,6 +1948,21 @@ function createTraceRecorder(options = {}) {
         returnValue: error instanceof Error ? error.message : String(error),
       });
     },
+    recordStdout(lineNumber, text) {
+      if (traceLimitExceeded) {
+        return;
+      }
+      const normalizedLine = normalizeLine(lineNumber, callStack[callStack.length - 1]?.line ?? 1);
+      appendTrace({
+        line: normalizedLine,
+        event: 'stdout',
+        variables: {},
+        function: callStack[callStack.length - 1]?.function ?? '<module>',
+        callStack: snapshotCallStack(),
+        stdoutLineCount: 1,
+        returnValue: String(text ?? ''),
+      });
+    },
     popCall() {
       if (callStack.length > 0) {
         const frame = callStack.pop();
@@ -1513,6 +1985,21 @@ function createTraceRecorder(options = {}) {
     getTrace() {
       return trace;
     },
+    getRuntimeTrace(language, runId = `${language}:run`, file) {
+      const events = runtimeTraceEvents.map((event) => ({
+        ...event,
+        runId,
+        ...(file ? { file } : {}),
+      }));
+      return {
+        schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+        language,
+        runId,
+        events,
+        lineEventCount: events.filter((event) => event.kind === 'line').length,
+        traceStepCount: events.length,
+      };
+    },
     getLineEventCount() {
       return lineEventCount;
     },
@@ -1672,6 +2159,75 @@ function createSyntheticTrace(payload, codeResult) {
   ];
 }
 
+function createEmptyRuntimeTrace(language, runId = `${language}:run`) {
+  return {
+    schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+    language,
+    runId,
+    events: [],
+    lineEventCount: 0,
+    traceStepCount: 0,
+  };
+}
+
+function defaultRuntimeTraceFile(language) {
+  return language === 'typescript' ? 'solution.ts' : 'solution.js';
+}
+
+function createSyntheticRuntimeTrace(payload, codeResult, language) {
+  const syntheticTrace = createSyntheticTrace(payload, codeResult);
+  const runId = `${language}:run`;
+  const file = defaultRuntimeTraceFile(language);
+  const events = [];
+  for (const step of syntheticTrace) {
+    const base = {
+      runId,
+      file,
+      line: step.line,
+      frameId: runtimeTraceFrameIdForSyntheticStep(step),
+    };
+    if (step.event === 'call') {
+      events.push({ ...base, kind: 'call', function: step.function, args: step.callStack?.at(-1)?.args });
+    } else if (step.event === 'line') {
+      events.push({ ...base, kind: 'line', function: step.function });
+    } else if (step.event === 'return') {
+      events.push({ ...base, kind: 'return', function: step.function, value: step.returnValue });
+    }
+    for (const [variable, value] of Object.entries(step.variables ?? {})) {
+      events.push({ ...base, kind: 'snapshot', target: { variable }, value });
+    }
+  }
+  return {
+    schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+    language,
+    runId,
+    events,
+    lineEventCount: events.filter((event) => event.kind === 'line').length,
+    traceStepCount: events.length,
+  };
+}
+
+const RUNTIME_TRACE_SCHEMA_VERSION = 'runtime-trace-2026-04-28';
+
+function runtimeTraceFrameIdForSyntheticStep(step) {
+  const stack = Array.isArray(step?.callStack) ? step.callStack : [];
+  if (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    return `${frame.function}:${frame.line}`;
+  }
+  return `${step.function}:${step.line}`;
+}
+
+function valueAtPath(value, path) {
+  if (!Array.isArray(path) || path.length === 0) return value;
+  let current = value;
+  for (const part of path) {
+    if (current === null || current === undefined || typeof current !== 'object') return undefined;
+    current = current[String(part)];
+  }
+  return current;
+}
+
 function getTypeScriptCompiler() {
   const ts = self?.ts;
   if (ts && typeof ts.transpileModule === 'function') {
@@ -1755,6 +2311,7 @@ function transpileTypeScript(sourceCode) {
 }
 
 async function prepareExecutableCode(sourceCode, language) {
+  ensureJavaScriptLibraries();
   if (language === 'typescript') {
     await ensureTypeScriptCompiler();
     return transpileTypeScript(sourceCode);
@@ -1780,6 +2337,51 @@ function addBindingNames(ts, nameNode, names) {
   }
 }
 
+function collectBindingNames(ts, nameNode) {
+  const names = new Set();
+  addBindingNames(ts, nameNode, names);
+  return [...names];
+}
+
+function addAssignmentTargetNames(ts, node, names) {
+  if (!node) return;
+  if (ts.isParenthesizedExpression(node)) {
+    addAssignmentTargetNames(ts, node.expression, names);
+    return;
+  }
+  if (ts.isIdentifier(node)) {
+    if (!node.text.startsWith('__trace')) names.add(node.text);
+    return;
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    for (const element of node.elements) {
+      if (ts.isSpreadElement(element)) {
+        addAssignmentTargetNames(ts, element.expression, names);
+      } else {
+        addAssignmentTargetNames(ts, element, names);
+      }
+    }
+    return;
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    for (const property of node.properties) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        addAssignmentTargetNames(ts, property.name, names);
+      } else if (ts.isPropertyAssignment(property)) {
+        addAssignmentTargetNames(ts, property.initializer, names);
+      } else if (ts.isSpreadAssignment(property)) {
+        addAssignmentTargetNames(ts, property.expression, names);
+      }
+    }
+  }
+}
+
+function collectAssignmentTargetNames(ts, node) {
+  const names = new Set();
+  addAssignmentTargetNames(ts, node, names);
+  return [...names];
+}
+
 function collectTraceVariableNames(ts, sourceFile) {
   const names = new Set();
 
@@ -1793,11 +2395,10 @@ function collectTraceVariableNames(ts, sourceFile) {
     } else if (
       ts.isBinaryExpression(node) &&
       node.left &&
-      ts.isIdentifier(node.left) &&
       node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
       node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
     ) {
-      names.add(node.left.text);
+      addAssignmentTargetNames(ts, node.left, names);
     }
     ts.forEachChild(node, visit);
   }
@@ -1817,6 +2418,95 @@ function shouldTraceStatement(ts, statement) {
   );
 }
 
+function shouldMapStatementLineForFunctionContext(ts, statement) {
+  return (
+    shouldTraceStatement(ts, statement) ||
+    ts.isWhileStatement(statement) ||
+    ts.isForStatement(statement) ||
+    ts.isForOfStatement(statement)
+  );
+}
+
+function isSingleLineNode(sourceFile, node) {
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
+  const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
+  return start === end;
+}
+
+function statementBypassesFollowingTraceLine(ts, statement) {
+  if (
+    ts.isBreakStatement(statement) ||
+    ts.isContinueStatement(statement) ||
+    ts.isReturnStatement(statement) ||
+    ts.isThrowStatement(statement)
+  ) {
+    return true;
+  }
+  if (ts.isBlock(statement)) {
+    return statement.statements.some((nested) => statementBypassesFollowingTraceLine(ts, nested));
+  }
+  return false;
+}
+
+function shouldTraceIfStatementPostLine(ts, sourceFile, statement) {
+  if (!isSingleLineNode(sourceFile, statement)) {
+    return false;
+  }
+  if (statementBypassesFollowingTraceLine(ts, statement.thenStatement)) {
+    return false;
+  }
+  if (statement.elseStatement && statementBypassesFollowingTraceLine(ts, statement.elseStatement)) {
+    return false;
+  }
+  return true;
+}
+
+function isPostLineStateStatement(ts, sourceFile, statement) {
+  if (ts.isVariableStatement(statement)) {
+    return true;
+  }
+  if (ts.isIfStatement(statement) && shouldTraceIfStatementPostLine(ts, sourceFile, statement)) {
+    return true;
+  }
+  if (!ts.isExpressionStatement(statement)) {
+    return false;
+  }
+  const expression = statement.expression;
+  if (
+    (ts.isPrefixUnaryExpression(expression) || ts.isPostfixUnaryExpression(expression)) &&
+    ts.isIdentifier(expression.operand) &&
+    (expression.operator === ts.SyntaxKind.PlusPlusToken ||
+      expression.operator === ts.SyntaxKind.MinusMinusToken)
+  ) {
+    return true;
+  }
+  if (
+    ts.isBinaryExpression(expression) &&
+    isAssignmentOperatorToken(ts, expression.operatorToken.kind) &&
+    ts.isIdentifier(expression.left)
+  ) {
+    return true;
+  }
+  if (isTraceStateMutationHelperCall(ts, expression)) {
+    return true;
+  }
+  return false;
+}
+
+function isTraceStateMutationHelperCall(ts, expression) {
+  let current = unwrapParenthesizedExpression(ts, expression);
+  if (!current || !ts.isCallExpression(current) || !ts.isIdentifier(current.expression)) {
+    return false;
+  }
+  return [
+    '__traceMutatingCall',
+    '__traceWriteIndex',
+    '__traceAugAssignIndex',
+    '__traceUpdateIndex',
+    '__traceUpdateScalar',
+  ].includes(current.expression.text);
+}
+
 function getNodeNameText(ts, nameNode) {
   if (!nameNode) return null;
   if (ts.isIdentifier(nameNode) || ts.isPrivateIdentifier(nameNode)) {
@@ -1857,7 +2547,8 @@ function inferTraceFunctionName(ts, node, fallbackFunctionName) {
   }
 
   if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-    const parent = node.parent;
+    const originalNode = ts.getOriginalNode(node);
+    const parent = node.parent ?? originalNode?.parent;
     if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
       return parent.name.text;
     }
@@ -1918,7 +2609,7 @@ function buildLineFunctionMap(ts, sourceFile, defaultFunctionName) {
       return;
     }
 
-    if (ts.isStatement(node) && shouldTraceStatement(ts, node)) {
+    if (ts.isStatement(node) && shouldMapStatementLineForFunctionContext(ts, node)) {
       mapStatementLine(node, currentFunctionName, currentFunctionStartLine, includeThisSnapshot);
     }
 
@@ -1931,7 +2622,14 @@ function buildLineFunctionMap(ts, sourceFile, defaultFunctionName) {
 
 function unwrapParenthesizedExpression(ts, node) {
   let current = node;
-  while (current && ts.isParenthesizedExpression(current)) {
+  while (
+    current &&
+    (ts.isParenthesizedExpression(current) ||
+      (typeof ts.isAsExpression === 'function' && ts.isAsExpression(current)) ||
+      (typeof ts.isTypeAssertionExpression === 'function' && ts.isTypeAssertionExpression(current)) ||
+      (typeof ts.isSatisfiesExpression === 'function' && ts.isSatisfiesExpression(current)) ||
+      (typeof ts.isNonNullExpression === 'function' && ts.isNonNullExpression(current)))
+  ) {
     current = current.expression;
   }
   return current;
@@ -1951,6 +2649,16 @@ function isAssignmentLikeLeftOperand(ts, node) {
   );
 }
 
+function isTraceablePropertyWriteLeftOperand(ts, node) {
+  const parent = node?.parent;
+  return Boolean(
+    parent &&
+      ts.isBinaryExpression(parent) &&
+      parent.left === node &&
+      parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
+  );
+}
+
 function isUpdateExpressionOperand(ts, node) {
   const parent = node?.parent;
   if (!parent) return false;
@@ -2006,21 +2714,71 @@ function extractTraceableElementAccess(ts, node) {
   const indices = [];
   let current = unwrapParenthesizedExpression(ts, node);
 
-  while (current && ts.isElementAccessExpression(current) && indices.length < 3) {
-    indices.unshift(current.argumentExpression);
-    current = unwrapParenthesizedExpression(ts, current.expression);
+  while (current && indices.length < 3) {
+    if (ts.isElementAccessExpression(current)) {
+      indices.unshift(current.argumentExpression);
+      current = unwrapParenthesizedExpression(ts, current.expression);
+      continue;
+    }
+    if (ts.isPropertyAccessExpression(current)) {
+      indices.unshift(ts.factory.createStringLiteral(current.name.text));
+      current = unwrapParenthesizedExpression(ts, current.expression);
+      continue;
+    }
+    break;
   }
 
-  if (!current || !ts.isIdentifier(current) || indices.length === 0 || indices.length > 2) {
+  if (!current || indices.length === 0 || indices.length > 2) {
+    return null;
+  }
+  if (ts.isThis(current)) {
+    return {
+      variableName: 'this',
+      receiverExpression: ts.factory.createThis(),
+      indices,
+    };
+  }
+  if (!ts.isIdentifier(current)) {
     return null;
   }
 
   return {
     variableName: current.text,
+    receiverExpression: ts.factory.createIdentifier(current.text),
     indices,
   };
 }
 
+function extractTraceablePropertyAccess(ts, node) {
+  const current = unwrapParenthesizedExpression(ts, node);
+  if (!current || !ts.isPropertyAccessExpression(current)) {
+    return null;
+  }
+  const receiver = unwrapParenthesizedExpression(ts, current.expression);
+  if (!receiver) {
+    return null;
+  }
+  if (ts.isThis(receiver)) {
+    return {
+      variableName: 'this',
+      propertyName: current.name.text,
+      scope: 'receiver',
+    };
+  }
+  if (!ts.isIdentifier(receiver)) {
+    return null;
+  }
+  return {
+    variableName: receiver.text,
+    propertyName: current.name.text,
+  };
+}
+
+function runtimeScopeForTraceableReceiver(receiverName, localVariableNames) {
+  if (receiverName === 'this') return 'receiver';
+  return localVariableNames.has(receiverName) ? 'local' : 'global';
+}
+
 function extractTraceableMutatingCall(ts, node) {
   if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
     return null;
@@ -2028,14 +2786,68 @@ function extractTraceableMutatingCall(ts, node) {
 
   const receiver = unwrapParenthesizedExpression(ts, node.expression.expression);
   const methodName = node.expression.name.text;
-  if (!receiver || !ts.isIdentifier(receiver) || !isTraceableMutatingMethod(methodName)) {
+  if (!receiver || !isTraceableMutatingMethod(methodName)) {
     return null;
   }
 
-  return {
-    variableName: receiver.text,
-    methodName,
-  };
+  if (ts.isIdentifier(receiver)) {
+    return {
+      variableName: receiver.text,
+      receiverExpression: ts.factory.createIdentifier(receiver.text),
+      methodName,
+      indices: [],
+    };
+  }
+
+  if (
+    ts.isPropertyAccessExpression(receiver) &&
+    ts.isThis(unwrapParenthesizedExpression(ts, receiver.expression))
+  ) {
+    return {
+      variableName: 'this',
+      receiverExpression: ts.factory.createThis(),
+      methodName,
+      indices: [ts.factory.createStringLiteral(receiver.name.text)],
+    };
+  }
+
+  const indexedReceiver = extractTraceableElementAccess(ts, receiver);
+  if (indexedReceiver) {
+    return {
+      variableName: indexedReceiver.variableName,
+      receiverExpression: indexedReceiver.receiverExpression,
+      methodName,
+      indices: indexedReceiver.indices,
+    };
+  }
+
+  if (
+    ts.isCallExpression(receiver) &&
+    ts.isPropertyAccessExpression(receiver.expression) &&
+    receiver.expression.name.text === 'get' &&
+    receiver.arguments.length === 1
+  ) {
+    const mapReceiver = unwrapParenthesizedExpression(ts, receiver.expression.expression);
+    if (ts.isIdentifier(mapReceiver)) {
+      return {
+        variableName: mapReceiver.text,
+        receiverExpression: ts.factory.createIdentifier(mapReceiver.text),
+        methodName,
+        indices: [receiver.arguments[0]],
+      };
+    }
+    const tracedMapReceiver = extractTraceableElementAccess(ts, mapReceiver);
+    if (tracedMapReceiver) {
+      return {
+        variableName: tracedMapReceiver.variableName,
+        receiverExpression: tracedMapReceiver.receiverExpression,
+        methodName,
+        indices: [...tracedMapReceiver.indices, receiver.arguments[0]],
+      };
+    }
+  }
+
+  return null;
 }
 
 function getCompoundAssignmentOperatorName(ts, tokenKind) {
@@ -2071,24 +2883,275 @@ function createIndicesArrayExpression(ts, indices) {
   return ts.factory.createArrayLiteralExpression(indices, false);
 }
 
-function createTraceReadIndexExpression(ts, variableName, indices) {
+function createIndexSourcesArrayExpression(ts, sourceFile, indices) {
+  return ts.factory.createArrayLiteralExpression(
+    indices.map((index) => {
+      const source = indexSourceExpressionText(ts, sourceFile, index);
+      return source ? ts.factory.createStringLiteral(source) : ts.factory.createNull();
+    }),
+    false
+  );
+}
+
+function indexSourceExpressionText(ts, sourceFile, index) {
+  if (ts.isIdentifier(index)) return index.text;
+  if (typeof index.pos === 'number' && index.pos < 0) return null;
+  let text = '';
+  try {
+    text = typeof index.getText === 'function' ? index.getText(sourceFile).trim().replace(/\s+/g, ' ') : '';
+  } catch {
+    text = '';
+  }
+  if (!text) return null;
+  return isSafeIndexSourceExpression(ts, index) ? text : null;
+}
+
+function isSafeIndexSourceExpression(ts, node) {
+  const unwrapped = unwrapParenthesizedExpression(ts, node);
+  if (!unwrapped) return false;
+  if (ts.isIdentifier(unwrapped) || ts.isNumericLiteral(unwrapped) || ts.isStringLiteral(unwrapped)) {
+    return true;
+  }
+  if (unwrapped.kind === ts.SyntaxKind.ThisKeyword) {
+    return true;
+  }
+  if (ts.isPrefixUnaryExpression(unwrapped)) {
+    if (
+      (unwrapped.operator === ts.SyntaxKind.PlusPlusToken || unwrapped.operator === ts.SyntaxKind.MinusMinusToken) &&
+      ts.isIdentifier(unwrapped.operand)
+    ) {
+      return true;
+    }
+    return (
+      (unwrapped.operator === ts.SyntaxKind.PlusToken || unwrapped.operator === ts.SyntaxKind.MinusToken) &&
+      isSafeIndexSourceExpression(ts, unwrapped.operand)
+    );
+  }
+  if (ts.isPostfixUnaryExpression(unwrapped)) {
+    return (
+      (unwrapped.operator === ts.SyntaxKind.PlusPlusToken || unwrapped.operator === ts.SyntaxKind.MinusMinusToken) &&
+      ts.isIdentifier(unwrapped.operand)
+    );
+  }
+  if (ts.isPropertyAccessExpression(unwrapped)) {
+    return isSafeIndexSourceExpression(ts, unwrapped.expression);
+  }
+  if (ts.isElementAccessExpression(unwrapped)) {
+    return (
+      isSafeIndexSourceExpression(ts, unwrapped.expression) &&
+      Boolean(unwrapped.argumentExpression) &&
+      isSafeIndexSourceExpression(ts, unwrapped.argumentExpression)
+    );
+  }
+  if (ts.isCallExpression(unwrapped)) {
+    const expression = unwrapParenthesizedExpression(ts, unwrapped.expression);
+    if (!expression || !ts.isPropertyAccessExpression(expression)) return false;
+    const safeIndexMethods = new Set(['at', 'charAt', 'charCodeAt', 'codePointAt']);
+    return (
+      safeIndexMethods.has(expression.name.text) &&
+      isSafeIndexSourceExpression(ts, expression.expression) &&
+      unwrapped.arguments.every((argument) => isSafeIndexSourceExpression(ts, argument))
+    );
+  }
+  if (ts.isBinaryExpression(unwrapped)) {
+    const allowedOperators = new Set([
+      ts.SyntaxKind.PlusToken,
+      ts.SyntaxKind.MinusToken,
+      ts.SyntaxKind.AsteriskToken,
+      ts.SyntaxKind.SlashToken,
+      ts.SyntaxKind.PercentToken,
+    ]);
+    return (
+      allowedOperators.has(unwrapped.operatorToken.kind) &&
+      isSafeIndexSourceExpression(ts, unwrapped.left) &&
+      isSafeIndexSourceExpression(ts, unwrapped.right)
+    );
+  }
+  return false;
+}
+
+function createTraceReadIndexExpression(ts, sourceFile, node, variableName, indices, indexSourceExpressions = indices) {
+  const receiverExpression = variableName === 'this'
+    ? ts.factory.createThis()
+    : ts.factory.createIdentifier(variableName);
+  return createTraceReadIndexExpressionForReceiver(
+    ts,
+    sourceFile,
+    node,
+    variableName,
+    receiverExpression,
+    indices,
+    indexSourceExpressions
+  );
+}
+
+function createTraceReadIndexExpressionForReceiver(
+  ts,
+  sourceFile,
+  node,
+  variableName,
+  receiverExpression,
+  indices,
+  indexSourceExpressions = indices
+) {
   return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceReadIndex'), undefined, [
     ts.factory.createStringLiteral(variableName),
-    ts.factory.createIdentifier(variableName),
+    receiverExpression,
     createIndicesArrayExpression(ts, indices),
+    createIndexSourcesArrayExpression(ts, sourceFile, indexSourceExpressions),
+    createSourceLocationObject(ts, sourceFile, node),
   ]);
 }
 
-function createTraceWriteIndexExpression(ts, variableName, indices, value) {
+function createTraceWriteIndexExpression(ts, sourceFile, node, variableName, indices, value, indexSourceExpressions = indices) {
+  const receiverExpression = variableName === 'this'
+    ? ts.factory.createThis()
+    : ts.factory.createIdentifier(variableName);
   return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceWriteIndex'), undefined, [
     ts.factory.createStringLiteral(variableName),
-    ts.factory.createIdentifier(variableName),
+    receiverExpression,
     createIndicesArrayExpression(ts, indices),
+    createIndexSourcesArrayExpression(ts, sourceFile, indexSourceExpressions),
     value,
+    createSourceLocationObject(ts, sourceFile, node),
   ]);
 }
 
-function createTraceAugAssignExpression(ts, variableName, indices, operatorName, rhs) {
+function createSourceLocationObject(ts, sourceFile, node) {
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return ts.factory.createObjectLiteralExpression(
+    [
+      ts.factory.createPropertyAssignment('line', ts.factory.createNumericLiteral(position.line + 1)),
+      ts.factory.createPropertyAssignment('column', ts.factory.createNumericLiteral(position.character + 1)),
+    ],
+    false
+  );
+}
+
+function createTraceReadPropertyExpression(ts, sourceFile, node, variableName, propertyName, scope) {
+  const receiverExpression = variableName === 'this'
+    ? ts.factory.createThis()
+    : ts.factory.createIdentifier(variableName);
+  const args = [
+    ts.factory.createStringLiteral(variableName),
+    receiverExpression,
+    ts.factory.createStringLiteral(propertyName),
+  ];
+  if (scope) {
+    args.push(ts.factory.createStringLiteral(scope));
+  }
+  args.push(createSourceLocationObject(ts, sourceFile, node));
+  return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceReadProperty'), undefined, args);
+}
+
+function createTraceWritePropertyExpression(ts, sourceFile, node, variableName, propertyName, value) {
+  const receiverExpression = variableName === 'this'
+    ? ts.factory.createThis()
+    : ts.factory.createIdentifier(variableName);
+  return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceWriteIndex'), undefined, [
+    ts.factory.createStringLiteral(variableName),
+    receiverExpression,
+    createIndicesArrayExpression(ts, [ts.factory.createStringLiteral(propertyName)]),
+    ts.factory.createArrayLiteralExpression([ts.factory.createNull()], false),
+    value,
+    createSourceLocationObject(ts, sourceFile, node),
+  ]);
+}
+
+function createTraceScalarWriteExpression(ts, sourceFile, node, variableName, value) {
+  return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceAssignScalar'), undefined, [
+    ts.factory.createStringLiteral(variableName),
+    value,
+    createSourceLocationObject(ts, sourceFile, node),
+  ]);
+}
+
+function createTraceScalarUpdateExpression(ts, sourceFile, node, variableName, operatorName, isPrefix) {
+  return ts.factory.createCallExpression(ts.factory.createIdentifier('__traceUpdateScalar'), undefined, [
+    ts.factory.createStringLiteral(variableName),
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      isPrefix
+        ? ts.factory.createPrefixUnaryExpression(
+            operatorName === 'inc' ? ts.SyntaxKind.PlusPlusToken : ts.SyntaxKind.MinusMinusToken,
+            ts.factory.createIdentifier(variableName)
+          )
+        : ts.factory.createPostfixUnaryExpression(
+            ts.factory.createIdentifier(variableName),
+            operatorName === 'inc' ? ts.SyntaxKind.PlusPlusToken : ts.SyntaxKind.MinusMinusToken
+          )
+    ),
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      ts.factory.createIdentifier(variableName)
+    ),
+    isPrefix ? ts.factory.createTrue() : ts.factory.createFalse(),
+    createSourceLocationObject(ts, sourceFile, node),
+  ]);
+}
+
+function createTraceScalarWriteStatement(ts, sourceFile, node, variableName) {
+  return ts.factory.createExpressionStatement(
+    ts.factory.createCallExpression(ts.factory.createIdentifier('__traceScalarWrite'), undefined, [
+      ts.factory.createStringLiteral(variableName),
+      ts.factory.createIdentifier(variableName),
+      createSourceLocationObject(ts, sourceFile, node),
+    ])
+  );
+}
+
+function traceScalarWriteStatementsForVariableStatement(ts, sourceFile, statement) {
+  if (!ts.isVariableStatement(statement)) return [];
+  const statements = [];
+  for (const declaration of statement.declarationList.declarations) {
+    if (!declaration.initializer) continue;
+    if (
+      ts.isArrowFunction(declaration.initializer) ||
+      ts.isFunctionExpression(declaration.initializer) ||
+      ts.isClassExpression(declaration.initializer)
+    ) {
+      continue;
+    }
+    for (const variableName of collectBindingNames(ts, declaration.name)) {
+      statements.push(createTraceScalarWriteStatement(ts, sourceFile, declaration.name, variableName));
+    }
+  }
+  return statements;
+}
+
+function traceScalarWriteStatementsForDestructuringAssignmentStatement(ts, sourceFile, statement) {
+  if (!ts.isExpressionStatement(statement)) return [];
+  const expression = ts.isParenthesizedExpression(statement.expression)
+    ? statement.expression.expression
+    : statement.expression;
+  if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+    return [];
+  }
+  if (!ts.isArrayLiteralExpression(expression.left) && !ts.isObjectLiteralExpression(expression.left)) {
+    return [];
+  }
+  return collectAssignmentTargetNames(ts, expression.left)
+    .map((variableName) => createTraceScalarWriteStatement(ts, sourceFile, expression.left, variableName));
+}
+
+function createTraceAugAssignExpression(
+  ts,
+  sourceFile,
+  node,
+  variableName,
+  indices,
+  operatorName,
+  rhs,
+  indexSourceExpressions = indices
+) {
   return ts.factory.createCallExpression(
     ts.factory.createIdentifier('__traceAugAssignIndex'),
     undefined,
@@ -2096,13 +3159,24 @@ function createTraceAugAssignExpression(ts, variableName, indices, operatorName,
       ts.factory.createStringLiteral(variableName),
       ts.factory.createIdentifier(variableName),
       createIndicesArrayExpression(ts, indices),
+      createIndexSourcesArrayExpression(ts, sourceFile, indexSourceExpressions),
       ts.factory.createStringLiteral(operatorName),
       rhs,
+      createSourceLocationObject(ts, sourceFile, node),
     ]
   );
 }
 
-function createTraceUpdateExpression(ts, variableName, indices, operatorName, isPrefix) {
+function createTraceUpdateExpression(
+  ts,
+  sourceFile,
+  node,
+  variableName,
+  indices,
+  operatorName,
+  isPrefix,
+  indexSourceExpressions = indices
+) {
   return ts.factory.createCallExpression(
     ts.factory.createIdentifier('__traceUpdateIndex'),
     undefined,
@@ -2110,25 +3184,106 @@ function createTraceUpdateExpression(ts, variableName, indices, operatorName, is
       ts.factory.createStringLiteral(variableName),
       ts.factory.createIdentifier(variableName),
       createIndicesArrayExpression(ts, indices),
+      createIndexSourcesArrayExpression(ts, sourceFile, indexSourceExpressions),
       ts.factory.createStringLiteral(operatorName),
       isPrefix ? ts.factory.createTrue() : ts.factory.createFalse(),
+      createSourceLocationObject(ts, sourceFile, node),
     ]
   );
 }
 
-function createTraceMutatingCallExpression(ts, variableName, methodName, args) {
+function createTraceMutatingCallExpression(
+  ts,
+  sourceFile,
+  node,
+  variableName,
+  methodName,
+  args,
+  indices = [],
+  indexSourceExpressions = indices
+) {
+  const receiverExpression = variableName === 'this'
+    ? ts.factory.createThis()
+    : ts.factory.createIdentifier(variableName);
+  return createTraceMutatingCallExpressionForReceiver(
+    ts,
+    sourceFile,
+    node,
+    variableName,
+    receiverExpression,
+    methodName,
+    args,
+    indices,
+    indexSourceExpressions
+  );
+}
+
+function createTraceMutatingCallExpressionForReceiver(
+  ts,
+  sourceFile,
+  node,
+  variableName,
+  receiverExpression,
+  methodName,
+  args,
+  indices = [],
+  indexSourceExpressions = indices
+) {
+  const effectiveIndexSourceExpressions = ['set', 'get', 'has'].includes(methodName) && args.length > 0
+    ? [...indexSourceExpressions, args[0]]
+    : indexSourceExpressions;
   return ts.factory.createCallExpression(
     ts.factory.createIdentifier('__traceMutatingCall'),
     undefined,
     [
       ts.factory.createStringLiteral(variableName),
-      ts.factory.createIdentifier(variableName),
+      receiverExpression,
+      createIndicesArrayExpression(ts, indices),
+      createIndexSourcesArrayExpression(ts, sourceFile, effectiveIndexSourceExpressions),
       ts.factory.createStringLiteral(methodName),
+      createSourceLocationObject(ts, sourceFile, node),
       ...args,
     ]
   );
 }
 
+function isConsoleLogCall(ts, node) {
+  return Boolean(
+    ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression) &&
+      ts.isIdentifier(node.expression.expression) &&
+      node.expression.expression.text === 'console' &&
+      node.expression.name.text === 'log'
+  );
+}
+
+function createTraceStdoutExpression(ts, sourceFile, node) {
+  const lineNumber = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+  return ts.factory.createCallExpression(
+    ts.factory.createIdentifier('__traceStdout'),
+    undefined,
+    [
+      ts.factory.createNumericLiteral(lineNumber),
+      ...node.arguments,
+    ]
+  );
+}
+
+function createTraceThrowExpression(ts, sourceFile, node) {
+  const lineNumber = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+  return ts.factory.updateThrowStatement(
+    node,
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier('__traceExceptionValue'),
+      undefined,
+      [
+        ts.factory.createNumericLiteral(lineNumber),
+        node.expression ?? ts.factory.createIdentifier('undefined'),
+      ]
+    )
+  );
+}
+
 function createSnapshotFactory(ts, variableNames, includeThis = false) {
   const properties = variableNames.map((name) =>
     ts.factory.createPropertyAssignment(
@@ -2222,6 +3377,19 @@ function createTraceLineStatement(ts, sourceFile, statement, variableNames, line
   );
 }
 
+function createAttachPendingAccessesStatement(ts) {
+  return ts.factory.createExpressionStatement(
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier('__traceRecorder'),
+        ts.factory.createIdentifier('attachPendingAccessesToPreviousLine')
+      ),
+      undefined,
+      []
+    )
+  );
+}
+
 function ensureBlockStatement(ts, statement) {
   if (ts.isBlock(statement)) {
     return statement;
@@ -2229,6 +3397,28 @@ function ensureBlockStatement(ts, statement) {
   return ts.factory.createBlock([statement], true);
 }
 
+function wrapTraceCondition(ts, expression, deferAccessesToNextLine = false) {
+  const recorderMethod = deferAccessesToNextLine ? 'tracePostLineCondition' : 'traceCondition';
+  const argument = deferAccessesToNextLine
+    ? ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        expression
+      )
+    : expression;
+  return ts.factory.createCallExpression(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier('__traceRecorder'),
+      ts.factory.createIdentifier(recorderMethod)
+    ),
+    undefined,
+    [argument]
+  );
+}
+
 function rewriteWhileStatementForTracing(ts, sourceFile, whileStatement, variableNames, lineFunctionMap, defaultFunctionName) {
   const originalNode = ts.getOriginalNode(whileStatement) ?? whileStatement;
   const tracedLine = createTraceLineStatement(
@@ -2243,7 +3433,7 @@ function rewriteWhileStatementForTracing(ts, sourceFile, whileStatement, variabl
   const guardedBreak = ts.factory.createIfStatement(
     ts.factory.createPrefixUnaryExpression(
       ts.SyntaxKind.ExclamationToken,
-      whileStatement.expression
+      wrapTraceCondition(ts, whileStatement.expression)
     ),
     ts.factory.createBreakStatement(),
     undefined
@@ -2276,27 +3466,82 @@ function rewriteForStatementForTracing(ts, sourceFile, forStatement, variableNam
     ts.factory.createBinaryExpression(
       tracedLineCall,
       ts.SyntaxKind.CommaToken,
-      condition
+      wrapTraceCondition(ts, condition)
     )
   );
-  return ts.factory.updateForStatement(
+  const initializerWriteStatements = [];
+  if (forStatement.initializer && ts.isVariableDeclarationList(forStatement.initializer)) {
+    for (const declaration of forStatement.initializer.declarations) {
+      if (!ts.isIdentifier(declaration.name)) continue;
+      initializerWriteStatements.push(createTraceScalarWriteStatement(ts, sourceFile, originalNode, declaration.name.text));
+    }
+  }
+  const rewrittenFor = ts.factory.updateForStatement(
     forStatement,
-    forStatement.initializer,
+    initializerWriteStatements.length > 0 ? undefined : forStatement.initializer,
     tracedCondition,
     forStatement.incrementor,
     forStatement.statement
   );
+  if (initializerWriteStatements.length === 0 || !forStatement.initializer || !ts.isVariableDeclarationList(forStatement.initializer)) {
+    return rewrittenFor;
+  }
+  return ts.factory.createBlock(
+    [
+      ts.factory.createVariableStatement(undefined, forStatement.initializer),
+      ...initializerWriteStatements,
+      rewrittenFor,
+    ],
+    true
+  );
 }
 
-function rewriteForOfStatementForTracing(ts, sourceFile, forOfStatement, variableNames, lineFunctionMap, defaultFunctionName) {
+function rewriteForOfStatementForTracing(ts, sourceFile, context, 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(
+  const originalExpression = originalNode.expression ?? forOfStatement.expression;
+  const indexedSource = extractTraceableElementAccess(ts, originalExpression);
+  const sourceName = ts.isIdentifier(forOfStatement.expression) ? forOfStatement.expression.text : null;
+  const bindingName =
+    ts.isVariableDeclarationList(forOfStatement.initializer) &&
+    forOfStatement.initializer.declarations.length === 1 &&
+    collectBindingNames(ts, forOfStatement.initializer.declarations[0].name).length > 0
+      ? collectBindingNames(ts, forOfStatement.initializer.declarations[0].name).join(',')
+      : ts.isIdentifier(forOfStatement.initializer)
+        ? forOfStatement.initializer.text
+        : null;
+  const lineNumber = sourceFile.getLineAndCharacterOfPosition(originalNode.getStart(sourceFile)).line + 1;
+  const tracedExpression =
+    indexedSource && bindingName
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier('__traceIterableBindIndexed'),
+          undefined,
+          [
+            ts.factory.createStringLiteral(indexedSource.variableName),
+            forOfStatement.expression,
+            createIndicesArrayExpression(ts, indexedSource.indices),
+            createIndexSourcesArrayExpression(ts, sourceFile, indexedSource.indices),
+            ts.factory.createStringLiteral(bindingName),
+            ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment('line', ts.factory.createNumericLiteral(lineNumber)),
+            ]),
+          ]
+        )
+      : sourceName && bindingName
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier('__traceIterableBind'),
+          undefined,
+          [
+            ts.factory.createStringLiteral(sourceName),
+            forOfStatement.expression,
+            ts.factory.createStringLiteral(bindingName),
+            ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment('line', ts.factory.createNumericLiteral(lineNumber)),
+            ]),
+          ]
+        )
+      : forOfStatement.expression;
+  const createHeaderLine = () => createTraceLineStatement(
     ts,
     sourceFile,
     originalNode,
@@ -2304,75 +3549,41 @@ function rewriteForOfStatementForTracing(ts, sourceFile, forOfStatement, variabl
     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))
-    );
-  }
+  const bodyTracedLine = createHeaderLine();
+  const rewriteContinueForHeader = (node) => {
+    if (ts.isFunctionLike(node)) return node;
+    if (
+      node !== visitedBodyBlock &&
+      (ts.isForStatement(node) ||
+        ts.isForInStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isWhileStatement(node) ||
+        ts.isDoStatement(node))
+    ) {
+      return node;
+    }
+    if (ts.isContinueStatement(node) && !node.label) {
+      return ts.factory.createBlock([createHeaderLine(), node], true);
+    }
+    return ts.visitEachChild(node, rewriteContinueForHeader, context);
+  };
+  const bodyStatements = visitedBodyBlock.statements.map((statement) => ts.visitNode(statement, rewriteContinueForHeader));
+  const bodyBlock = ts.factory.updateBlock(visitedBodyBlock, [
+    bodyTracedLine,
+    ...bodyStatements,
+  ]);
 
   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)
+      ts.factory.updateForOfStatement(
+        forOfStatement,
+        forOfStatement.awaitModifier,
+        forOfStatement.initializer,
+        tracedExpression,
+        bodyBlock
       ),
+      createHeaderLine(),
+      createAttachPendingAccessesStatement(ts),
     ],
     true
   );
@@ -2395,16 +3606,28 @@ function instrumentStatementList(
       ts.getOriginalNode(visitedStatement) ??
       visitedStatement;
     if (shouldTraceStatement(ts, visitedStatement)) {
+      const tracedLineStatement = createTraceLineStatement(
+        ts,
+        sourceFile,
+        originalStatement,
+        variableNames,
+        lineFunctionMap,
+        defaultFunctionName
+      );
+      if (isPostLineStateStatement(ts, sourceFile, originalStatement)) {
+        nextStatements.push(visitedStatement);
+        nextStatements.push(...traceScalarWriteStatementsForVariableStatement(ts, sourceFile, originalStatement));
+        nextStatements.push(tracedLineStatement);
+        continue;
+      }
       nextStatements.push(
-        createTraceLineStatement(
-          ts,
-          sourceFile,
-          originalStatement,
-          variableNames,
-          lineFunctionMap,
-          defaultFunctionName
-        )
+        tracedLineStatement
       );
+      nextStatements.push(visitedStatement);
+      nextStatements.push(...traceScalarWriteStatementsForVariableStatement(ts, sourceFile, originalStatement));
+      nextStatements.push(...traceScalarWriteStatementsForDestructuringAssignmentStatement(ts, sourceFile, originalStatement));
+      nextStatements.push(createAttachPendingAccessesStatement(ts));
+      continue;
     }
     nextStatements.push(visitedStatement);
   }
@@ -2642,6 +3865,7 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
   );
 
   const variableNames = collectTraceVariableNames(ts, sourceFile);
+  const localVariableNames = new Set(variableNames);
   const effectiveFunctionName =
     typeof traceFunctionName === 'string' && traceFunctionName.length > 0
       ? traceFunctionName
@@ -2662,14 +3886,31 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
           const visitedIndices = tracedOperand.indices.map((indexExpr) => ts.visitNode(indexExpr, visit));
           return createTraceUpdateExpression(
             ts,
+            sourceFile,
+            node,
             tracedOperand.variableName,
             visitedIndices,
             operatorName,
+            ts.isPrefixUnaryExpression(node),
+            tracedOperand.indices
+          );
+        }
+        if (ts.isIdentifier(node.operand) && operatorName) {
+          return createTraceScalarUpdateExpression(
+            ts,
+            sourceFile,
+            node,
+            node.operand.text,
+            operatorName,
             ts.isPrefixUnaryExpression(node)
           );
         }
       }
 
+      if (ts.isThrowStatement(node)) {
+        return createTraceThrowExpression(ts, sourceFile, node);
+      }
+
       if (ts.isBinaryExpression(node)) {
         const tracedLeft = extractTraceableElementAccess(ts, node.left);
         if (tracedLeft && isAssignmentOperatorToken(ts, node.operatorToken.kind)) {
@@ -2678,9 +3919,12 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
           if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
             return createTraceWriteIndexExpression(
               ts,
+              sourceFile,
+              node.left,
               tracedLeft.variableName,
               visitedIndices,
-              visitedRight
+              visitedRight,
+              tracedLeft.indices
             );
           }
 
@@ -2688,34 +3932,87 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
           if (operatorName) {
             return createTraceAugAssignExpression(
               ts,
+              sourceFile,
+              node.left,
               tracedLeft.variableName,
               visitedIndices,
               operatorName,
-              visitedRight
+              visitedRight,
+              tracedLeft.indices
             );
           }
         }
+
+        if (ts.isIdentifier(node.left) && isAssignmentOperatorToken(ts, node.operatorToken.kind)) {
+          const visitedRight = ts.visitNode(node.right, visit);
+          const rewrittenAssignment = ts.factory.updateBinaryExpression(
+            node,
+            node.left,
+            node.operatorToken,
+            visitedRight
+          );
+          return createTraceScalarWriteExpression(
+            ts,
+            sourceFile,
+            node.left,
+            node.left.text,
+            rewrittenAssignment
+          );
+        }
+
+        const tracedPropertyLeft = extractTraceablePropertyAccess(ts, node.left);
+        if (tracedPropertyLeft && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+          const visitedRight = ts.visitNode(node.right, visit);
+          return createTraceWritePropertyExpression(
+            ts,
+            sourceFile,
+            node.left,
+            tracedPropertyLeft.variableName,
+            tracedPropertyLeft.propertyName,
+            visitedRight
+          );
+        }
       }
 
       if (ts.isCallExpression(node)) {
+        if (isConsoleLogCall(ts, node)) {
+          return createTraceStdoutExpression(ts, sourceFile, node);
+        }
         const tracedCall = extractTraceableMutatingCall(ts, node);
         if (tracedCall) {
           const visitedArgs = node.arguments.map((arg) => ts.visitNode(arg, visit));
-          return createTraceMutatingCallExpression(
+          return createTraceMutatingCallExpressionForReceiver(
             ts,
+            sourceFile,
+            node,
             tracedCall.variableName,
+            tracedCall.receiverExpression,
             tracedCall.methodName,
-            visitedArgs
+            visitedArgs,
+            tracedCall.indices?.map((indexExpr) => ts.visitNode(indexExpr, visit)) ?? [],
+            tracedCall.indices ?? []
           );
         }
       }
 
+      if (ts.isIfStatement(node)) {
+        const visited = ts.visitEachChild(node, visit, context);
+        return ts.factory.updateIfStatement(
+          visited,
+          wrapTraceCondition(ts, visited.expression, shouldTraceIfStatementPostLine(ts, sourceFile, node)),
+          visited.thenStatement,
+          visited.elseStatement
+        );
+      }
+
       if (ts.isElementAccessExpression(node)) {
+        const parent = node.parent;
         if (
           isNestedElementAccessExpression(ts, node) ||
           isAssignmentLikeLeftOperand(ts, node) ||
           isUpdateExpressionOperand(ts, node) ||
-          isDestructuringAssignmentTarget(ts, node)
+          isDestructuringAssignmentTarget(ts, node) ||
+          (parent && ts.isCallExpression(parent) && parent.expression === node)
         ) {
           return ts.visitEachChild(node, visit, context);
         }
@@ -2723,7 +4020,57 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
         const tracedAccess = extractTraceableElementAccess(ts, node);
         if (tracedAccess) {
           const visitedIndices = tracedAccess.indices.map((indexExpr) => ts.visitNode(indexExpr, visit));
-          return createTraceReadIndexExpression(ts, tracedAccess.variableName, visitedIndices);
+          return createTraceReadIndexExpression(
+            ts,
+            sourceFile,
+            node,
+            tracedAccess.variableName,
+            visitedIndices,
+            tracedAccess.indices
+          );
+        }
+      }
+
+      if (ts.isPropertyAccessExpression(node)) {
+        const parent = node.parent;
+        const grandparent = parent?.parent;
+        if (
+          isTraceablePropertyWriteLeftOperand(ts, node) ||
+          isDestructuringAssignmentTarget(ts, node) ||
+          (parent && ts.isCallExpression(parent) && parent.expression === node) ||
+          (parent &&
+            ts.isPropertyAccessExpression(parent) &&
+            parent.expression === node &&
+            grandparent &&
+            ts.isCallExpression(grandparent) &&
+            grandparent.expression === parent)
+        ) {
+          return ts.visitEachChild(node, visit, context);
+        }
+
+        const tracedIndexedPropertyAccess = extractTraceableElementAccess(ts, node);
+        if (tracedIndexedPropertyAccess && tracedIndexedPropertyAccess.indices.length > 1) {
+          const visitedIndices = tracedIndexedPropertyAccess.indices.map((indexExpr) => ts.visitNode(indexExpr, visit));
+          return createTraceReadIndexExpression(
+            ts,
+            sourceFile,
+            node,
+            tracedIndexedPropertyAccess.variableName,
+            visitedIndices,
+            tracedIndexedPropertyAccess.indices
+          );
+        }
+
+        const tracedAccess = extractTraceablePropertyAccess(ts, node);
+        if (tracedAccess) {
+          return createTraceReadPropertyExpression(
+            ts,
+            sourceFile,
+            node,
+            tracedAccess.variableName,
+            tracedAccess.propertyName,
+            tracedAccess.scope ?? runtimeScopeForTraceableReceiver(tracedAccess.variableName, localVariableNames)
+          );
         }
       }
 
@@ -2803,6 +4150,7 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
         return rewriteForOfStatementForTracing(
           ts,
           sourceFile,
+          context,
           visited,
           variableNames,
           lineFunctionMap,
@@ -2865,9 +4213,7 @@ async function instrumentCodeForTracing(sourceCode, language, traceFunctionName)
 function buildScriptExecutionRunner(code) {
   return new Function(
     'console',
-    `"use strict";
-${JAVASCRIPT_RUNTIME_PRELUDE}
-let result;
+    `${JAVASCRIPT_RUNTIME_PRELUDE}
 ${code}
 if (typeof result === 'undefined') {
   return null;
@@ -2879,19 +4225,41 @@ return result;`
 const TRACING_RUNTIME_HELPERS_SOURCE = `
 function __traceNormalizeIndices(__indices, __maxDepth = 2) {
   if (!Array.isArray(__indices) || __indices.length === 0 || __indices.length > __maxDepth) return null;
-  if (!__indices.every((__index) => typeof __index === 'number' && Number.isInteger(__index))) return null;
-  return __indices.map((__index) => Math.trunc(__index));
+  if (!__indices.every((__index) =>
+    (typeof __index === 'number' && Number.isInteger(__index)) ||
+    (typeof __index === 'string' && __index.length > 0)
+  )) return null;
+  return __indices.map((__index) => typeof __index === 'number' ? Math.trunc(__index) : __index);
+}
+
+function __traceNormalizeIndexSources(__indexSources, __pathLength) {
+  if (!Array.isArray(__indexSources) || !Number.isInteger(__pathLength) || __pathLength <= 0) return null;
+  const __normalized = __indexSources.slice(0, __pathLength).map((__source) =>
+    typeof __source === 'string' && __source.length > 0 ? __source : null
+  );
+  while (__normalized.length < __pathLength) __normalized.push(null);
+  return __normalized.some((__source) => __source !== null) ? __normalized : null;
 }
 
 function __traceReadValueAtIndices(__container, __indices) {
   let __current = __container;
   for (const __index of __indices) {
     if (__current === null || __current === undefined) return undefined;
-    __current = __current[__index];
+    __current = __traceIsMapLike(__current) ? __current.get(__index) : __current[__index];
   }
   return __current;
 }
 
+function __traceIsMapLike(__value) {
+  return __value instanceof Map ||
+    (!!__value &&
+      typeof __value === 'object' &&
+      typeof __value.get === 'function' &&
+      typeof __value.set === 'function' &&
+      typeof __value.has === 'function' &&
+      typeof __value.delete === 'function');
+}
+
 function __traceWriteValueAtIndices(__container, __indices, __value) {
   if (__indices.length === 1) {
     __container[__indices[0]] = __value;
@@ -2907,33 +4275,156 @@ function __traceWriteValueAtIndices(__container, __indices, __value) {
   return __value;
 }
 
-function __traceReadIndex(__varName, __container, __indices) {
+function __traceReadIndex(__varName, __container, __indices, __indexSources, __location) {
   const __normalized = __traceNormalizeIndices(__indices);
+  const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __normalized?.length ?? 0);
+  const __value = __traceReadValueAtIndices(__container, Array.isArray(__indices) ? __indices : []);
   if (__normalized) {
     __traceRecorder.recordAccess({
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-read' : 'indexed-read',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      value: __value,
+      ...__traceNormalizeSourceLocation(__location),
+    });
+  }
+  return __value;
+}
+
+function* __traceIterableBind(__varName, __iterable, __bindingName, __location) {
+  if (
+    typeof __varName !== 'string' ||
+    typeof __bindingName !== 'string' ||
+    (__iterable === null || __iterable === undefined) ||
+    typeof __iterable[Symbol.iterator] !== 'function'
+  ) {
+    yield* __iterable;
+    return;
+  }
+  let __index = 0;
+  for (const __value of __iterable) {
+    __traceRecorder.recordAccess({
+      variable: __varName,
+      kind: 'indexed-read',
+      indices: [__index],
+      pathDepth: 1,
+      value: __value,
+      binding: { kind: 'iteration', variable: __bindingName },
+      ...__traceNormalizeSourceLocation(__location),
     });
+    __index += 1;
+    yield __value;
+  }
+}
+
+function* __traceIterableBindIndexed(__varName, __iterable, __baseIndices, __indexSources, __bindingName, __location) {
+  if (
+    typeof __varName !== 'string' ||
+    typeof __bindingName !== 'string' ||
+    (__iterable === null || __iterable === undefined) ||
+    typeof __iterable[Symbol.iterator] !== 'function'
+  ) {
+    yield* __iterable;
+    return;
+  }
+  const __base = __traceNormalizeIndices(__baseIndices);
+  const __baseSources = __traceNormalizeIndexSources(__indexSources, __base?.length ?? 0);
+  let __index = 0;
+  for (const __value of __iterable) {
+    if (__base) {
+      const __path = [...__base, __index];
+      const __sources = Array.isArray(__baseSources) ? [...__baseSources, null] : null;
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: __path.length === 2 ? 'cell-read' : 'indexed-read',
+        indices: __path,
+        pathDepth: __path.length,
+        value: __value,
+        ...(Array.isArray(__sources) ? { indexSources: __sources } : {}),
+        binding: { kind: 'iteration', variable: __bindingName },
+        ...__traceNormalizeSourceLocation(__location),
+      });
+    }
+    __index += 1;
+    yield __value;
+  }
+}
+
+function __traceIsMetadataProperty(__container, __propertyName) {
+  if (__propertyName === 'length') {
+    return Array.isArray(__container) || typeof __container === 'string';
+  }
+  if (__propertyName === 'size') {
+    return __traceIsMapLike(__container) || __container instanceof Set;
   }
-  return __traceReadValueAtIndices(__container, Array.isArray(__indices) ? __indices : []);
+  return false;
+}
+
+function __traceNormalizeSourceLocation(__location) {
+  if (!__location || typeof __location !== 'object') return {};
+  const __line = Number(__location.line);
+  const __column = Number(__location.column);
+  return {
+    ...(Number.isFinite(__line) && __line > 0 ? { line: Math.trunc(__line) } : {}),
+    ...(Number.isFinite(__column) && __column >= 0 ? { column: Math.trunc(__column) } : {}),
+  };
+}
+
+function __traceReadProperty(__varName, __container, __propertyName, __scopeOrLocation, __maybeLocation) {
+  const __scope = typeof __scopeOrLocation === 'string' ? __scopeOrLocation : undefined;
+  const __location = typeof __scopeOrLocation === 'string' ? __maybeLocation : __scopeOrLocation;
+  __traceRecorder.recordAccess({
+    variable: __varName,
+    kind: 'indexed-read',
+    indices: [__propertyName],
+    pathDepth: 1,
+    ...(__scope ? { scope: __scope } : {}),
+    ...__traceNormalizeSourceLocation(__location),
+  });
+  return __container?.[__propertyName];
 }
 
-function __traceWriteIndex(__varName, __container, __indices, __value) {
+function __traceWriteIndex(__varName, __container, __indices, __indexSources, __value, __location) {
   const __normalized = __traceNormalizeIndices(__indices);
+  const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __normalized?.length ?? 0);
   const __result = __traceWriteValueAtIndices(__container, Array.isArray(__indices) ? __indices : [], __value);
   if (__normalized) {
     __traceRecorder.recordAccess({
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-write' : 'indexed-write',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      value: __result,
+      ...__traceNormalizeSourceLocation(__location),
     });
   }
   return __result;
 }
 
+function __traceScalarWrite(__varName, __value, __location) {
+  __traceRecorder.recordAccess({
+    variable: __varName,
+    kind: 'indexed-write',
+    value: __value,
+    ...__traceNormalizeSourceLocation(__location),
+  });
+  return __value;
+}
+
+function __traceAssignScalar(__varName, __value, __location) {
+  return __traceScalarWrite(__varName, __value, __location);
+}
+
+function __traceUpdateScalar(__varName, __update, __current, __isPrefix, __location) {
+  const __result = typeof __update === 'function' ? __update() : undefined;
+  const __value = typeof __current === 'function' ? __current() : __result;
+  __traceScalarWrite(__varName, __value, __location);
+  return __isPrefix ? __value : __result;
+}
+
 function __traceApplyAugmentedValue(__current, __op, __rhs) {
   switch (__op) {
     case 'add': return __current + __rhs;
@@ -2951,8 +4442,9 @@ function __traceApplyAugmentedValue(__current, __op, __rhs) {
   }
 }
 
-function __traceAugAssignIndex(__varName, __container, __indices, __op, __rhs) {
+function __traceAugAssignIndex(__varName, __container, __indices, __indexSources, __op, __rhs, __location) {
   const __normalized = __traceNormalizeIndices(__indices);
+  const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __normalized?.length ?? 0);
   const __effectiveIndices = Array.isArray(__indices) ? __indices : [];
   const __current = __traceReadValueAtIndices(__container, __effectiveIndices);
   if (__normalized) {
@@ -2960,7 +4452,9 @@ function __traceAugAssignIndex(__varName, __container, __indices, __op, __rhs) {
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-read' : 'indexed-read',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      ...__traceNormalizeSourceLocation(__location),
     });
   }
   const __next = __traceApplyAugmentedValue(__current, __op, __rhs);
@@ -2970,14 +4464,18 @@ function __traceAugAssignIndex(__varName, __container, __indices, __op, __rhs) {
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-write' : 'indexed-write',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      value: __next,
+      ...__traceNormalizeSourceLocation(__location),
     });
   }
   return __next;
 }
 
-function __traceUpdateIndex(__varName, __container, __indices, __op, __isPrefix) {
+function __traceUpdateIndex(__varName, __container, __indices, __indexSources, __op, __isPrefix, __location) {
   const __normalized = __traceNormalizeIndices(__indices);
+  const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __normalized?.length ?? 0);
   const __effectiveIndices = Array.isArray(__indices) ? __indices : [];
   const __current = __traceReadValueAtIndices(__container, __effectiveIndices);
   if (__normalized) {
@@ -2985,7 +4483,9 @@ function __traceUpdateIndex(__varName, __container, __indices, __op, __isPrefix)
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-read' : 'indexed-read',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      ...__traceNormalizeSourceLocation(__location),
     });
   }
   const __delta = __op === 'dec' ? -1 : 1;
@@ -2996,20 +4496,111 @@ function __traceUpdateIndex(__varName, __container, __indices, __op, __isPrefix)
       variable: __varName,
       kind: __normalized.length === 2 ? 'cell-write' : 'indexed-write',
       indices: __normalized,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
       pathDepth: __normalized.length,
+      value: __next,
+      ...__traceNormalizeSourceLocation(__location),
     });
   }
   return __isPrefix ? __next : __current;
 }
 
-function __traceMutatingCall(__varName, __container, __method, ...__args) {
-  const __result = __container[__method](...__args);
-  if (['push', 'pop', 'shift', 'unshift', 'splice'].includes(__method)) {
+function __traceNormalizeMethodName(__container, __method, __args) {
+  void __container;
+  void __args;
+  return __method;
+}
+
+function __traceStdout(__line, ...__args) {
+  console.log(...__args);
+  __traceRecorder.recordStdout(__line, __args.map((__arg) => String(__arg)).join(' '));
+}
+
+function __traceExceptionValue(__line, __error) {
+  __traceRecorder.recordException(__line, __error);
+  return __error;
+}
+
+function __traceMutatingCall(__varName, __container, __indices, __indexSources, __method, __location, ...__args) {
+  const __sourceLocation = __traceNormalizeSourceLocation(__location);
+  let __target = __container;
+  for (const __index of __indices || []) {
+    __target = __traceIsMapLike(__target) ? __target.get(__index) : __target?.[__index];
+  }
+  const __mayMutate = ['push', 'pop', 'shift', 'unshift', 'splice', 'set', 'add', 'delete', 'clear'].includes(__method);
+  const __result = __target[__method](...__args);
+  if (['push', 'pop', 'shift', 'unshift', 'splice', 'set', 'get', 'has', 'add', 'delete', 'clear'].includes(__method)) {
+    const __path = __indices || [];
+    const __isMapLike = __traceIsMapLike(__target);
+    const __isNestedMap = __path.length > 0 && __traceIsMapLike(__target);
+    if (__isMapLike && __method === 'set') {
+      const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __path.length + 1);
+      const __targetPath = [...__path, __args[0]];
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: 'indexed-write',
+        indices: __targetPath,
+        pathDepth: __path.length + 1,
+        ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
+        value: serializeValue(__args[1]),
+        ...__sourceLocation,
+      });
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: 'mutating-call',
+        method: __traceNormalizeMethodName(__target, __method, __args),
+        args: __args,
+        indices: __targetPath,
+        pathDepth: __path.length + 1,
+        ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
+        ...__sourceLocation,
+      });
+      return __result;
+    }
+    if (__isMapLike && (__method === 'get' || __method === 'has')) {
+      const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __path.length + 1);
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: 'indexed-read',
+        indices: [...__path, __args[0]],
+        pathDepth: __path.length + 1,
+        ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
+        value: serializeValue(__result),
+        ...__sourceLocation,
+      });
+      return __result;
+    }
+    if (__target instanceof Set && __method === 'has') {
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: 'indexed-read',
+        indices: [...__path, __args[0]],
+        pathDepth: __path.length + 1,
+        ...__sourceLocation,
+      });
+      return __result;
+    }
+    if (__path.length > 0) {
+      const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __path.length);
+      __traceRecorder.recordAccess({
+        variable: __varName,
+        kind: 'indexed-read',
+        indices: __path,
+        pathDepth: __path.length,
+        ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
+        ...__sourceLocation,
+      });
+    }
+    const __normalizedSources = __traceNormalizeIndexSources(__indexSources, __path.length);
     __traceRecorder.recordAccess({
       variable: __varName,
       kind: 'mutating-call',
-      method: __method,
-      pathDepth: 1,
+      method: __traceNormalizeMethodName(__target, __method, __args),
+      args: __args,
+      indices: __path,
+      pathDepth: __path.length,
+      ...(Array.isArray(__normalizedSources) ? { indexSources: __normalizedSources } : {}),
+      ...__sourceLocation,
     });
   }
   return __result;
@@ -3021,10 +4612,8 @@ function buildScriptTracingRunner(code) {
     'console',
     '__traceRecorder',
     '__traceCtx',
-    `"use strict";
-${JAVASCRIPT_RUNTIME_PRELUDE}
+    `${JAVASCRIPT_RUNTIME_PRELUDE}
 ${TRACING_RUNTIME_HELPERS_SOURCE}
-let result;
 ${code}
 if (typeof result === 'undefined') {
   return null;
@@ -3042,6 +4631,7 @@ function buildFunctionExecutionRunner(code, executionStyle, argNames) {
       `"use strict";
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 let __target;
 try {
   __target = eval(__functionName);
@@ -3051,7 +4641,7 @@ try {
 if (typeof __target !== 'function') {
   throw new Error('Function "' + __functionName + '" not found');
 }
-return __target(${argNames.join(', ')});`
+return __target(${argNames.map((name) => `__tracecodeMaterializeCustomObject(${name})`).join(', ')});`
     );
   }
 
@@ -3063,6 +4653,7 @@ return __target(${argNames.join(', ')});`
       `"use strict";
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 if (typeof Solution !== 'function') {
   throw new Error('Class "Solution" not found');
 }
@@ -3071,7 +4662,7 @@ const __method = __solver[__functionName];
 if (typeof __method !== 'function') {
   throw new Error('Method "Solution.' + __functionName + '" not found');
 }
-return __method.call(__solver, ${argNames.join(', ')});`
+return __method.call(__solver, ${argNames.map((name) => `__tracecodeMaterializeCustomObject(${name})`).join(', ')});`
     );
   }
 
@@ -3084,6 +4675,7 @@ return __method.call(__solver, ${argNames.join(', ')});`
       `"use strict";
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 if (!Array.isArray(__operations) || !Array.isArray(__arguments)) {
   throw new Error('ops-class execution requires inputs.operations and inputs.arguments (or ops/args)');
 }
@@ -3110,6 +4702,7 @@ for (let __i = 0; __i < __operations.length; __i++) {
   if (!Array.isArray(__callArgs)) {
     __callArgs = [__callArgs];
   }
+  __callArgs = __callArgs.map((__arg) => __tracecodeMaterializeCustomObject(__arg));
   if (__i === 0) {
     __instance = new __targetClass(...__callArgs);
     __out.push(null);
@@ -3139,6 +4732,7 @@ function buildFunctionTracingRunner(code, executionStyle, argNames) {
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${TRACING_RUNTIME_HELPERS_SOURCE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 let __target;
 try {
   __target = eval(__functionName);
@@ -3148,7 +4742,7 @@ try {
 if (typeof __target !== 'function') {
   throw new Error('Function "' + __functionName + '" not found');
 }
-return __target(${argNames.join(', ')});`
+return __target(${argNames.map((name) => `__tracecodeMaterializeCustomObject(${name})`).join(', ')});`
     );
   }
 
@@ -3163,6 +4757,7 @@ return __target(${argNames.join(', ')});`
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${TRACING_RUNTIME_HELPERS_SOURCE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 if (typeof Solution !== 'function') {
   throw new Error('Class "Solution" not found');
 }
@@ -3171,7 +4766,7 @@ const __method = __solver[__functionName];
 if (typeof __method !== 'function') {
   throw new Error('Method "Solution.' + __functionName + '" not found');
 }
-return __method.call(__solver, ${argNames.join(', ')});`
+return __method.call(__solver, ${argNames.map((name) => `__tracecodeMaterializeCustomObject(${name})`).join(', ')});`
     );
   }
 
@@ -3187,6 +4782,7 @@ return __method.call(__solver, ${argNames.join(', ')});`
 ${JAVASCRIPT_RUNTIME_PRELUDE}
 ${TRACING_RUNTIME_HELPERS_SOURCE}
 ${code}
+${CUSTOM_OBJECT_MATERIALIZER_SOURCE}
 if (!Array.isArray(__operations) || !Array.isArray(__arguments)) {
   throw new Error('ops-class execution requires inputs.operations and inputs.arguments (or ops/args)');
 }
@@ -3213,6 +4809,7 @@ for (let __i = 0; __i < __operations.length; __i++) {
   if (!Array.isArray(__callArgs)) {
     __callArgs = [__callArgs];
   }
+  __callArgs = __callArgs.map((__arg) => __tracecodeMaterializeCustomObject(__arg));
   if (__i === 0) {
     __instance = new __targetClass(...__callArgs);
     __out.push(null);
@@ -3291,7 +4888,7 @@ async function executeCode(payload) {
 
     return {
       success: true,
-      output: serializeValue(output),
+      output: serializeOutputValue(output),
       consoleOutput,
     };
   } catch (error) {
@@ -3347,11 +4944,11 @@ async function executeWithTracing(payload) {
         instrumentedCode = await instrumentCodeForTracing(executableCode, language, traceFunctionName);
       }
     } catch (instrumentationError) {
-      if (WORKER_DEBUG) {
-        const message =
-          instrumentationError instanceof Error ? instrumentationError.message : String(instrumentationError);
-        console.warn('[JavaScriptWorker] trace instrumentation failed, using synthetic fallback:', message);
-      }
+      const message =
+        instrumentationError instanceof Error ? instrumentationError.message : String(instrumentationError);
+      emitRuntimeDiagnostic('warn', 'trace-instrumentation-fallback', 'Trace instrumentation failed; using synthetic fallback.', {
+        message,
+      });
     }
 
     if (!instrumentedCode) {
@@ -3359,27 +4956,28 @@ async function executeWithTracing(payload) {
       const executionTimeMs = performanceNow() - startedAt;
 
       if (!fallbackResult.success) {
+        const trace = createEmptyRuntimeTrace(language);
         return {
           success: false,
           error: fallbackResult.error,
           errorLine: fallbackResult.errorLine,
-          trace: [],
+          trace,
           executionTimeMs,
           consoleOutput: fallbackResult.consoleOutput ?? [],
-          lineEventCount: 0,
-          traceStepCount: 0,
+          lineEventCount: trace.lineEventCount,
+          traceStepCount: trace.traceStepCount,
         };
       }
 
-      const syntheticTrace = createSyntheticTrace(payload, fallbackResult);
+      const trace = createSyntheticRuntimeTrace(payload, fallbackResult, language);
       return {
         success: true,
         output: fallbackResult.output,
-        trace: syntheticTrace,
+        trace,
         executionTimeMs,
         consoleOutput: fallbackResult.consoleOutput ?? [],
-        lineEventCount: syntheticTrace.filter((step) => step.event === 'line').length,
-        traceStepCount: syntheticTrace.length,
+        lineEventCount: trace.lineEventCount,
+        traceStepCount: trace.traceStepCount,
       };
     }
 
@@ -3422,21 +5020,23 @@ async function executeWithTracing(payload) {
       );
     }
 
-    const serializedOutput = serializeValue(output);
+    const serializedTraceOutput = serializeValue(output);
+    const serializedOutput = serializeOutputValue(output);
     if (!hasNamedFunction) {
       traceRecorder.popToFunction(traceFunctionName);
-      traceRecorder.recordReturn(traceLineBounds.endLine, serializedOutput, traceFunctionName);
+      traceRecorder.recordReturn(traceLineBounds.endLine, serializedTraceOutput, traceFunctionName);
     }
 
     const executionTimeMs = performanceNow() - startedAt;
+    const trace = traceRecorder.getRuntimeTrace(language, `${language}:run`, defaultRuntimeTraceFile(language));
     return {
       success: true,
       output: serializedOutput,
-      trace: traceRecorder.getTrace(),
+      trace,
       executionTimeMs,
       consoleOutput,
-      lineEventCount: traceRecorder.getLineEventCount(),
-      traceStepCount: traceRecorder.getTraceStepCount(),
+      lineEventCount: trace.lineEventCount,
+      traceStepCount: trace.traceStepCount,
       traceLimitExceeded: traceRecorder.isTraceLimitExceeded(),
       timeoutReason: traceRecorder.getTimeoutReason(),
     };
@@ -3461,16 +5061,17 @@ async function executeWithTracing(payload) {
       traceRecorder.recordException(traceErrorLine, message, traceFunctionName);
     }
 
+    const trace = traceRecorder.getRuntimeTrace(language, `${language}:run`, defaultRuntimeTraceFile(language));
     return {
       success: false,
       output: null,
       error: message,
       errorLine,
-      trace: traceRecorder.getTrace(),
+      trace,
       executionTimeMs,
       consoleOutput,
-      lineEventCount: traceRecorder.getLineEventCount(),
-      traceStepCount: traceRecorder.getTraceStepCount(),
+      lineEventCount: trace.lineEventCount,
+      traceStepCount: trace.traceStepCount,
       traceLimitExceeded,
       timeoutReason,
     };
@@ -3537,11 +5138,37 @@ async function initRuntime() {
 
   isLoading = true;
   const startedAt = performanceNow();
+  ensureJavaScriptLibraries();
   isInitialized = true;
   isLoading = false;
   return { success: true, loadTimeMs: performanceNow() - startedAt };
 }
 
+async function warmRuntime(payload = {}) {
+  const startedAt = performanceNow();
+  const initStartedAt = performanceNow();
+  await initRuntime();
+  const initMs = performanceNow() - initStartedAt;
+  let compilerWarmupMs = 0;
+
+  if (payload?.language === 'typescript' || payload?.preloadTypeScriptCompiler === true) {
+    const compilerStartedAt = performanceNow();
+    await ensureTypeScriptCompiler();
+    compilerWarmupMs = performanceNow() - compilerStartedAt;
+  }
+
+  const totalMs = performanceNow() - startedAt;
+  return {
+    success: true,
+    loadTimeMs: totalMs,
+    timings: {
+      totalMs,
+      initMs,
+      warmupMs: compilerWarmupMs,
+    },
+  };
+}
+
 async function processMessage(data) {
   const { id, type, payload } = data;
 
@@ -3553,6 +5180,12 @@ async function processMessage(data) {
         break;
       }
 
+      case 'warmup': {
+        const result = await warmRuntime(payload);
+        self.postMessage({ id, type: 'warmup-result', payload: result });
+        break;
+      }
+
       case 'execute-with-tracing': {
         const result = await executeWithTracing(payload);
         self.postMessage({ id, type: 'execute-result', payload: result });
@@ -3616,7 +5249,5 @@ self.onmessage = function(event) {
     });
 };
 
-if (WORKER_DEBUG) {
-  console.log('[JavaScriptWorker] ready');
-}
+emitRuntimeDiagnostic('info', 'worker-ready', 'JavaScript worker is ready.');
 self.postMessage({ type: 'worker-ready' });