@tracecode/harness 0.4.0 → 0.5.1

package/dist/python.cjs

@@ -111,6 +111,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:
@@ -138,7 +139,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]}
@@ -154,7 +155,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]}
@@ -167,6 +168,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
@@ -202,14 +233,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
@@ -284,14 +315,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
@@ -323,14 +354,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
@@ -530,6 +561,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:
@@ -557,7 +589,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]}
@@ -573,7 +605,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]}
@@ -586,6 +618,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
@@ -621,14 +683,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
@@ -703,14 +765,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

package/dist/python.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../packages/harness-python/src/index.ts","../packages/harness-python/src/generated/python-harness-snippets.ts","../packages/harness-python/src/python-harness.ts","../packages/harness-python/src/python-harness-template.ts"],"sourcesContent":["export * from './python-harness';\nexport * from './python-harness-template';\nexport * from './generated/python-harness-snippets';\n","/**\n * AUTO-GENERATED FILE. DO NOT EDIT MANUALLY.\n *\n * Source: packages/harness-python/src/python-harness-template.ts\n * Generator: scripts/generate-python-harness-artifacts.ts\n */\n\n// @ts-nocheck\n\nexport function toPythonLiteral(value){if(value===null||value===void 0){return\"None\"}if(typeof value===\"boolean\"){return value?\"True\":\"False\"}if(typeof value===\"number\"){return String(value)}if(typeof value===\"string\"){return JSON.stringify(value)}if(Array.isArray(value)){return\"[\"+value.map(toPythonLiteral).join(\", \")+\"]\"}if(typeof value===\"object\"){const entries=Object.entries(value).map(([k,v])=>`${JSON.stringify(k)}: ${toPythonLiteral(v)}`).join(\", \");return\"{\"+entries+\"}\"}return JSON.stringify(value)}\n\nexport const 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\";\n\nexport const 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\";\n\nexport const 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\";\n\nexport const 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\";\n\nexport const PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = \"\\ndef _serialize(obj, depth=0, state=None):\\n    if state is None:\\n        state = {\\\"nodes\\\": 0, \\\"seen\\\": set()}\\n    if depth > 64:\\n        return \\\"__MAX_DEPTH__\\\"\\n    if isinstance(obj, (int, float, str, bool, type(None))):\\n        return obj\\n\\n    state[\\\"nodes\\\"] += 1\\n    if state[\\\"nodes\\\"] > 600:\\n        return \\\"__MAX_NODES__\\\"\\n\\n    if isinstance(obj, (list, tuple)):\\n        return [_serialize(x, depth + 1, state) for x in obj]\\n    elif isinstance(obj, dict):\\n        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}\\n    elif isinstance(obj, set):\\n        serialized = [_serialize(x, depth + 1, state) for x in obj]\\n        try:\\n            serialized = sorted(serialized)\\n        except TypeError:\\n            pass\\n        return {\\\"__type__\\\": \\\"set\\\", \\\"values\\\": serialized}\\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\\n        obj_id = id(obj)\\n        if obj_id in state[\\\"seen\\\"]:\\n            return \\\"__CYCLE__\\\"\\n        state[\\\"seen\\\"].add(obj_id)\\n        result = {\\\"__type__\\\": \\\"TreeNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\\n        if hasattr(obj, 'left'):\\n            result[\\\"left\\\"] = _serialize(obj.left, depth + 1, state)\\n        if hasattr(obj, 'right'):\\n            result[\\\"right\\\"] = _serialize(obj.right, depth + 1, state)\\n        state[\\\"seen\\\"].remove(obj_id)\\n        return result\\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\\n        obj_id = id(obj)\\n        if obj_id in state[\\\"seen\\\"]:\\n            return \\\"__CYCLE__\\\"\\n        state[\\\"seen\\\"].add(obj_id)\\n        result = {\\\"__type__\\\": \\\"ListNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\\n        result[\\\"next\\\"] = _serialize(obj.next, depth + 1, state)\\n        state[\\\"seen\\\"].remove(obj_id)\\n        return result\\n    else:\\n        return repr(obj)\\n\";\n\nexport const PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = \"\\ndef _serialize(obj, depth=0):\\n    if depth > 10:\\n        return \\\"<max depth>\\\"\\n    if isinstance(obj, (int, float, str, bool, type(None))):\\n        return obj\\n    elif isinstance(obj, (list, tuple)):\\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') and (hasattr(obj, 'left') or hasattr(obj, 'right')):\\n        result = {\\\"__type__\\\": \\\"TreeNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', 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') and hasattr(obj, 'next'):\\n        result = {\\\"__type__\\\": \\\"ListNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', None), depth + 1)}\\n        result[\\\"next\\\"] = _serialize(obj.next, depth + 1)\\n        return result\\n    else:\\n        return repr(obj)\\n\";\n\nexport const 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\";\n","/**\n * Python Harness Code\n *\n * Shared Python harness helpers for scripts and Node-side validation paths.\n *\n * Canonical source:\n * - packages/harness-python/src/python-harness-template.ts\n *\n * Generated artifacts (via scripts/generate-python-harness-artifacts.ts):\n * - packages/harness-python/src/generated/python-harness-snippets.ts (consumed here)\n * - workers/python/generated-python-harness-snippets.js\n *\n * Note: workers/python/pyodide-worker.js still contains runtime-specific embedded\n * harness code. Keep it aligned via:\n *   pnpm test:python-harness-sync\n */\n\nimport {\n  toPythonLiteral,\n  PYTHON_CLASS_DEFINITIONS,\n  PYTHON_CONVERSION_HELPERS,\n  PYTHON_TRACE_SERIALIZE_FUNCTION,\n  PYTHON_EXECUTE_SERIALIZE_FUNCTION,\n  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_SERIALIZE_FUNCTION,\n} from './generated/python-harness-snippets';\n\nexport {\n  toPythonLiteral,\n  PYTHON_CLASS_DEFINITIONS,\n  PYTHON_CONVERSION_HELPERS,\n  PYTHON_TRACE_SERIALIZE_FUNCTION,\n  PYTHON_EXECUTE_SERIALIZE_FUNCTION,\n  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_SERIALIZE_FUNCTION,\n};\n\nexport function identifyConversions(inputs: Record<string, unknown>): {\n  treeKeys: string[];\n  listKeys: string[];\n} {\n  const treeKeys: string[] = [];\n  const listKeys: string[] = [];\n  \n  for (const [key, value] of Object.entries(inputs)) {\n    if (\n      value &&\n      typeof value === 'object' &&\n      !Array.isArray(value) &&\n      ('val' in (value as Record<string, unknown>) || 'value' in (value as Record<string, unknown>))\n    ) {\n      const obj = value as Record<string, unknown>;\n      const hasLeft = 'left' in obj;\n      const hasRight = 'right' in obj;\n      const hasNext = 'next' in obj;\n      \n      if (hasLeft || hasRight) {\n        treeKeys.push(key);\n      } else if (hasNext) {\n        listKeys.push(key);\n      } else {\n        // Default to tree for backwards compatibility (just 'val')\n        treeKeys.push(key);\n      }\n    }\n  }\n  \n  return { treeKeys, listKeys };\n}\n\n/**\n * Generate Python code for converting tree/list inputs.\n */\nexport function generateConversionCode(inputs: Record<string, unknown>): string {\n  const { treeKeys, listKeys } = identifyConversions(inputs);\n  \n  const lines: string[] = [];\n  \n  for (const key of treeKeys) {\n    lines.push(`${key} = _dict_to_tree(${key})`);\n  }\n  \n  for (const key of listKeys) {\n    lines.push(`${key} = _dict_to_list(${key})`);\n  }\n  \n  return lines.join('\\n');\n}\n\n/**\n * Generate Python code for setting up inputs.\n */\nexport function generateInputSetup(inputs: Record<string, unknown>): string {\n  return Object.entries(inputs)\n    .map(([key, value]) => `${key} = ${toPythonLiteral(value)}`)\n    .join('\\n');\n}\n\n/**\n * Generate a complete Python script for running a solution.\n * This is used by the validation script to run solutions via subprocess.\n */\nexport function generateSolutionScript(\n  solutionCode: string,\n  functionName: string,\n  inputs: Record<string, unknown>\n): string {\n  const inputSetup = generateInputSetup(inputs);\n  const conversionCode = generateConversionCode(inputs);\n  const paramList = Object.keys(inputs)\n    .map((key) => `${key}=${key}`)\n    .join(', ');\n  \n  return `\nimport json\nimport sys\n\n${PYTHON_CLASS_DEFINITIONS}\n\n${PYTHON_CONVERSION_HELPERS}\n\n${PYTHON_SERIALIZE_FUNCTION}\n\n# Solution code\n${solutionCode}\n\n# Set up inputs\n${inputSetup}\n\n# Convert tree/list inputs\n${conversionCode}\n\n# Run the function\ntry:\n    _result = ${functionName}(${paramList})\n    print(json.dumps({\"success\": True, \"output\": _serialize(_result)}))\nexcept Exception as e:\n    print(json.dumps({\"success\": False, \"error\": f\"{type(e).__name__}: {str(e)}\"}))\n`;\n}\n","/**\n * Canonical Python Harness Template\n *\n * This file is the single source of truth for shared harness snippets.\n * Generated artifacts:\n * - packages/harness-python/src/generated/python-harness-snippets.ts\n * - workers/python/generated-python-harness-snippets.js\n */\n\n/**\n * Convert a JavaScript value to a Python literal string.\n * Handles null -> None, booleans -> True/False, and nested structures.\n */\nexport function templateToPythonLiteral(value: unknown): string {\n  if (value === null || value === undefined) {\n    return 'None';\n  }\n  if (typeof value === 'boolean') {\n    return value ? 'True' : 'False';\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'string') {\n    return JSON.stringify(value);\n  }\n  if (Array.isArray(value)) {\n    return '[' + value.map(templateToPythonLiteral).join(', ') + ']';\n  }\n  if (typeof value === 'object') {\n    const entries = Object.entries(value as Record<string, unknown>)\n      .map(([k, v]) => `${JSON.stringify(k)}: ${templateToPythonLiteral(v)}`)\n      .join(', ');\n    return '{' + entries + '}';\n  }\n  return JSON.stringify(value);\n}\n\n/**\n * Python class definitions for TreeNode and ListNode.\n * These must match the worker definitions.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Python helper functions for converting dicts to TreeNode/ListNode.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Trace-mode Python serialization function.\n * Includes function filtering and node reference tracking for cycle-safe traces.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Execute-mode Python serialization function.\n * Preserves current execute/interview output semantics.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Practice materialization serializer with strict safety limits and markers.\n */\nexport const TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `\ndef _serialize(obj, depth=0, state=None):\n    if state is None:\n        state = {\"nodes\": 0, \"seen\": set()}\n    if depth > 64:\n        return \"__MAX_DEPTH__\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n\n    state[\"nodes\"] += 1\n    if state[\"nodes\"] > 600:\n        return \"__MAX_NODES__\"\n\n    if isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1, state) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        serialized = [_serialize(x, depth + 1, state) for x in obj]\n        try:\n            serialized = sorted(serialized)\n        except TypeError:\n            pass\n        return {\"__type__\": \"set\", \"values\": serialized}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1, state)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        result[\"next\"] = _serialize(obj.next, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    else:\n        return repr(obj)\n`;\n\n/**\n * Interview materialization serializer, preserving current legacy behavior.\n */\nexport const TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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') and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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') and hasattr(obj, 'next'):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n`;\n\n/**\n * Backwards-compatible alias. Use TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION\n * for new callsites.\n */\nexport const TEMPLATE_PYTHON_SERIALIZE_FUNCTION = TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION;\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../packages/harness-python/src/index.ts","../packages/harness-python/src/generated/python-harness-snippets.ts","../packages/harness-python/src/python-harness.ts","../packages/harness-python/src/python-harness-template.ts"],"sourcesContent":["export * from './python-harness';\nexport * from './python-harness-template';\nexport * from './generated/python-harness-snippets';\n","/**\n * AUTO-GENERATED FILE. DO NOT EDIT MANUALLY.\n *\n * Source: packages/harness-python/src/python-harness-template.ts\n * Generator: scripts/generate-python-harness-artifacts.ts\n */\n\n// @ts-nocheck\n\nexport function toPythonLiteral(value){if(value===null||value===void 0){return\"None\"}if(typeof value===\"boolean\"){return value?\"True\":\"False\"}if(typeof value===\"number\"){return String(value)}if(typeof value===\"string\"){return JSON.stringify(value)}if(Array.isArray(value)){return\"[\"+value.map(toPythonLiteral).join(\", \")+\"]\"}if(typeof value===\"object\"){const entries=Object.entries(value).map(([k,v])=>`${JSON.stringify(k)}: ${toPythonLiteral(v)}`).join(\", \");return\"{\"+entries+\"}\"}return JSON.stringify(value)}\n\nexport const 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\";\n\nexport const 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\";\n\nexport const 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 isinstance(obj, TreeNode):\\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 isinstance(obj, ListNode):\\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\";\n\nexport const 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 isinstance(obj, TreeNode):\\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 isinstance(obj, ListNode):\\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\";\n\nexport const PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = \"\\ndef _serialize(obj, depth=0, state=None):\\n    if state is None:\\n        state = {\\\"nodes\\\": 0, \\\"seen\\\": set()}\\n    if depth > 64:\\n        return \\\"__MAX_DEPTH__\\\"\\n    if isinstance(obj, (int, float, str, bool, type(None))):\\n        return obj\\n\\n    state[\\\"nodes\\\"] += 1\\n    if state[\\\"nodes\\\"] > 600:\\n        return \\\"__MAX_NODES__\\\"\\n\\n    if isinstance(obj, (list, tuple)):\\n        return [_serialize(x, depth + 1, state) for x in obj]\\n    elif isinstance(obj, dict):\\n        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}\\n    elif isinstance(obj, set):\\n        serialized = [_serialize(x, depth + 1, state) for x in obj]\\n        try:\\n            serialized = sorted(serialized)\\n        except TypeError:\\n            pass\\n        return {\\\"__type__\\\": \\\"set\\\", \\\"values\\\": serialized}\\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\\n        obj_id = id(obj)\\n        if obj_id in state[\\\"seen\\\"]:\\n            return \\\"__CYCLE__\\\"\\n        state[\\\"seen\\\"].add(obj_id)\\n        result = {\\\"__type__\\\": \\\"TreeNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\\n        if hasattr(obj, 'left'):\\n            result[\\\"left\\\"] = _serialize(obj.left, depth + 1, state)\\n        if hasattr(obj, 'right'):\\n            result[\\\"right\\\"] = _serialize(obj.right, depth + 1, state)\\n        state[\\\"seen\\\"].remove(obj_id)\\n        return result\\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\\n        obj_id = id(obj)\\n        if obj_id in state[\\\"seen\\\"]:\\n            return \\\"__CYCLE__\\\"\\n        state[\\\"seen\\\"].add(obj_id)\\n        result = {\\\"__type__\\\": \\\"ListNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\\n        result[\\\"next\\\"] = _serialize(obj.next, depth + 1, state)\\n        state[\\\"seen\\\"].remove(obj_id)\\n        return result\\n    else:\\n        return repr(obj)\\n\";\n\nexport const PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = \"\\ndef _serialize(obj, depth=0):\\n    if depth > 10:\\n        return \\\"<max depth>\\\"\\n    if isinstance(obj, (int, float, str, bool, type(None))):\\n        return obj\\n    elif isinstance(obj, (list, tuple)):\\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 isinstance(obj, TreeNode):\\n        result = {\\\"__type__\\\": \\\"TreeNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', 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 isinstance(obj, ListNode):\\n        result = {\\\"__type__\\\": \\\"ListNode\\\", \\\"val\\\": _serialize(getattr(obj, 'val', None), depth + 1)}\\n        result[\\\"next\\\"] = _serialize(obj.next, depth + 1)\\n        return result\\n    else:\\n        return repr(obj)\\n\";\n\nexport const 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 isinstance(obj, TreeNode):\\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 isinstance(obj, ListNode):\\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\";\n","/**\n * Python Harness Code\n *\n * Shared Python harness helpers for scripts and Node-side validation paths.\n *\n * Canonical source:\n * - packages/harness-python/src/python-harness-template.ts\n *\n * Generated artifacts (via scripts/generate-python-harness-artifacts.ts):\n * - packages/harness-python/src/generated/python-harness-snippets.ts (consumed here)\n * - workers/python/generated-python-harness-snippets.js\n *\n * Note: workers/python/pyodide-worker.js still contains runtime-specific embedded\n * harness code. Keep it aligned via:\n *   pnpm test:python-harness-sync\n */\n\nimport {\n  toPythonLiteral,\n  PYTHON_CLASS_DEFINITIONS,\n  PYTHON_CONVERSION_HELPERS,\n  PYTHON_TRACE_SERIALIZE_FUNCTION,\n  PYTHON_EXECUTE_SERIALIZE_FUNCTION,\n  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_SERIALIZE_FUNCTION,\n} from './generated/python-harness-snippets';\n\nexport {\n  toPythonLiteral,\n  PYTHON_CLASS_DEFINITIONS,\n  PYTHON_CONVERSION_HELPERS,\n  PYTHON_TRACE_SERIALIZE_FUNCTION,\n  PYTHON_EXECUTE_SERIALIZE_FUNCTION,\n  PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION,\n  PYTHON_SERIALIZE_FUNCTION,\n};\n\nexport function identifyConversions(inputs: Record<string, unknown>): {\n  treeKeys: string[];\n  listKeys: string[];\n} {\n  const treeKeys: string[] = [];\n  const listKeys: string[] = [];\n  \n  for (const [key, value] of Object.entries(inputs)) {\n    if (\n      value &&\n      typeof value === 'object' &&\n      !Array.isArray(value) &&\n      ('val' in (value as Record<string, unknown>) || 'value' in (value as Record<string, unknown>))\n    ) {\n      const obj = value as Record<string, unknown>;\n      const hasLeft = 'left' in obj;\n      const hasRight = 'right' in obj;\n      const hasNext = 'next' in obj;\n      \n      if (hasLeft || hasRight) {\n        treeKeys.push(key);\n      } else if (hasNext) {\n        listKeys.push(key);\n      } else {\n        // Default to tree for backwards compatibility (just 'val')\n        treeKeys.push(key);\n      }\n    }\n  }\n  \n  return { treeKeys, listKeys };\n}\n\n/**\n * Generate Python code for converting tree/list inputs.\n */\nexport function generateConversionCode(inputs: Record<string, unknown>): string {\n  const { treeKeys, listKeys } = identifyConversions(inputs);\n  \n  const lines: string[] = [];\n  \n  for (const key of treeKeys) {\n    lines.push(`${key} = _dict_to_tree(${key})`);\n  }\n  \n  for (const key of listKeys) {\n    lines.push(`${key} = _dict_to_list(${key})`);\n  }\n  \n  return lines.join('\\n');\n}\n\n/**\n * Generate Python code for setting up inputs.\n */\nexport function generateInputSetup(inputs: Record<string, unknown>): string {\n  return Object.entries(inputs)\n    .map(([key, value]) => `${key} = ${toPythonLiteral(value)}`)\n    .join('\\n');\n}\n\n/**\n * Generate a complete Python script for running a solution.\n * This is used by the validation script to run solutions via subprocess.\n */\nexport function generateSolutionScript(\n  solutionCode: string,\n  functionName: string,\n  inputs: Record<string, unknown>\n): string {\n  const inputSetup = generateInputSetup(inputs);\n  const conversionCode = generateConversionCode(inputs);\n  const paramList = Object.keys(inputs)\n    .map((key) => `${key}=${key}`)\n    .join(', ');\n  \n  return `\nimport json\nimport sys\n\n${PYTHON_CLASS_DEFINITIONS}\n\n${PYTHON_CONVERSION_HELPERS}\n\n${PYTHON_SERIALIZE_FUNCTION}\n\n# Solution code\n${solutionCode}\n\n# Set up inputs\n${inputSetup}\n\n# Convert tree/list inputs\n${conversionCode}\n\n# Run the function\ntry:\n    _result = ${functionName}(${paramList})\n    print(json.dumps({\"success\": True, \"output\": _serialize(_result)}))\nexcept Exception as e:\n    print(json.dumps({\"success\": False, \"error\": f\"{type(e).__name__}: {str(e)}\"}))\n`;\n}\n","/**\n * Canonical Python Harness Template\n *\n * This file is the single source of truth for shared harness snippets.\n * Generated artifacts:\n * - packages/harness-python/src/generated/python-harness-snippets.ts\n * - workers/python/generated-python-harness-snippets.js\n */\n\n/**\n * Convert a JavaScript value to a Python literal string.\n * Handles null -> None, booleans -> True/False, and nested structures.\n */\nexport function templateToPythonLiteral(value: unknown): string {\n  if (value === null || value === undefined) {\n    return 'None';\n  }\n  if (typeof value === 'boolean') {\n    return value ? 'True' : 'False';\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'string') {\n    return JSON.stringify(value);\n  }\n  if (Array.isArray(value)) {\n    return '[' + value.map(templateToPythonLiteral).join(', ') + ']';\n  }\n  if (typeof value === 'object') {\n    const entries = Object.entries(value as Record<string, unknown>)\n      .map(([k, v]) => `${JSON.stringify(k)}: ${templateToPythonLiteral(v)}`)\n      .join(', ');\n    return '{' + entries + '}';\n  }\n  return JSON.stringify(value);\n}\n\n/**\n * Python class definitions for TreeNode and ListNode.\n * These must match the worker definitions.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Python helper functions for converting dicts to TreeNode/ListNode.\n */\nexport const TEMPLATE_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`;\n\n/**\n * Trace-mode Python serialization function.\n * Includes function filtering and node reference tracking for cycle-safe traces.\n */\nexport const TEMPLATE_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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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`;\n\n/**\n * Execute-mode Python serialization function.\n * Preserves current execute/interview output semantics.\n */\nexport const TEMPLATE_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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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`;\n\n/**\n * Practice materialization serializer with strict safety limits and markers.\n */\nexport const TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = `\ndef _serialize(obj, depth=0, state=None):\n    if state is None:\n        state = {\"nodes\": 0, \"seen\": set()}\n    if depth > 64:\n        return \"__MAX_DEPTH__\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n\n    state[\"nodes\"] += 1\n    if state[\"nodes\"] > 600:\n        return \"__MAX_NODES__\"\n\n    if isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1, state) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        serialized = [_serialize(x, depth + 1, state) for x in obj]\n        try:\n            serialized = sorted(serialized)\n        except TypeError:\n            pass\n        return {\"__type__\": \"set\", \"values\": serialized}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1, state)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        result[\"next\"] = _serialize(obj.next, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    else:\n        return repr(obj)\n`;\n\n/**\n * Interview materialization serializer, preserving current legacy behavior.\n */\nexport const TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = `\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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 isinstance(obj, TreeNode):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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 isinstance(obj, ListNode):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n`;\n\n/**\n * Backwards-compatible alias. Use TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION\n * for new callsites.\n */\nexport const TEMPLATE_PYTHON_SERIALIZE_FUNCTION = TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION;\n"],"mappings":"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","names":[]}

package/dist/python.d.cts

@@ -7,11 +7,11 @@
 declare function toPythonLiteral(value: any): any;
 declare const 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";
 declare const 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";
-declare const 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";
-declare const 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";
+declare const 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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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";
+declare const 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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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";
 declare const PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _serialize(obj, depth=0, state=None):\n    if state is None:\n        state = {\"nodes\": 0, \"seen\": set()}\n    if depth > 64:\n        return \"__MAX_DEPTH__\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n\n    state[\"nodes\"] += 1\n    if state[\"nodes\"] > 600:\n        return \"__MAX_NODES__\"\n\n    if isinstance(obj, (list, tuple)):\n        return [_serialize(x, depth + 1, state) for x in obj]\n    elif isinstance(obj, dict):\n        return {str(k): _serialize(v, depth + 1, state) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        serialized = [_serialize(x, depth + 1, state) for x in obj]\n        try:\n            serialized = sorted(serialized)\n        except TypeError:\n            pass\n        return {\"__type__\": \"set\", \"values\": serialized}\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize(obj.left, depth + 1, state)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize(obj.right, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    elif (hasattr(obj, 'val') or hasattr(obj, 'value')) and hasattr(obj, 'next'):\n        obj_id = id(obj)\n        if obj_id in state[\"seen\"]:\n            return \"__CYCLE__\"\n        state[\"seen\"].add(obj_id)\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, state)}\n        result[\"next\"] = _serialize(obj.next, depth + 1, state)\n        state[\"seen\"].remove(obj_id)\n        return result\n    else:\n        return repr(obj)\n";
-declare const PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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') and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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') and hasattr(obj, 'next'):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n";
-declare const 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";
+declare const PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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 isinstance(obj, TreeNode):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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 isinstance(obj, ListNode):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n";
+declare const 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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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 Harness Code
@@ -74,12 +74,12 @@ declare const TEMPLATE_PYTHON_CONVERSION_HELPERS = "\ndef _ensure_node_value_ali
  * Trace-mode Python serialization function.
  * Includes function filtering and node reference tracking for cycle-safe traces.
  */
-declare const TEMPLATE_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";
+declare const TEMPLATE_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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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";
 /**
  * Execute-mode Python serialization function.
  * Preserves current execute/interview output semantics.
  */
-declare const TEMPLATE_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";
+declare const TEMPLATE_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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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";
 /**
  * Practice materialization serializer with strict safety limits and markers.
  */
@@ -87,11 +87,11 @@ declare const TEMPLATE_PYTHON_PRACTICE_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _
 /**
  * Interview materialization serializer, preserving current legacy behavior.
  */
-declare const TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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') and (hasattr(obj, 'left') or hasattr(obj, 'right')):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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') and hasattr(obj, 'next'):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n";
+declare const TEMPLATE_PYTHON_INTERVIEW_MATERIALIZE_SERIALIZE_FUNCTION = "\ndef _serialize(obj, depth=0):\n    if depth > 10:\n        return \"<max depth>\"\n    if isinstance(obj, (int, float, str, bool, type(None))):\n        return obj\n    elif isinstance(obj, (list, tuple)):\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 isinstance(obj, TreeNode):\n        result = {\"__type__\": \"TreeNode\", \"val\": _serialize(getattr(obj, 'val', 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 isinstance(obj, ListNode):\n        result = {\"__type__\": \"ListNode\", \"val\": _serialize(getattr(obj, 'val', None), depth + 1)}\n        result[\"next\"] = _serialize(obj.next, depth + 1)\n        return result\n    else:\n        return repr(obj)\n";
 /**
  * Backwards-compatible alias. Use TEMPLATE_PYTHON_EXECUTE_SERIALIZE_FUNCTION
  * for new callsites.
  */
-declare const TEMPLATE_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";
+declare const TEMPLATE_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 isinstance(obj, TreeNode):\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 isinstance(obj, ListNode):\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";
 
 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 };