@tracecode/harness 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -63,7 +63,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // packages/harness-core/src/trace-contract.ts
-var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-03-07";
+var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-03-13";
 var TRACE_EVENTS = /* @__PURE__ */ new Set([
   "line",
   "call",
@@ -106,13 +106,13 @@ function normalizeFunctionName(value) {
   return "<module>";
 }
 function normalizeKind(value) {
-  if (value === "map" || value === "set" || value === "hashmap") {
+  if (value === "map" || value === "set" || value === "hashmap" || value === "object") {
     return value;
   }
   return "hashmap";
 }
 function normalizeObjectKind(value) {
-  if (value === "hashmap" || value === "map" || value === "set" || value === "tree" || value === "linked-list" || value === "graph-adjacency") {
+  if (value === "hashmap" || value === "object" || value === "map" || value === "set" || value === "tree" || value === "linked-list" || value === "graph-adjacency") {
     return value;
   }
   return null;
@@ -190,6 +190,14 @@ function normalizeRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
   return normalizeUnknown(value);
 }
+function normalizeVariableSources(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value).filter(
+    ([name, source]) => typeof name === "string" && name.length > 0 && (source === "user" || source === "user-input" || source === "harness-prelude")
+  ).sort((a, b) => a[0].localeCompare(b[0]));
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+}
 function normalizeCallStackFrame(frame) {
   return {
     function: normalizeFunctionName(frame?.function),
@@ -207,7 +215,9 @@ function normalizeVisualizationPayload(payload) {
       ...item?.highlight ? { highlight: true } : {}
     })) : [],
     ...entry?.highlightedKey !== void 0 ? { highlightedKey: normalizeUnknown(entry.highlightedKey) } : {},
-    ...entry?.deletedKey !== void 0 ? { deletedKey: normalizeUnknown(entry.deletedKey) } : {}
+    ...entry?.deletedKey !== void 0 ? { deletedKey: normalizeUnknown(entry.deletedKey) } : {},
+    ...typeof entry?.objectClassName === "string" && entry.objectClassName.length > 0 ? { objectClassName: entry.objectClassName } : {},
+    ...typeof entry?.objectId === "string" && entry.objectId.length > 0 ? { objectId: entry.objectId } : {}
   })).sort((a, b) => `${a.name}:${a.kind}`.localeCompare(`${b.name}:${b.kind}`)) : [];
   const objectKinds = payload?.objectKinds && typeof payload.objectKinds === "object" ? Object.fromEntries(
     Object.entries(payload.objectKinds).filter(([name]) => typeof name === "string" && name.length > 0).map(([name, kind]) => [name, normalizeObjectKind(kind)]).filter((entry) => entry[1] !== null).sort((a, b) => a[0].localeCompare(b[0]))
@@ -224,11 +234,13 @@ function normalizeTraceStep(step) {
   const normalizedStdoutCount = normalizeOutputLineCount(step?.stdoutLineCount);
   const normalizedVisualization = normalizeVisualizationPayload(step?.visualization);
   const normalizedAccesses = normalizeAccesses(step?.accesses);
+  const normalizedVariableSources = normalizeVariableSources(step?.variableSources);
   return {
     event: normalizeEvent(step?.event),
     line: normalizeLineNumber(step?.line, 1),
     function: normalizeFunctionName(step?.function),
     variables: normalizeRecord(step?.variables),
+    ...normalizedVariableSources ? { variableSources: normalizedVariableSources } : {},
     ...Array.isArray(step?.callStack) && step.callStack.length > 0 ? { callStack: step.callStack.map(normalizeCallStackFrame) } : {},
     ...normalizedAccesses ? { accesses: normalizedAccesses } : {},
     ...step?.returnValue !== void 0 ? { returnValue: normalizeUnknown(step.returnValue) } : {},
@@ -1439,6 +1451,7 @@ var PYTHON_TRACE_SERIALIZE_FUNCTION = `
 # Sentinel to mark skipped values (functions, etc.) - distinct from None
 _SKIP_SENTINEL = "__TRACECODE_SKIP__"
 _MAX_SERIALIZE_DEPTH = 48
+_MAX_OBJECT_FIELDS = 32
 
 def _serialize(obj, depth=0, node_refs=None):
     if node_refs is None:
@@ -1495,6 +1508,36 @@ def _serialize(obj, depth=0, node_refs=None):
         }
         result["next"] = _serialize(obj.next, depth + 1, node_refs)
         return result
+    elif hasattr(obj, '__dict__'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"object-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')
+        result = {
+            "__type__": "object",
+            "__class__": class_name,
+            "__id__": node_id,
+        }
+        try:
+            raw_fields = getattr(obj, '__dict__', None)
+        except Exception:
+            raw_fields = None
+        if isinstance(raw_fields, dict):
+            added = 0
+            for key, value in raw_fields.items():
+                key_str = str(key)
+                if key_str.startswith('_'):
+                    continue
+                if callable(value):
+                    continue
+                result[key_str] = _serialize(value, depth + 1, node_refs)
+                added += 1
+                if added >= _MAX_OBJECT_FIELDS:
+                    result["__truncated__"] = True
+                    break
+        return result
     elif callable(obj):
         # Skip functions entirely - return sentinel
         return _SKIP_SENTINEL
@@ -1858,6 +1901,7 @@ var TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION = `
 # Sentinel to mark skipped values (functions, etc.) - distinct from None
 _SKIP_SENTINEL = "__TRACECODE_SKIP__"
 _MAX_SERIALIZE_DEPTH = 48
+_MAX_OBJECT_FIELDS = 32
 
 def _serialize(obj, depth=0, node_refs=None):
     if node_refs is None:
@@ -1914,6 +1958,36 @@ def _serialize(obj, depth=0, node_refs=None):
         }
         result["next"] = _serialize(obj.next, depth + 1, node_refs)
         return result
+    elif hasattr(obj, '__dict__'):
+        obj_ref = id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = f"object-{obj_ref}"
+        node_refs[obj_ref] = node_id
+        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')
+        result = {
+            "__type__": "object",
+            "__class__": class_name,
+            "__id__": node_id,
+        }
+        try:
+            raw_fields = getattr(obj, '__dict__', None)
+        except Exception:
+            raw_fields = None
+        if isinstance(raw_fields, dict):
+            added = 0
+            for key, value in raw_fields.items():
+                key_str = str(key)
+                if key_str.startswith('_'):
+                    continue
+                if callable(value):
+                    continue
+                result[key_str] = _serialize(value, depth + 1, node_refs)
+                added += 1
+                if added >= _MAX_OBJECT_FIELDS:
+                    result["__truncated__"] = True
+                    break
+        return result
     elif callable(obj):
         # Skip functions entirely - return sentinel
         return _SKIP_SENTINEL
@@ -2143,6 +2217,17 @@ function isLikelyListNodeValue(value) {
   const hasListLinks = "next" in value || "prev" in 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 ctor = value.constructor;
+  const name = typeof ctor?.name === "string" ? ctor.name : "";
+  if (!name || name === "Object" || name === "Array" || name === "Map" || name === "Set") {
+    return null;
+  }
+  return name;
+}
 function serializeValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(), nodeRefState = { ids: /* @__PURE__ */ new Map(), nextId: 1 }) {
   if (depth > 48) return "<max depth>";
   if (value === null || value === void 0) return value;
@@ -2202,6 +2287,28 @@ function serializeValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(),
         ..."prev" in nodeValue ? { prev: serializeValue(nodeValue.prev ?? null, depth + 1, seen, nodeRefState) } : {}
       };
     }
+    const customClassName = getCustomClassName(value);
+    if (customClassName) {
+      const objectValue = value;
+      const existingId = nodeRefState.ids.get(objectValue);
+      if (existingId) {
+        return { __ref__: existingId };
+      }
+      const objectId = `object-${nodeRefState.nextId++}`;
+      nodeRefState.ids.set(objectValue, objectId);
+      if (seen.has(objectValue)) return { __ref__: objectId };
+      seen.add(objectValue);
+      const out2 = {
+        __type__: "object",
+        __class__: customClassName,
+        __id__: objectId
+      };
+      for (const [k, v] of Object.entries(value)) {
+        out2[k] = serializeValue(v, depth + 1, seen, nodeRefState);
+      }
+      seen.delete(objectValue);
+      return out2;
+    }
     if (seen.has(value)) return "<cycle>";
     seen.add(value);
     const out = {};
@@ -2291,6 +2398,180 @@ 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 === void 0) 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 !== void 0) {
+      const leftNode = {
+        val: leftValue,
+        value: leftValue,
+        left: null,
+        right: null
+      };
+      node.left = leftNode;
+      queue.push(leftNode);
+    }
+    if (index >= values.length) break;
+    const rightValue = values[index++];
+    if (rightValue !== null && rightValue !== void 0) {
+      const rightNode = {
+        val: rightValue,
+        value: rightValue,
+        left: null,
+        right: null
+      };
+      node.right = rightNode;
+      queue.push(rightNode);
+    }
+  }
+  return root;
+}
+function materializeTreeInput(value) {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) {
+    return buildTreeNodeFromLevelOrder(value);
+  }
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+  const record = value;
+  if (isLikelyTreeNodeValue(record)) {
+    return {
+      val: record.val ?? record.value ?? null,
+      value: record.val ?? record.value ?? null,
+      left: materializeTreeInput(record.left ?? null),
+      right: materializeTreeInput(record.right ?? null)
+    };
+  }
+  const taggedRecord = value;
+  if (taggedRecord.__type__ === "TreeNode") {
+    return {
+      val: taggedRecord.val ?? taggedRecord.value ?? null,
+      value: taggedRecord.val ?? taggedRecord.value ?? null,
+      left: materializeTreeInput(taggedRecord.left ?? null),
+      right: materializeTreeInput(taggedRecord.right ?? null)
+    };
+  }
+  return value;
+}
+function materializeListInput(value, refs = /* @__PURE__ */ new Map(), materialized = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || value === void 0) 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++) {
+      const nextNode = { val: value[i], value: value[i], next: null };
+      current.next = nextNode;
+      current = nextNode;
+    }
+    return head;
+  }
+  if (!isPlainObjectRecord(value)) {
+    return value;
+  }
+  const record = value;
+  if (typeof record.__ref__ === "string") {
+    return refs.get(record.__ref__) ?? null;
+  }
+  const taggedRecord = value;
+  if (isLikelyListNodeValue(record) || taggedRecord.__type__ === "ListNode") {
+    const existingMaterialized = materialized.get(record);
+    if (existingMaterialized) {
+      return existingMaterialized;
+    }
+    const node = {
+      val: taggedRecord.val ?? taggedRecord.value ?? null,
+      value: taggedRecord.val ?? taggedRecord.value ?? null,
+      next: null
+    };
+    materialized.set(record, node);
+    if (typeof taggedRecord.__id__ === "string" && taggedRecord.__id__.length > 0) {
+      refs.set(taggedRecord.__id__, node);
+    }
+    node.next = materializeListInput(taggedRecord.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 {
+    const ts = await getTypeScriptModule();
+    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 {
+    return {};
+  }
+}
+function applyInputMaterializers(inputs, materializers) {
+  if (Object.keys(materializers).length === 0) return inputs;
+  const next = { ...inputs };
+  for (const [name, kind] of Object.entries(materializers)) {
+    if (!Object.prototype.hasOwnProperty.call(next, name)) continue;
+    next[name] = kind === "tree" ? materializeTreeInput(next[name]) : materializeListInput(next[name]);
+  }
+  return next;
+}
 function collectSimpleParameterNames(ts, functionLikeNode) {
   const names = [];
   for (const parameter of functionLikeNode.parameters ?? []) {
@@ -2344,14 +2625,20 @@ function findFunctionLikeNode(ts, sourceFile, functionName, executionStyle) {
   visit(sourceFile);
   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;
   }
   try {
     const ts = await getTypeScriptModule();
-    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;
@@ -2495,20 +2782,22 @@ async function transpileTypeScript(code) {
   }
   return transpiled.outputText;
 }
-async function executeJavaScriptCode(code, functionName, inputs, executionStyle = "function") {
+async function executeJavaScriptCode(code, functionName, inputs, executionStyle = "function", language = "javascript") {
   const consoleOutput = [];
   const consoleProxy = createConsoleProxy(consoleOutput);
   const normalizedInputs = normalizeInputs(inputs);
+  const materializers = await resolveInputMaterializers(code, functionName, executionStyle, language);
+  const materializedInputs = applyInputMaterializers(normalizedInputs, materializers);
   try {
     let output;
     if (executionStyle === "ops-class") {
-      const { operations, argumentsList } = getOpsClassInputs(normalizedInputs);
+      const { operations, argumentsList } = getOpsClassInputs(materializedInputs);
       const runner = buildRunner(code, executionStyle, []);
       output = await Promise.resolve(runner(consoleProxy, functionName, operations, argumentsList));
     } else {
-      const inputKeys = await resolveOrderedInputKeys(code, 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 = buildRunner(code, executionStyle, argNames);
       output = await Promise.resolve(runner(consoleProxy, functionName, ...argValues));
     }
@@ -2527,9 +2816,9 @@ async function executeJavaScriptCode(code, functionName, inputs, executionStyle
     };
   }
 }
-async function executeJavaScriptWithTracing(code, functionName, inputs, executionStyle = "function") {
+async function executeJavaScriptWithTracing(code, functionName, inputs, executionStyle = "function", language = "javascript") {
   const startedAt = performanceNow();
-  const codeResult = await executeJavaScriptCode(code, functionName ?? "", inputs, executionStyle);
+  const codeResult = await executeJavaScriptCode(code, functionName ?? "", inputs, executionStyle, language);
   const executionTimeMs = performanceNow() - startedAt;
   if (!codeResult.success) {
     return {
@@ -2554,8 +2843,11 @@ async function executeJavaScriptWithTracing(code, functionName, inputs, executio
   };
 }
 async function executeTypeScriptCode(code, functionName, inputs, executionStyle = "function") {
+  const normalizedInputs = normalizeInputs(inputs);
+  const materializers = await resolveInputMaterializers(code, functionName, executionStyle, "typescript");
+  const materializedInputs = applyInputMaterializers(normalizedInputs, materializers);
   const transpiledCode = await transpileTypeScript(code);
-  return executeJavaScriptCode(transpiledCode, functionName, inputs, executionStyle);
+  return executeJavaScriptCode(transpiledCode, functionName, materializedInputs, executionStyle, "typescript");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {