@tracecode/harness 0.4.0 → 0.5.0

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

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

package/workers/python/pyodide-worker.js

@@ -232,6 +232,7 @@ const PYTHON_TRACE_SERIALIZE_FUNCTION_SNIPPET = resolveSharedPythonSnippet(
 # 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:
@@ -288,6 +289,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

package/workers/python/runtime-core.js

@@ -38,6 +38,8 @@ _original_print = _builtins.print
 _target_function = "${targetFunction}"
 _MIRROR_PRINT_TO_WORKER_CONSOLE = ${mirrorPrintToConsole ? 'True' : 'False'}
 _MINIMAL_TRACE = ${minimalTrace ? 'True' : 'False'}
+_SCRIPT_MODE = ${functionName ? 'False' : 'True'}
+_TRACE_INPUT_NAMES = set(${JSON.stringify(Object.keys(inputs))})
 
 class _InfiniteLoopDetected(Exception):
     pass
@@ -71,6 +73,7 @@ _internal_funcs = {'_serialize', '_tracer', '_custom_print', '_dict_to_tree', '_
 _internal_locals = {
     '_trace_data', '_console_output', '_original_print', '_target_function',
     '_MIRROR_PRINT_TO_WORKER_CONSOLE', '_MINIMAL_TRACE', '_SKIP_SENTINEL',
+    '_SCRIPT_MODE', '_TRACE_INPUT_NAMES', '_SCRIPT_PRE_USER_GLOBALS',
     '_call_stack', '_pending_accesses', '_prev_hashmap_snapshots', '_TRACE_MUTATING_METHODS', '_internal_funcs', '_internal_locals', '_max_trace_steps',
     '_trace_limit_exceeded', '_timeout_reason', '_total_line_events', '_max_line_events',
     '_line_hit_count', '_max_single_line_hits', '_infinite_loop_line',
@@ -134,18 +137,235 @@ def _snapshot_call_stack():
         return []
     return [f.copy() for f in _call_stack]
 
-def _snapshot_locals(frame):
+def _is_serialized_ref(value):
+    return isinstance(value, dict) and len(value) == 1 and isinstance(value.get('__ref__'), str)
+
+def _is_serialized_list_node(value):
+    return isinstance(value, dict) and value.get('__type__') == 'ListNode' and isinstance(value.get('__id__'), str)
+
+def _serialized_list_root_id(value):
+    if _is_serialized_list_node(value):
+        return value.get('__id__')
+    if _is_serialized_ref(value):
+        return value.get('__ref__')
+    return None
+
+def _collect_serialized_list_component(value, node_ids=None, ref_ids=None, seen=None):
+    if node_ids is None:
+        node_ids = set()
+    if ref_ids is None:
+        ref_ids = set()
+    if seen is None:
+        seen = set()
+
+    if _is_serialized_ref(value):
+        ref_ids.add(value.get('__ref__'))
+        return (node_ids, ref_ids)
+
+    if not _is_serialized_list_node(value):
+        return (node_ids, ref_ids)
+
+    marker = id(value)
+    if marker in seen:
+        return (node_ids, ref_ids)
+    seen.add(marker)
+
+    node_id = value.get('__id__')
+    if isinstance(node_id, str):
+        node_ids.add(node_id)
+
+    for field_name in ('next', 'prev'):
+        if field_name in value:
+            _collect_serialized_list_component(value.get(field_name), node_ids, ref_ids, seen)
+
+    return (node_ids, ref_ids)
+
+def _clone_serialized_value(value):
+    if isinstance(value, dict):
+        return {key: _clone_serialized_value(nested) for key, nested in value.items()}
+    if isinstance(value, list):
+        return [_clone_serialized_value(item) for item in value]
+    return value
+
+def _inline_component_list_refs(value, root_payloads, seen_root_ids=None):
+    if seen_root_ids is None:
+        seen_root_ids = set()
+
+    if _is_serialized_ref(value):
+        ref_id = value.get('__ref__')
+        if not isinstance(ref_id, str):
+            return value
+        target = root_payloads.get(ref_id)
+        if target is None or ref_id in seen_root_ids:
+            return value
+        next_seen = set(seen_root_ids)
+        next_seen.add(ref_id)
+        return _inline_component_list_refs(_clone_serialized_value(target), root_payloads, next_seen)
+
+    if isinstance(value, list):
+        return [_inline_component_list_refs(item, root_payloads, seen_root_ids) for item in value]
+
+    if not isinstance(value, dict):
+        return value
+
+    out = {}
+    next_seen = set(seen_root_ids)
+    value_id = value.get('__id__')
+    if isinstance(value_id, str):
+        next_seen.add(value_id)
+
+    for key, nested in value.items():
+        out[key] = _inline_component_list_refs(nested, root_payloads, next_seen)
+    return out
+
+def _normalize_top_level_linked_list_locals(local_vars):
+    if not isinstance(local_vars, dict) or len(local_vars) < 2:
+        return local_vars
+
+    ordered_names = list(local_vars.keys())
+    candidates = []
+
+    for index, name in enumerate(ordered_names):
+        value = local_vars.get(name)
+        root_id = _serialized_list_root_id(value)
+        if not isinstance(root_id, str):
+            continue
+        node_ids, ref_ids = _collect_serialized_list_component(value)
+        all_ids = set(node_ids) | set(ref_ids)
+        if not all_ids:
+            all_ids.add(root_id)
+        candidates.append({
+            'name': name,
+            'index': index,
+            'value': value,
+            'root_id': root_id,
+            'is_ref_only': _is_serialized_ref(value),
+            'node_ids': node_ids,
+            'ref_ids': ref_ids,
+            'all_ids': all_ids,
+            'incoming': 0,
+        })
+
+    if len(candidates) < 2:
+        return local_vars
+
+    parent = list(range(len(candidates)))
+
+    def _find(i):
+        while parent[i] != i:
+            parent[i] = parent[parent[i]]
+            i = parent[i]
+        return i
+
+    def _union(a, b):
+        ra = _find(a)
+        rb = _find(b)
+        if ra != rb:
+            parent[rb] = ra
+
+    for i in range(len(candidates)):
+        left = candidates[i]
+        for j in range(i + 1, len(candidates)):
+            right = candidates[j]
+            if left['all_ids'].intersection(right['all_ids']):
+                _union(i, j)
+            if left['root_id'] in right['all_ids'] or right['root_id'] in left['all_ids']:
+                _union(i, j)
+
+    for i in range(len(candidates)):
+        left = candidates[i]
+        for j in range(len(candidates)):
+            if i == j:
+                continue
+            right = candidates[j]
+            if left['root_id'] in right['all_ids'] and left['root_id'] != right['root_id']:
+                left['incoming'] += 1
+
+    groups = {}
+    for index, candidate in enumerate(candidates):
+        groups.setdefault(_find(index), []).append(candidate)
+
+    for group in groups.values():
+        if len(group) < 2:
+            continue
+
+        root_payloads = {}
+        for candidate in group:
+            root_id = candidate.get('root_id')
+            value = candidate.get('value')
+            if isinstance(root_id, str) and _is_serialized_list_node(value):
+                root_payloads[root_id] = _clone_serialized_value(value)
+
+        canonical = max(
+            group,
+            key=lambda candidate: (
+                0 if candidate['is_ref_only'] else 1,
+                1 if candidate['incoming'] == 0 else 0,
+                len(candidate['node_ids']) + len(candidate['ref_ids']),
+                -candidate['index'],
+            ),
+        )
+
+        if _is_serialized_list_node(canonical.get('value')):
+            local_vars[canonical['name']] = _inline_component_list_refs(
+                _clone_serialized_value(canonical['value']),
+                root_payloads,
+                set([canonical.get('root_id')]) if isinstance(canonical.get('root_id'), str) else set(),
+            )
+
+        for candidate in group:
+            if candidate is canonical:
+                continue
+            root_id = candidate.get('root_id')
+            if isinstance(root_id, str):
+                local_vars[candidate['name']] = {'__ref__': root_id}
+
+    return local_vars
+
+_SCRIPT_PRE_USER_GLOBALS = set()
+
+def _snapshot_local_sources(frame):
     if _MINIMAL_TRACE:
         return {}
+    try:
+        func_name = frame.f_code.co_name
+        sources = {}
+        for name in frame.f_locals.keys():
+            if name in _internal_locals or name == '_' or name.startswith('__'):
+                continue
+            if _SCRIPT_MODE and func_name == '<module>':
+                if name in _TRACE_INPUT_NAMES:
+                    sources[name] = 'user-input'
+                elif name in _SCRIPT_PRE_USER_GLOBALS:
+                    sources[name] = 'harness-prelude'
+                else:
+                    sources[name] = 'user'
+            else:
+                sources[name] = 'user'
+        return sources
+    except Exception:
+        return {}
+
+def _snapshot_locals(frame, with_sources=False):
+    if _MINIMAL_TRACE:
+        return ({}, {}) if with_sources else {}
     try:
         _node_refs = {}
-        return {
+        _sources = _snapshot_local_sources(frame)
+        local_vars = {
             k: v
-            for k, v in ((k, _serialize(v, 0, _node_refs)) for k, v in frame.f_locals.items() if k not in _internal_locals and k != '_' and not k.startswith('__'))
+            for k, v in (
+                (k, _serialize(v, 0, _node_refs))
+                for k, v in frame.f_locals.items()
+                if k not in _internal_locals and k != '_' and not k.startswith('__') and _sources.get(k) != 'harness-prelude'
+            )
             if v != _SKIP_SENTINEL
         }
+        local_vars = _normalize_top_level_linked_list_locals(local_vars)
+        local_sources = {name: _sources.get(name, 'user') for name in local_vars.keys()}
+        return (local_vars, local_sources) if with_sources else local_vars
     except Exception:
-        return {}
+        return ({}, {}) if with_sources else {}
 
 def __tracecode_record_access(frame, event):
     if frame is None or not isinstance(event, dict):
@@ -681,12 +901,13 @@ def _tracer(frame, event, arg):
                 _trace_limit_exceeded = True
                 _timeout_reason = 'single-line-limit'
                 _infinite_loop_line = frame.f_lineno
-                local_vars = _snapshot_locals(frame)
+                local_vars, local_sources = _snapshot_locals(frame, with_sources=True)
                 local_vars['timeoutReason'] = _timeout_reason
                 _trace_data.append({
                     'line': frame.f_lineno,
                     'event': 'timeout',
                     'variables': local_vars,
+                    'variableSources': local_sources,
                     'function': func_name,
                     'callStack': _snapshot_call_stack(),
                     'stdoutLineCount': len(_console_output),
@@ -715,7 +936,7 @@ def _tracer(frame, event, arg):
             raise _InfiniteLoopDetected(f"Exceeded {_max_trace_steps} trace steps")
 
     if event == 'call':
-        local_vars = _snapshot_locals(frame)
+        local_vars, local_sources = _snapshot_locals(frame, with_sources=True)
         if func_name != '<module>':
             _call_stack.append({
                 'function': func_name,
@@ -728,6 +949,7 @@ def _tracer(frame, event, arg):
             'line': frame.f_lineno,
             'event': 'call',
             'variables': local_vars,
+            'variableSources': local_sources,
             'function': func_name,
             'callStack': _snapshot_call_stack(),
             'stdoutLineCount': len(_console_output),
@@ -737,11 +959,12 @@ def _tracer(frame, event, arg):
     elif event == 'line':
         if _MINIMAL_TRACE:
             return _tracer
-        local_vars = _snapshot_locals(frame)
+        local_vars, local_sources = _snapshot_locals(frame, with_sources=True)
         _trace_data.append({
             'line': frame.f_lineno,
             'event': event,
             'variables': local_vars,
+            'variableSources': local_sources,
             'function': func_name,
             'callStack': _snapshot_call_stack(),
             'stdoutLineCount': len(_console_output),
@@ -750,11 +973,12 @@ def _tracer(frame, event, arg):
         })
     elif event == 'return':
         if not _MINIMAL_TRACE:
-            local_vars = _snapshot_locals(frame)
+            local_vars, local_sources = _snapshot_locals(frame, with_sources=True)
             _trace_data.append({
                 'line': frame.f_lineno,
                 'event': 'return',
                 'variables': local_vars,
+                'variableSources': local_sources,
                 'function': func_name,
                 'returnValue': _serialize(arg),
                 'callStack': _snapshot_call_stack(),
@@ -893,6 +1117,9 @@ ${listConversions}
 
 ${preloadUserDefinitions}
 
+if _SCRIPT_MODE:
+    _SCRIPT_PRE_USER_GLOBALS = set(globals().keys()) - _TRACE_INPUT_NAMES
+
 sys.settrace(_tracer)
 _trace_failed = False