@tracecode/harness 0.4.0 → 0.5.1

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-export { L as Language, a as LanguageRuntimeProfile, R as RuntimeCapabilities, b as RuntimeClient, c as RuntimeExecutionStyle, d as RuntimeMaturity, T as TraceExecutionOptions } from './runtime-types-Dvgn07z9.cjs';
-export { C as CallStackFrame, a as CodeExecutionResult, E as ExecutionResult, b as ExecutionStatus, P as ProcessedStep, c as PyodideState, R as RawTraceStep, d as RuntimeHashMapEntry, e as RuntimeHashMapVisualization, f as RuntimeObjectKind, g as RuntimeTraceAccessEvent, h as RuntimeTraceAccessKind, i as RuntimeVisualizationPayload, T as TestResult } from './types-Bzr1Ohcf.cjs';
+export { L as Language, a as LanguageRuntimeProfile, R as RuntimeCapabilities, b as RuntimeClient, c as RuntimeExecutionStyle, d as RuntimeMaturity, T as TraceExecutionOptions } from './runtime-types--lBQ6rYu.cjs';
+export { C as CallStackFrame, a as CodeExecutionResult, E as ExecutionResult, b as ExecutionStatus, P as ProcessedStep, c as PyodideState, R as RawTraceStep, d as RuntimeHashMapEntry, e as RuntimeHashMapVisualization, f as RuntimeObjectKind, g as RuntimeTraceAccessEvent, h as RuntimeTraceAccessKind, i as RuntimeVisualizationPayload, T as TestResult } from './types-DwIYM3Ku.cjs';
 export { RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION, RuntimeTraceContractCallStackFrame, RuntimeTraceContractEvent, RuntimeTraceContractHashMap, RuntimeTraceContractHashMapEntry, RuntimeTraceContractResult, RuntimeTraceContractStep, RuntimeTraceContractVisualization, adaptJavaScriptTraceExecutionResult, adaptPythonTraceExecutionResult, adaptTraceExecutionResult, normalizeRuntimeTraceContract, stableStringifyRuntimeTraceContract } from './core.cjs';
 export { BrowserHarness, BrowserHarnessAssetOverrides, BrowserHarnessAssets, CreateBrowserHarnessOptions, DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS, LANGUAGE_RUNTIME_PROFILES, SUPPORTED_LANGUAGES, assertRuntimeRequestSupported, createBrowserHarness, getLanguageRuntimeProfile, getSupportedLanguageProfiles, isLanguageSupported, resolveBrowserHarnessAssets } from './browser.cjs';
 export { PYTHON_CLASS_DEFINITIONS, PYTHON_CONVERSION_HELPERS, PYTHON_EXECUTE_SERIALIZE_FUNCTION, PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION, PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION, PYTHON_SERIALIZE_FUNCTION, PYTHON_TRACE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_CLASS_DEFINITIONS, TEMPLATE_PYTHON_CONVERSION_HELPERS, TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION, generateConversionCode, generateInputSetup, generateSolutionScript, identifyConversions, templateToPythonLiteral, toPythonLiteral } from './python.cjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { L as Language, a as LanguageRuntimeProfile, R as RuntimeCapabilities, b as RuntimeClient, c as RuntimeExecutionStyle, d as RuntimeMaturity, T as TraceExecutionOptions } from './runtime-types-C7d1LFbx.js';
-export { C as CallStackFrame, a as CodeExecutionResult, E as ExecutionResult, b as ExecutionStatus, P as ProcessedStep, c as PyodideState, R as RawTraceStep, d as RuntimeHashMapEntry, e as RuntimeHashMapVisualization, f as RuntimeObjectKind, g as RuntimeTraceAccessEvent, h as RuntimeTraceAccessKind, i as RuntimeVisualizationPayload, T as TestResult } from './types-Bzr1Ohcf.js';
+export { L as Language, a as LanguageRuntimeProfile, R as RuntimeCapabilities, b as RuntimeClient, c as RuntimeExecutionStyle, d as RuntimeMaturity, T as TraceExecutionOptions } from './runtime-types-DtaaAhHL.js';
+export { C as CallStackFrame, a as CodeExecutionResult, E as ExecutionResult, b as ExecutionStatus, P as ProcessedStep, c as PyodideState, R as RawTraceStep, d as RuntimeHashMapEntry, e as RuntimeHashMapVisualization, f as RuntimeObjectKind, g as RuntimeTraceAccessEvent, h as RuntimeTraceAccessKind, i as RuntimeVisualizationPayload, T as TestResult } from './types-DwIYM3Ku.js';
 export { RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION, RuntimeTraceContractCallStackFrame, RuntimeTraceContractEvent, RuntimeTraceContractHashMap, RuntimeTraceContractHashMapEntry, RuntimeTraceContractResult, RuntimeTraceContractStep, RuntimeTraceContractVisualization, adaptJavaScriptTraceExecutionResult, adaptPythonTraceExecutionResult, adaptTraceExecutionResult, normalizeRuntimeTraceContract, stableStringifyRuntimeTraceContract } from './core.js';
 export { BrowserHarness, BrowserHarnessAssetOverrides, BrowserHarnessAssets, CreateBrowserHarnessOptions, DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS, LANGUAGE_RUNTIME_PROFILES, SUPPORTED_LANGUAGES, assertRuntimeRequestSupported, createBrowserHarness, getLanguageRuntimeProfile, getSupportedLanguageProfiles, isLanguageSupported, resolveBrowserHarnessAssets } from './browser.js';
 export { PYTHON_CLASS_DEFINITIONS, PYTHON_CONVERSION_HELPERS, PYTHON_EXECUTE_SERIALIZE_FUNCTION, PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION, PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION, PYTHON_SERIALIZE_FUNCTION, PYTHON_TRACE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_CLASS_DEFINITIONS, TEMPLATE_PYTHON_CONVERSION_HELPERS, TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_SERIALIZE_FUNCTION, TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION, generateConversionCode, generateInputSetup, generateSolutionScript, identifyConversions, templateToPythonLiteral, toPythonLiteral } from './python.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 // 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",
@@ -42,13 +42,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;
@@ -126,6 +126,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),
@@ -143,7 +151,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]))
@@ -160,11 +170,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) } : {},
@@ -1375,6 +1387,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:
@@ -1402,7 +1415,7 @@ def _serialize(obj, depth=0, node_refs=None):
         except TypeError:
             sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
         return {"__type__": "set", "values": sorted_vals}
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         obj_ref = id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
@@ -1418,7 +1431,7 @@ def _serialize(obj, depth=0, node_refs=None):
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1, node_refs)
         return result
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         obj_ref = id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
@@ -1431,6 +1444,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
@@ -1466,14 +1509,14 @@ def _serialize(obj, depth=0):
             return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
         except TypeError:
             return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         if hasattr(obj, 'left'):
             result["left"] = _serialize(obj.left, depth + 1)
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1)
         return result
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         result["next"] = _serialize(obj.next, depth + 1)
         return result
@@ -1548,14 +1591,14 @@ def _serialize(obj, depth=0):
             return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
         except TypeError:
             return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
-    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
         if hasattr(obj, 'left'):
             result["left"] = _serialize(obj.left, depth + 1)
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1)
         return result
-    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
         result["next"] = _serialize(obj.next, depth + 1)
         return result
@@ -1587,14 +1630,14 @@ def _serialize(obj, depth=0):
             return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
         except TypeError:
             return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         if hasattr(obj, 'left'):
             result["left"] = _serialize(obj.left, depth + 1)
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1)
         return result
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         result["next"] = _serialize(obj.next, depth + 1)
         return result
@@ -1794,6 +1837,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:
@@ -1821,7 +1865,7 @@ def _serialize(obj, depth=0, node_refs=None):
         except TypeError:
             sorted_vals = [_serialize(x, depth + 1, node_refs) for x in obj]
         return {"__type__": "set", "values": sorted_vals}
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         obj_ref = id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
@@ -1837,7 +1881,7 @@ def _serialize(obj, depth=0, node_refs=None):
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1, node_refs)
         return result
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         obj_ref = id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
@@ -1850,6 +1894,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
@@ -1885,14 +1959,14 @@ def _serialize(obj, depth=0):
             return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
         except TypeError:
             return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         if hasattr(obj, 'left'):
             result["left"] = _serialize(obj.left, depth + 1)
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1)
         return result
-    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1)}
         result["next"] = _serialize(obj.next, depth + 1)
         return result
@@ -1967,14 +2041,14 @@ def _serialize(obj, depth=0):
             return {"__type__": "set", "values": sorted([_serialize(x, depth + 1) for x in obj])}
         except TypeError:
             return {"__type__": "set", "values": [_serialize(x, depth + 1) for x in obj]}
-    elif hasattr(obj, 'val') and (hasattr(obj, 'left') or hasattr(obj, 'right')):
+    elif isinstance(obj, TreeNode):
         result = {"__type__": "TreeNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
         if hasattr(obj, 'left'):
             result["left"] = _serialize(obj.left, depth + 1)
         if hasattr(obj, 'right'):
             result["right"] = _serialize(obj.right, depth + 1)
         return result
-    elif hasattr(obj, 'val') and hasattr(obj, 'next'):
+    elif isinstance(obj, ListNode):
         result = {"__type__": "ListNode", "val": _serialize(getattr(obj, 'val', None), depth + 1)}
         result["next"] = _serialize(obj.next, depth + 1)
         return result
@@ -2068,16 +2142,28 @@ function createConsoleProxy(output) {
 }
 function isLikelyTreeNodeValue(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const hasValue = "val" in value || "value" in value;
-  const hasTreeLinks = "left" in value || "right" in value;
-  return hasValue && hasTreeLinks;
+  const record = value;
+  if (record.__type__ === "TreeNode") return true;
+  const ctor = value.constructor;
+  return ctor?.name === "TreeNode";
 }
 function isLikelyListNodeValue(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const hasValue = "val" in value || "value" in value;
-  const hasTreeLinks = "left" in value || "right" in value;
-  const hasListLinks = "next" in value || "prev" in value;
-  return hasValue && hasListLinks && !hasTreeLinks;
+  const record = value;
+  if (record.__type__ === "ListNode") return true;
+  const ctor = value.constructor;
+  return ctor?.name === "ListNode";
+}
+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>";
@@ -2121,22 +2207,47 @@ function serializeValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(),
       const nodePrefix = isTree ? "tree" : "list";
       const nodeId = `${nodePrefix}-${nodeRefState.nextId++}`;
       nodeRefState.ids.set(objectValue, nodeId);
-      if (isTree) {
-        return {
-          __type__: "TreeNode",
-          __id__: nodeId,
-          val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, depth + 1, seen, nodeRefState),
-          left: serializeValue(nodeValue.left ?? null, depth + 1, seen, nodeRefState),
-          right: serializeValue(nodeValue.right ?? null, depth + 1, seen, nodeRefState)
-        };
-      }
-      return {
+      const out2 = isTree ? {
+        __type__: "TreeNode",
+        __id__: nodeId,
+        val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, depth + 1, seen, nodeRefState),
+        left: serializeValue(nodeValue.left ?? null, depth + 1, seen, nodeRefState),
+        right: serializeValue(nodeValue.right ?? null, depth + 1, seen, nodeRefState)
+      } : {
         __type__: "ListNode",
         __id__: nodeId,
         val: serializeValue(nodeValue.val ?? nodeValue.value ?? null, depth + 1, seen, nodeRefState),
         next: serializeValue(nodeValue.next ?? null, depth + 1, seen, nodeRefState),
         ..."prev" in nodeValue ? { prev: serializeValue(nodeValue.prev ?? null, depth + 1, seen, nodeRefState) } : {}
       };
+      const skipped = isTree ? /* @__PURE__ */ new Set(["__id__", "__type__", "__class__", "val", "value", "left", "right"]) : /* @__PURE__ */ new Set(["__id__", "__type__", "__class__", "val", "value", "next", "prev"]);
+      for (const [k, v] of Object.entries(nodeValue)) {
+        if (skipped.has(k)) continue;
+        out2[k] = serializeValue(v, depth + 1, seen, nodeRefState);
+      }
+      return out2;
+    }
+    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);
@@ -2227,6 +2338,194 @@ 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)) {
+    const node = {
+      val: record.val ?? record.value ?? null,
+      value: record.val ?? record.value ?? null,
+      left: materializeTreeInput(record.left ?? null),
+      right: materializeTreeInput(record.right ?? null)
+    };
+    for (const [key, nested] of Object.entries(record)) {
+      if (key === "__id__" || key === "__type__" || key === "val" || key === "value" || key === "left" || key === "right") continue;
+      node[key] = materializeTreeInput(nested);
+    }
+    return node;
+  }
+  const taggedRecord = value;
+  if (taggedRecord.__type__ === "TreeNode") {
+    const node = {
+      val: taggedRecord.val ?? taggedRecord.value ?? null,
+      value: taggedRecord.val ?? taggedRecord.value ?? null,
+      left: materializeTreeInput(taggedRecord.left ?? null),
+      right: materializeTreeInput(taggedRecord.right ?? null)
+    };
+    for (const [key, nested] of Object.entries(taggedRecord)) {
+      if (key === "__id__" || key === "__type__" || key === "val" || key === "value" || key === "left" || key === "right") continue;
+      node[key] = materializeTreeInput(nested);
+    }
+    return node;
+  }
+  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);
+    for (const [key, nested] of Object.entries(taggedRecord)) {
+      if (key === "__id__" || key === "__type__" || key === "__class__" || key === "val" || key === "value" || key === "next") continue;
+      node[key] = materializeListInput(nested, 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 ?? []) {
@@ -2280,14 +2579,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;
@@ -2431,20 +2736,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));
     }
@@ -2463,9 +2770,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 {
@@ -2490,8 +2797,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");
 }
 export {
   DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS,