@tracecode/harness 0.4.0 → 0.5.0

package/workers/javascript/javascript-worker.js

@@ -141,6 +141,17 @@ function isLikelyListNodeValue(value) {
   return hasValue && hasListLinks && !hasTreeLinks;
 }
 
+function getCustomClassName(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  if (value instanceof Map || value instanceof Set) return null;
+  if (isLikelyTreeNodeValue(value) || isLikelyListNodeValue(value)) return null;
+  const name = typeof value?.constructor?.name === 'string' ? value.constructor.name : '';
+  if (!name || name === 'Object' || name === 'Array' || name === 'Map' || name === 'Set') {
+    return null;
+  }
+  return name;
+}
+
 function serializeValue(
   value,
   depth = 0,
@@ -209,6 +220,30 @@ function serializeValue(
       };
     }
 
+    const customClassName = getCustomClassName(value);
+    if (customClassName) {
+      const existingId = nodeRefState.ids.get(value);
+      if (existingId) {
+        return { __ref__: existingId };
+      }
+
+      const objectId = `object-${nodeRefState.nextId++}`;
+      nodeRefState.ids.set(value, objectId);
+
+      if (seen.has(value)) return { __ref__: objectId };
+      seen.add(value);
+      const out = {
+        __type__: 'object',
+        __class__: customClassName,
+        __id__: objectId,
+      };
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = serializeValue(v, depth + 1, seen, nodeRefState);
+      }
+      seen.delete(value);
+      return out;
+    }
+
     if (seen.has(value)) return '<cycle>';
     seen.add(value);
     const out = {};
@@ -222,6 +257,67 @@ function serializeValue(
   return String(value);
 }
 
+function serializeTopLevelValue(value, nodeRefState) {
+  if (value === null || value === undefined) return value;
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    return serializeValue(value, 0, new WeakSet(), nodeRefState);
+  }
+
+  if (isLikelyTreeNodeValue(value) || isLikelyListNodeValue(value)) {
+    const objectValue = value;
+    const nodeValue = value;
+    const isTree = isLikelyTreeNodeValue(value);
+    let nodeId = nodeRefState.ids.get(objectValue);
+    if (!nodeId) {
+      nodeId = `${isTree ? 'tree' : 'list'}-${nodeRefState.nextId++}`;
+      nodeRefState.ids.set(objectValue, nodeId);
+    }
+
+    if (isTree) {
+      return {
+        __type__: 'TreeNode',
+        __id__: nodeId,
+        val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
+        left: serializeValue(nodeValue.left ?? null, 1, new WeakSet(), nodeRefState),
+        right: serializeValue(nodeValue.right ?? null, 1, new WeakSet(), nodeRefState),
+      };
+    }
+
+    return {
+      __type__: 'ListNode',
+      __id__: nodeId,
+      val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, 1, new WeakSet(), nodeRefState),
+      next: serializeValue(nodeValue.next ?? null, 1, new WeakSet(), nodeRefState),
+      ...('prev' in nodeValue
+        ? { prev: serializeValue(nodeValue.prev ?? null, 1, new WeakSet(), nodeRefState) }
+        : {}),
+    };
+  }
+
+  const customClassName = getCustomClassName(value);
+  if (customClassName) {
+    const objectValue = value;
+    let objectId = nodeRefState.ids.get(objectValue);
+    if (!objectId) {
+      objectId = `object-${nodeRefState.nextId++}`;
+      nodeRefState.ids.set(objectValue, objectId);
+    }
+    const seen = new WeakSet();
+    seen.add(objectValue);
+    const out = {
+      __type__: 'object',
+      __class__: customClassName,
+      __id__: objectId,
+    };
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = serializeValue(v, 1, seen, nodeRefState);
+    }
+    return out;
+  }
+
+  return serializeValue(value, 0, new WeakSet(), nodeRefState);
+}
+
 function extractUserErrorLine(error) {
   if (error && typeof error === 'object' && '__tracecodeLine' in error) {
     const line = Number(error.__tracecodeLine);
@@ -314,6 +410,182 @@ function normalizeInputs(inputs) {
   return hydrated;
 }
 
+function buildTreeNodeFromLevelOrder(values) {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  const firstValue = values[0];
+  if (firstValue === null || firstValue === undefined) return null;
+  const root = { val: firstValue, value: firstValue, left: null, right: null };
+  const queue = [root];
+  let index = 1;
+
+  while (queue.length > 0 && index < values.length) {
+    const node = queue.shift();
+    if (!node) break;
+
+    const leftValue = values[index++];
+    if (leftValue !== null && leftValue !== undefined) {
+      node.left = { val: leftValue, value: leftValue, left: null, right: null };
+      queue.push(node.left);
+    }
+
+    if (index >= values.length) break;
+
+    const rightValue = values[index++];
+    if (rightValue !== null && rightValue !== undefined) {
+      node.right = { val: rightValue, value: rightValue, left: null, right: null };
+      queue.push(node.right);
+    }
+  }
+
+  return root;
+}
+
+function materializeTreeInput(value) {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) {
+    return buildTreeNodeFromLevelOrder(value);
+  }
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+  if (isLikelyTreeNodeValue(value) || value.__type__ === 'TreeNode') {
+    const nodeValue = value;
+    return {
+      val: nodeValue.val ?? nodeValue.value ?? null,
+      value: nodeValue.val ?? nodeValue.value ?? null,
+      left: materializeTreeInput(nodeValue.left ?? null),
+      right: materializeTreeInput(nodeValue.right ?? null),
+    };
+  }
+  return value;
+}
+
+function materializeListInput(value, refs = new Map(), materialized = new WeakMap()) {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return null;
+    const head = { val: value[0], value: value[0], next: null };
+    let current = head;
+    for (let i = 1; i < value.length; i++) {
+      current.next = { val: value[i], value: value[i], next: null };
+      current = current.next;
+    }
+    return head;
+  }
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+  if (typeof value.__ref__ === 'string') {
+    return refs.get(value.__ref__) ?? null;
+  }
+  if (isLikelyListNodeValue(value) || value.__type__ === 'ListNode') {
+    const existingMaterialized = materialized.get(value);
+    if (existingMaterialized) {
+      return existingMaterialized;
+    }
+    const node = {
+      val: value.val ?? value.value ?? null,
+      value: value.val ?? value.value ?? null,
+      next: null,
+    };
+    materialized.set(value, node);
+    if (typeof value.__id__ === 'string' && value.__id__.length > 0) {
+      refs.set(value.__id__, node);
+    }
+    node.next = materializeListInput(value.next ?? null, refs, materialized);
+    return node;
+  }
+  return value;
+}
+
+function detectMaterializerKind(ts, typeNode) {
+  if (!typeNode) return null;
+  if (ts.isParenthesizedTypeNode(typeNode)) {
+    return detectMaterializerKind(ts, typeNode.type);
+  }
+  if (ts.isUnionTypeNode(typeNode)) {
+    for (const child of typeNode.types) {
+      const resolved = detectMaterializerKind(ts, child);
+      if (resolved) return resolved;
+    }
+    return null;
+  }
+  if (ts.isTypeReferenceNode(typeNode)) {
+    const typeNameText = typeNode.typeName.getText();
+    if (typeNameText === 'TreeNode') return 'tree';
+    if (typeNameText === 'ListNode') return 'list';
+    return null;
+  }
+  return null;
+}
+
+function collectInputMaterializers(ts, functionLikeNode) {
+  const out = {};
+  for (const parameter of functionLikeNode.parameters ?? []) {
+    if (!ts.isIdentifier(parameter.name)) continue;
+    if (parameter.name.text === 'this') continue;
+    const kind = detectMaterializerKind(ts, parameter.type);
+    if (kind) {
+      out[parameter.name.text] = kind;
+    }
+  }
+  return out;
+}
+
+async function resolveInputMaterializers(code, functionName, executionStyle, language) {
+  if (!functionName || executionStyle === 'ops-class' || language !== 'typescript') {
+    return {};
+  }
+
+  try {
+    await ensureTypeScriptCompiler();
+    const ts = getTypeScriptCompiler();
+    if (!ts) return {};
+
+    const sourceFile = ts.createSourceFile(
+      'runtime-input.ts',
+      code,
+      ts.ScriptTarget.ES2020,
+      true,
+      ts.ScriptKind.TS
+    );
+    const target = findFunctionLikeNode(ts, sourceFile, functionName, executionStyle);
+    if (!target) return {};
+    return collectInputMaterializers(ts, target);
+  } catch (_error) {
+    return {};
+  }
+}
+
+function applyInputMaterializers(inputs, materializers) {
+  const next = { ...inputs };
+  const combined = { ...inferFallbackInputMaterializers(inputs), ...(materializers ?? {}) };
+  if (Object.keys(combined).length === 0) return inputs;
+  for (const [name, kind] of Object.entries(combined)) {
+    if (!Object.prototype.hasOwnProperty.call(next, name)) continue;
+    next[name] = kind === 'tree' ? materializeTreeInput(next[name]) : materializeListInput(next[name]);
+  }
+  return next;
+}
+
+function inferFallbackInputMaterializers(inputs) {
+  if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) return {};
+  const inferred = {};
+  for (const [name, value] of Object.entries(inputs)) {
+    const lowerName = String(name || '').toLowerCase();
+    if (!Array.isArray(value)) continue;
+    if (lowerName === 'root' || lowerName.endsWith('root') || lowerName.includes('tree')) {
+      inferred[name] = 'tree';
+      continue;
+    }
+    if (lowerName === 'head' || lowerName.endsWith('head') || lowerName.includes('list')) {
+      inferred[name] = 'list';
+      continue;
+    }
+  }
+  return inferred;
+}
+
 function collectSimpleParameterNames(ts, functionLikeNode) {
   const names = [];
 
@@ -391,7 +663,7 @@ function findFunctionLikeNode(ts, sourceFile, functionName, executionStyle) {
   return found;
 }
 
-async function resolveOrderedInputKeys(code, functionName, inputs, executionStyle) {
+async function resolveOrderedInputKeys(code, functionName, inputs, executionStyle, language = 'javascript') {
   const fallbackKeys = Object.keys(inputs ?? {});
   if (!functionName || executionStyle === 'ops-class' || fallbackKeys.length <= 1) {
     return fallbackKeys;
@@ -404,7 +676,13 @@ async function resolveOrderedInputKeys(code, functionName, inputs, executionStyl
       return fallbackKeys;
     }
 
-    const sourceFile = ts.createSourceFile('runtime-input.js', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.JS);
+    const sourceFile = ts.createSourceFile(
+      `runtime-input.${language === 'typescript' ? 'ts' : 'js'}`,
+      code,
+      ts.ScriptTarget.ES2020,
+      true,
+      language === 'typescript' ? ts.ScriptKind.TS : ts.ScriptKind.JS
+    );
     const target = findFunctionLikeNode(ts, sourceFile, functionName, executionStyle);
     if (!target) {
       return fallbackKeys;
@@ -553,8 +831,13 @@ function createTraceRecorder(options = {}) {
     const result = {};
     for (const [key, variableValue] of Object.entries(value)) {
       if (variableValue === undefined) continue;
+      if (typeof variableValue === 'function') continue;
       try {
-        result[key] = serializeValue(variableValue, 0, new WeakSet(), stableNodeRefState);
+        const refState =
+          key === 'this' && variableValue && typeof variableValue === 'object'
+            ? { ids: new Map(), nextId: 1 }
+            : stableNodeRefState;
+        result[key] = serializeTopLevelValue(variableValue, refState);
       } catch {
         // Skip variables that throw during serialization (e.g. transient proxy/getter failures).
       }
@@ -621,6 +904,7 @@ function createTraceRecorder(options = {}) {
   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;
 
@@ -673,8 +957,53 @@ function createTraceRecorder(options = {}) {
       }
 
       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({
@@ -756,6 +1085,15 @@ function createTraceRecorder(options = {}) {
     return callStack[callStack.length - 1]?.id;
   }
 
+  function normalizeFrameMatchKey(functionName) {
+    const normalized =
+      typeof functionName === 'string' && functionName.length > 0 ? functionName : '<module>';
+    if (normalized === 'constructor' || normalized.endsWith('.constructor')) {
+      return 'constructor';
+    }
+    return normalized;
+  }
+
   function flushPendingAccesses(frameId) {
     if (frameId === undefined || frameId === null) {
       return undefined;
@@ -852,8 +1190,49 @@ function createTraceRecorder(options = {}) {
       return '<module>';
     }
 
+    const normalizedMatchKey = normalizeFrameMatchKey(normalizedFunctionName);
+    let matchingFrameIndex = -1;
+    for (let index = callStack.length - 1; index >= 0; index -= 1) {
+      const frame = callStack[index];
+      if (!frame) continue;
+      if (
+        frame.function === normalizedFunctionName ||
+        normalizeFrameMatchKey(frame.function) === normalizedMatchKey
+      ) {
+        matchingFrameIndex = index;
+        break;
+      }
+    }
+
+    if (matchingFrameIndex >= 0) {
+      while (callStack.length - 1 > matchingFrameIndex) {
+        const frame = callStack.pop();
+        if (frame?.id !== undefined) {
+          pendingAccessesByFrame.delete(frame.id);
+        }
+      }
+    }
+
     const topFrame = callStack[callStack.length - 1];
-    if (!topFrame || topFrame.function !== normalizedFunctionName) {
+    if (topFrame && normalizeFrameMatchKey(topFrame.function) === normalizedMatchKey) {
+      if (
+        normalizedMatchKey === 'constructor' &&
+        topFrame.function !== normalizedFunctionName &&
+        normalizedFunctionName.endsWith('.constructor')
+      ) {
+        topFrame.function = normalizedFunctionName;
+      }
+      if (
+        Object.keys(topFrame.args ?? {}).length === 0 &&
+        inferredArgs &&
+        typeof inferredArgs === 'object'
+      ) {
+        topFrame.args = sanitizeVariables(inferredArgs);
+      }
+      return normalizedFunctionName;
+    }
+
+    if (!topFrame) {
       const callLine = normalizeLine(functionStartLine, lineNumber);
       const inferredFrame = {
         id: nextFrameId++,
@@ -870,13 +1249,7 @@ function createTraceRecorder(options = {}) {
         callStack: snapshotCallStack(),
         visualization: buildVisualizationPayload(inferredArgs),
       });
-    } else if (
-      topFrame.function === normalizedFunctionName &&
-      Object.keys(topFrame.args ?? {}).length === 0 &&
-      inferredArgs &&
-      typeof inferredArgs === 'object'
-    ) {
-      topFrame.args = sanitizeVariables(inferredArgs);
+      return normalizedFunctionName;
     }
 
     return normalizedFunctionName;
@@ -1381,9 +1754,16 @@ function inferTraceFunctionName(ts, node, fallbackFunctionName) {
   }
 
   if (ts.isConstructorDeclaration(node)) {
+    const originalNode = ts.getOriginalNode(node);
+    const classLikeParent =
+      node.parent && ts.isClassLike(node.parent)
+        ? node.parent
+        : originalNode?.parent && ts.isClassLike(originalNode.parent)
+          ? originalNode.parent
+          : null;
     const className =
-      node.parent && ts.isClassLike(node.parent) && node.parent.name && ts.isIdentifier(node.parent.name)
-        ? node.parent.name.text
+      classLikeParent && classLikeParent.name && ts.isIdentifier(classLikeParent.name)
+        ? classLikeParent.name.text
         : null;
     return className ? `${className}.constructor` : 'constructor';
   }
@@ -1407,53 +1787,57 @@ function inferTraceFunctionName(ts, node, fallbackFunctionName) {
 function buildLineFunctionMap(ts, sourceFile, defaultFunctionName) {
   const lineFunctionMap = new Map();
 
-  function mapStatementLine(statementNode, functionName, functionStartLine) {
+  function mapStatementLine(statementNode, functionName, functionStartLine, includeThisSnapshot) {
     const lineNumber = sourceFile.getLineAndCharacterOfPosition(statementNode.getStart(sourceFile)).line + 1;
     if (!lineFunctionMap.has(lineNumber)) {
       lineFunctionMap.set(lineNumber, {
         functionName,
         functionStartLine,
+        includeThisSnapshot,
       });
     }
   }
 
-  function visitNode(node, currentFunctionName, currentFunctionStartLine) {
+  function visitNode(node, currentFunctionName, currentFunctionStartLine, includeThisSnapshot) {
     const nextFunctionName = ts.isFunctionLike(node)
       ? inferTraceFunctionName(ts, node, currentFunctionName)
       : currentFunctionName;
     const nextFunctionStartLine = ts.isFunctionLike(node)
       ? sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1
       : currentFunctionStartLine;
+    const nextIncludeThisSnapshot = ts.isFunctionLike(node)
+      ? functionLikeSnapshotsReceiver(ts, node)
+      : includeThisSnapshot;
 
     if (ts.isSourceFile(node) || ts.isBlock(node)) {
       for (const statement of node.statements) {
-        visitNode(statement, currentFunctionName, currentFunctionStartLine);
+        visitNode(statement, currentFunctionName, currentFunctionStartLine, includeThisSnapshot);
       }
       return;
     }
 
     if (ts.isCaseClause(node) || ts.isDefaultClause(node)) {
       for (const statement of node.statements) {
-        visitNode(statement, currentFunctionName, currentFunctionStartLine);
+        visitNode(statement, currentFunctionName, currentFunctionStartLine, includeThisSnapshot);
       }
       return;
     }
 
     if (ts.isFunctionLike(node)) {
       if (node.body) {
-        visitNode(node.body, nextFunctionName, nextFunctionStartLine);
+        visitNode(node.body, nextFunctionName, nextFunctionStartLine, nextIncludeThisSnapshot);
       }
       return;
     }
 
     if (ts.isStatement(node) && shouldTraceStatement(ts, node)) {
-      mapStatementLine(node, currentFunctionName, currentFunctionStartLine);
+      mapStatementLine(node, currentFunctionName, currentFunctionStartLine, includeThisSnapshot);
     }
 
-    ts.forEachChild(node, (child) => visitNode(child, currentFunctionName, currentFunctionStartLine));
+    ts.forEachChild(node, (child) => visitNode(child, currentFunctionName, currentFunctionStartLine, includeThisSnapshot));
   }
 
-  visitNode(sourceFile, defaultFunctionName, 1);
+  visitNode(sourceFile, defaultFunctionName, 1, false);
   return lineFunctionMap;
 }
 
@@ -1657,7 +2041,7 @@ function createTraceMutatingCallExpression(ts, variableName, methodName, args) {
   );
 }
 
-function createSnapshotFactory(ts, variableNames) {
+function createSnapshotFactory(ts, variableNames, includeThis = false) {
   const properties = variableNames.map((name) =>
     ts.factory.createPropertyAssignment(
       ts.factory.createIdentifier(name),
@@ -1681,6 +2065,31 @@ function createSnapshotFactory(ts, variableNames) {
     )
   );
 
+  if (includeThis) {
+    properties.push(
+      ts.factory.createPropertyAssignment(
+        ts.factory.createStringLiteral('this'),
+        ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createIdentifier('__traceRecorder'),
+            ts.factory.createIdentifier('read')
+          ),
+          undefined,
+          [
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              [],
+              undefined,
+              ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+              ts.factory.createThis()
+            ),
+          ]
+        )
+      )
+    );
+  }
+
   return ts.factory.createArrowFunction(
     undefined,
     undefined,
@@ -1693,11 +2102,21 @@ function createSnapshotFactory(ts, variableNames) {
   );
 }
 
+function functionLikeSnapshotsReceiver(ts, functionLikeNode) {
+  return (
+    ts.isMethodDeclaration(functionLikeNode) ||
+    ts.isConstructorDeclaration(functionLikeNode) ||
+    ts.isGetAccessorDeclaration(functionLikeNode) ||
+    ts.isSetAccessorDeclaration(functionLikeNode)
+  );
+}
+
 function createTraceLineStatement(ts, sourceFile, statement, variableNames, lineFunctionMap, defaultFunctionName) {
   const lineNumber = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile)).line + 1;
   const functionContext = lineFunctionMap.get(lineNumber);
   const traceFunctionName = functionContext?.functionName ?? defaultFunctionName;
   const traceFunctionStartLine = functionContext?.functionStartLine ?? lineNumber;
+  const includeThisSnapshot = Boolean(functionContext?.includeThisSnapshot);
   return ts.factory.createExpressionStatement(
     ts.factory.createCallExpression(
       ts.factory.createPropertyAccessExpression(
@@ -1707,7 +2126,7 @@ function createTraceLineStatement(ts, sourceFile, statement, variableNames, line
       undefined,
       [
         ts.factory.createNumericLiteral(lineNumber),
-        createSnapshotFactory(ts, variableNames),
+        createSnapshotFactory(ts, variableNames, includeThisSnapshot),
         ts.factory.createStringLiteral(traceFunctionName),
         ts.factory.createNumericLiteral(traceFunctionStartLine),
       ]
@@ -1917,6 +2336,7 @@ function wrapFunctionBodyForTracing(
   const functionEndPosition = Math.max(functionBody.getEnd() - 1, functionBody.getStart(sourceFile));
   const functionEndLine = sourceFile.getLineAndCharacterOfPosition(functionEndPosition).line + 1;
   const parameterNames = collectFunctionParameterNames(ts, functionLikeNode);
+  const includeThisSnapshot = functionLikeSnapshotsReceiver(ts, functionLikeNode);
 
   const rewrittenBody = rewriteFunctionReturnStatements(
     ts,
@@ -1927,7 +2347,7 @@ function wrapFunctionBodyForTracing(
   );
 
   const argsSnapshotExpression = ts.factory.createCallExpression(
-    ts.factory.createParenthesizedExpression(createSnapshotFactory(ts, parameterNames)),
+    ts.factory.createParenthesizedExpression(createSnapshotFactory(ts, parameterNames, includeThisSnapshot)),
     undefined,
     []
   );
@@ -2554,6 +2974,8 @@ async function executeCode(payload) {
   const consoleOutput = [];
   const consoleProxy = createConsoleProxy(consoleOutput);
   const normalizedInputs = normalizeInputs(inputs);
+  const materializers = await resolveInputMaterializers(code, functionName, executionStyle, language);
+  const materializedInputs = applyInputMaterializers(normalizedInputs, materializers);
 
   try {
     if (typeof code !== 'string') {
@@ -2569,13 +2991,13 @@ async function executeCode(payload) {
 
     if (hasNamedFunction) {
       if (executionStyle === 'ops-class') {
-        const { operations, argumentsList } = getOpsClassInputs(normalizedInputs);
+        const { operations, argumentsList } = getOpsClassInputs(materializedInputs);
         const runner = buildFunctionExecutionRunner(executableCode, executionStyle, []);
         output = await Promise.resolve(runner(consoleProxy, functionName, operations, argumentsList));
       } else {
-        const inputKeys = await resolveOrderedInputKeys(executableCode, functionName, normalizedInputs, executionStyle);
+        const inputKeys = await resolveOrderedInputKeys(code, functionName, materializedInputs, executionStyle, language);
         const argNames = inputKeys.map((_, index) => `__arg${index}`);
-        const argValues = inputKeys.map((key) => normalizedInputs[key]);
+        const argValues = inputKeys.map((key) => materializedInputs[key]);
         const runner = buildFunctionExecutionRunner(executableCode, executionStyle, argNames);
         output = await Promise.resolve(runner(consoleProxy, functionName, ...argValues));
       }
@@ -2617,6 +3039,8 @@ async function executeWithTracing(payload) {
   const consoleOutput = [];
   const consoleProxy = createConsoleProxy(consoleOutput);
   const normalizedInputs = normalizeInputs(inputs);
+  const materializers = await resolveInputMaterializers(code, functionName, executionStyle, language);
+  const materializedInputs = applyInputMaterializers(normalizedInputs, materializers);
   const hasNamedFunction = typeof functionName === 'string' && functionName.length > 0;
   const traceFunctionName = hasNamedFunction ? functionName : '<module>';
   const traceRecorder = createTraceRecorder(options);
@@ -2680,14 +3104,14 @@ async function executeWithTracing(payload) {
     }
 
     const serializedInputs = {};
-    for (const [key, value] of Object.entries(normalizedInputs)) {
+    for (const [key, value] of Object.entries(materializedInputs)) {
       serializedInputs[key] = serializeValue(value);
     }
 
     let output;
     if (hasNamedFunction) {
       if (executionStyle === 'ops-class') {
-        const { operations, argumentsList } = getOpsClassInputs(normalizedInputs);
+        const { operations, argumentsList } = getOpsClassInputs(materializedInputs);
         const runner = buildFunctionTracingRunner(instrumentedCode, executionStyle, []);
         output = await Promise.resolve(
           runner(
@@ -2700,9 +3124,9 @@ async function executeWithTracing(payload) {
           )
         );
       } else {
-        const inputKeys = await resolveOrderedInputKeys(executableCode, functionName, normalizedInputs, executionStyle);
+        const inputKeys = await resolveOrderedInputKeys(code, functionName, materializedInputs, executionStyle, language);
         const argNames = inputKeys.map((_, index) => `__arg${index}`);
-        const argValues = inputKeys.map((key) => normalizedInputs[key]);
+        const argValues = inputKeys.map((key) => materializedInputs[key]);
         const runner = buildFunctionTracingRunner(instrumentedCode, executionStyle, argNames);
         output = await Promise.resolve(
           runner(consoleProxy, traceRecorder, { functionName: traceFunctionName }, functionName, ...argValues)