@tracecode/harness 0.6.6 → 0.7.0-beta8

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

@@ -10,10 +10,10 @@
 
   scope.__TRACECODE_PYTHON_HARNESS__ = Object.freeze({
     PYTHON_CLASS_DEFINITIONS: "\nclass TreeNode:\n    def __init__(self, val=0, left=None, right=None):\n        self.val = val\n        self.value = val\n        self.left = left\n        self.right = right\n    def __getitem__(self, key):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))\n        if key == 'left': return self.left\n        if key == 'right': return self.right\n        raise KeyError(key)\n    def get(self, key, default=None):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))\n        if key == 'left': return self.left\n        if key == 'right': return self.right\n        return default\n    def __repr__(self):\n        return f\"TreeNode({getattr(self, 'val', getattr(self, 'value', None))})\"\n\nclass ListNode:\n    def __init__(self, val=0, next=None):\n        self.val = val\n        self.value = val\n        self.next = next\n    def __getitem__(self, key):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', None))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', None))\n        if key == 'next': return self.next\n        raise KeyError(key)\n    def get(self, key, default=None):\n        if key == 'val': return getattr(self, 'val', getattr(self, 'value', default))\n        if key == 'value': return getattr(self, 'value', getattr(self, 'val', default))\n        if key == 'next': return self.next\n        return default\n    def __repr__(self):\n        return f\"ListNode({getattr(self, 'val', getattr(self, 'value', None))})\"\n",
-    PYTHON_CONVERSION_HELPERS: "\ndef _ensure_node_value_aliases(node):\n    if node is None:\n        return node\n    try:\n        has_val = hasattr(node, 'val')\n        has_value = hasattr(node, 'value')\n        if has_value and not has_val:\n            try:\n                setattr(node, 'val', getattr(node, 'value'))\n            except Exception:\n                pass\n        elif has_val and not has_value:\n            try:\n                setattr(node, 'value', getattr(node, 'val'))\n            except Exception:\n                pass\n    except Exception:\n        pass\n    return node\n\ndef _dict_to_tree(d):\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = TreeNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node.left = _dict_to_tree(d.get('left'))\n    node.right = _dict_to_tree(d.get('right'))\n    return node\n\ndef _dict_to_list(d, _refs=None):\n    if _refs is None:\n        _refs = {}\n    if d is None:\n        return None\n    if not isinstance(d, dict):\n        return d\n    if '__ref__' in d:\n        return _refs.get(d.get('__ref__'))\n    if 'val' not in d and 'value' not in d:\n        return d\n    node = ListNode(d.get('val', d.get('value', 0)))\n    _ensure_node_value_aliases(node)\n    node_id = d.get('__id__')\n    if isinstance(node_id, str) and node_id:\n        _refs[node_id] = node\n    node.next = _dict_to_list(d.get('next'), _refs)\n    return node\n",
-    PYTHON_TRACE_SERIALIZE_FUNCTION: "\n# Sentinel to mark skipped values (functions, etc.) - distinct from None\n_SKIP_SENTINEL = \"__TRACECODE_SKIP__\"\n_MAX_SERIALIZE_DEPTH = 48\n_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",
-    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",
-    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_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, _builtins.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, _builtins.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, _builtins.str) and node_id:\n        _refs[node_id] = node\n    node.next = _dict_to_list(d.get('next'), _refs)\n    return node\n",
+    PYTHON_TRACE_SERIALIZE_FUNCTION: "\n# Sentinel to mark skipped values (functions, etc.) - distinct from None\n_SKIP_SENTINEL = \"__TRACECODE_SKIP__\"\n_MAX_SERIALIZE_DEPTH = 48\n_MAX_SERIALIZED_ITEMS = 64\n_MAX_OBJECT_FIELDS = 32\n_tracecode_global_object_refs = {}\n_tracecode_next_object_ref_id = 0\n\ndef _tracecode_ref_id(obj_ref, node_refs):\n    global _tracecode_next_object_ref_id\n    if obj_ref in node_refs:\n        return node_refs[obj_ref]\n    if obj_ref in _tracecode_global_object_refs:\n        node_id = _tracecode_global_object_refs[obj_ref]\n    else:\n        node_id = f\"ref-{_tracecode_next_object_ref_id}\"\n        _tracecode_global_object_refs[obj_ref] = node_id\n        _tracecode_next_object_ref_id += 1\n    node_refs[obj_ref] = node_id\n    return node_id\n\ndef _truncation_marker(total, emitted):\n    return {\"__truncated__\": True, \"remaining\": max(0, total - emitted)}\n\ndef _serialize_sequence(values, depth, node_refs):\n    values_list = _builtins.list(values)\n    emitted = min(len(values_list), _MAX_SERIALIZED_ITEMS)\n    result = [_serialize(x, depth + 1, node_refs) for x in values_list[:emitted]]\n    if emitted < len(values_list):\n        result.append(_truncation_marker(len(values_list), emitted))\n    return result\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, (_builtins.list, _builtins.tuple)):\n        return _serialize_sequence(obj, depth, node_refs)\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return _serialize_sequence(obj, depth, node_refs)\n    elif isinstance(obj, _builtins.dict):\n        items = _builtins.list(obj.items())\n        emitted = min(len(items), _MAX_SERIALIZED_ITEMS)\n        result = {str(k): _serialize(v, depth + 1, node_refs) for k, v in items[:emitted]}\n        if emitted < len(items):\n            result[\"__truncated__\"] = True\n            result[\"remaining\"] = len(items) - emitted\n        return result\n    elif isinstance(obj, set):\n        # Use try/except for sorting to handle heterogeneous sets\n        values = _builtins.list(obj)\n        emitted = min(len(values), _MAX_SERIALIZED_ITEMS)\n        try:\n            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in values[:emitted]])\n        except TypeError:\n            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in values[:emitted]]\n        result = {\"__type__\": \"set\", \"values\": sorted_vals}\n        if emitted < len(values):\n            result[\"__truncated__\"] = True\n            result[\"remaining\"] = len(values) - emitted\n        return result\n    elif isinstance(obj, TreeNode):\n        obj_ref = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\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 = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\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    elif hasattr(obj, '__dict__'):\n        obj_ref = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\n            \"__type__\": class_name,\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, _builtins.dict):\n            fields = []\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                fields.append((key_str, value))\n            for key_str, value in fields[:_MAX_OBJECT_FIELDS]:\n                result[key_str] = _serialize(value, depth + 1, node_refs)\n            if len(fields) > _MAX_OBJECT_FIELDS:\n                result[\"__truncated__\"] = True\n                result[\"remaining\"] = len(fields) - _MAX_OBJECT_FIELDS\n        return result\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\ndef _serialize_output(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, (_builtins.list, _builtins.tuple)):\n        return [_serialize_output(x, depth + 1, node_refs) for x in obj]\n    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':\n        return [_serialize_output(x, depth + 1, node_refs) for x in obj]\n    elif isinstance(obj, _builtins.dict):\n        return {str(k): _serialize_output(v, depth + 1, node_refs) for k, v in obj.items()}\n    elif isinstance(obj, set):\n        try:\n            sorted_vals = sorted([_serialize_output(x, depth + 1, node_refs) for x in obj])\n        except TypeError:\n            sorted_vals = [_serialize_output(x, depth + 1, node_refs) for x in obj]\n        return {\"__type__\": \"set\", \"values\": sorted_vals}\n    elif isinstance(obj, TreeNode):\n        obj_ref = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\n        result = {\n            \"__type__\": \"TreeNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize_output(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        if hasattr(obj, 'left'):\n            result[\"left\"] = _serialize_output(obj.left, depth + 1, node_refs)\n        if hasattr(obj, 'right'):\n            result[\"right\"] = _serialize_output(obj.right, depth + 1, node_refs)\n        return result\n    elif isinstance(obj, ListNode):\n        obj_ref = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\n        result = {\n            \"__type__\": \"ListNode\",\n            \"__id__\": node_id,\n            \"val\": _serialize_output(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),\n        }\n        result[\"next\"] = _serialize_output(obj.next, depth + 1, node_refs)\n        return result\n    elif callable(obj):\n        return _SKIP_SENTINEL\n    elif hasattr(obj, '__dict__'):\n        obj_ref = _builtins.id(obj)\n        if obj_ref in node_refs:\n            return {\"__ref__\": node_refs[obj_ref]}\n        node_id = _tracecode_ref_id(obj_ref, node_refs)\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\n            \"__type__\": class_name,\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, _builtins.dict):\n            for key, value in raw_fields.items():\n                key_str = str(key)\n                if key_str.startswith('_') or callable(value):\n                    continue\n                result[key_str] = _serialize_output(value, depth + 1, node_refs)\n        return result\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return _SKIP_SENTINEL\n        return repr_str\n",
+    PYTHON_EXECUTE_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (_builtins.list, _builtins.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, _builtins.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    elif hasattr(obj, '__dict__'):\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\"__type__\": class_name, \"__class__\": class_name}\n        try:\n            raw_fields = getattr(obj, '__dict__', None)\n        except Exception:\n            raw_fields = None\n        if isinstance(raw_fields, _builtins.dict):\n            for key, value in raw_fields.items():\n                key_str = str(key)\n                if key_str.startswith('_') or callable(value):\n                    continue\n                result[key_str] = _serialize(value, depth + 1)\n        return result\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
+    PYTHON_SERIALIZE_FUNCTION: "\n_MAX_SERIALIZE_DEPTH = 48\n\ndef _serialize(obj, depth=0):\n    if isinstance(obj, (bool, int, str, type(None))):\n        return obj\n    elif isinstance(obj, float):\n        if not math.isfinite(obj):\n            if math.isnan(obj):\n                return \"NaN\"\n            return \"Infinity\" if obj > 0 else \"-Infinity\"\n        return obj\n    if depth > _MAX_SERIALIZE_DEPTH:\n        return \"<max depth>\"\n    elif isinstance(obj, (_builtins.list, _builtins.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, _builtins.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    elif hasattr(obj, '__dict__'):\n        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')\n        result = {\"__type__\": class_name, \"__class__\": class_name}\n        try:\n            raw_fields = getattr(obj, '__dict__', None)\n        except Exception:\n            raw_fields = None\n        if isinstance(raw_fields, _builtins.dict):\n            for key, value in raw_fields.items():\n                key_str = str(key)\n                if key_str.startswith('_') or callable(value):\n                    continue\n                result[key_str] = _serialize(value, depth + 1)\n        return result\n    else:\n        repr_str = repr(obj)\n        if repr_str.startswith('<') and repr_str.endswith('>'):\n            return None\n        return repr_str\n",
   });
 
   scope.__TRACECODE_toPythonLiteral = __tracecodeToPythonLiteral;

package/workers/python/pyodide-worker.js

@@ -1,8 +1,8 @@
 /**
- * Pyodide Web Worker
+ * Python Web Worker
  * 
  * Runs Python code execution in a separate thread to avoid blocking the UI.
- * This worker handles loading Pyodide, executing code, and returning traces.
+ * This worker handles loading the Python runtime, executing code, and returning traces.
  * 
  * This is the canonical worker implementation for the browser Python runtime.
  * The legacy lib/execution/pyodide.ts path is deprecated and should not be used.
@@ -37,6 +37,7 @@ const GENERATED_HARNESS_SNIPPETS_PATHS = [
 let pyodide = null;
 let isLoading = false;
 let loadPromise = null;
+let pythonPackageLoadPromise = null;
 const WORKER_DEBUG = (() => {
   try {
     return typeof self !== 'undefined' && typeof self.location?.search === 'string' && self.location.search.includes('dev=');
@@ -45,6 +46,20 @@ const WORKER_DEBUG = (() => {
   }
 })();
 
+function emitRuntimeDiagnostic(level, phase, message, detail) {
+  if (!WORKER_DEBUG && level !== 'error') return;
+  const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : level === 'debug' ? 'debug' : 'info';
+  console[method]('[TraceRuntime]', {
+    schema: 'tracecode.runtime-diagnostic.v1',
+    source: 'harness',
+    component: 'PythonWorker',
+    runtime: 'python',
+    phase,
+    message,
+    ...(detail === undefined ? {} : { detail }),
+  });
+}
+
 // Interview mode runtime guard defaults. These are intentionally coarse
 // safeguards to stop runaway executions without exposing internals.
 const INTERVIEW_GUARD_DEFAULTS = Object.freeze({
@@ -55,21 +70,32 @@ const INTERVIEW_GUARD_DEFAULTS = Object.freeze({
   memoryCheckEvery: 200,
 });
 
+async function ensurePythonLibraryPackages(runtime) {
+  if (!runtime || typeof runtime.loadPackage !== 'function') return;
+  if (!pythonPackageLoadPromise) {
+    pythonPackageLoadPromise = runtime.loadPackage(['sortedcontainers']).catch((error) => {
+      pythonPackageLoadPromise = null;
+      const message = error instanceof Error ? error.message : String(error);
+      emitRuntimeDiagnostic('warn', 'package-preload-failed', 'Failed to preload Python packages.', { message });
+    });
+  }
+  await pythonPackageLoadPromise;
+}
+
 // Load generated shared harness snippets when available. Keep worker startup
 // resilient by falling back to embedded implementations if this import fails.
 if (typeof importScripts === 'function') {
   for (const scriptPath of GENERATED_HARNESS_SNIPPETS_PATHS) {
     try {
       importScripts(scriptPath);
-      if (WORKER_DEBUG) {
-        console.log('[PyodideWorker] Loaded generated harness snippets from', scriptPath);
-      }
+      emitRuntimeDiagnostic('info', 'generated-snippets-loaded', 'Loaded generated harness snippets.', { scriptPath });
       break;
     } catch (error) {
-      if (WORKER_DEBUG) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn('[PyodideWorker] Failed to load generated harness snippets from', scriptPath, message);
-      }
+      const message = error instanceof Error ? error.message : String(error);
+      emitRuntimeDiagnostic('warn', 'generated-snippets-load-failed', 'Failed to load generated harness snippets.', {
+        scriptPath,
+        message,
+      });
     }
   }
 }
@@ -195,7 +221,7 @@ def _ensure_node_value_aliases(node):
 def _dict_to_tree(d):
     if d is None:
         return None
-    if not isinstance(d, dict):
+    if not isinstance(d, _builtins.dict):
         return d
     if 'val' not in d and 'value' not in d:
         return d
@@ -210,7 +236,7 @@ def _dict_to_list(d, _refs=None):
         _refs = {}
     if d is None:
         return None
-    if not isinstance(d, dict):
+    if not isinstance(d, _builtins.dict):
         return d
     if '__ref__' in d:
         return _refs.get(d.get('__ref__'))
@@ -219,7 +245,7 @@ def _dict_to_list(d, _refs=None):
     node = ListNode(d.get('val', d.get('value', 0)))
     _ensure_node_value_aliases(node)
     node_id = d.get('__id__')
-    if isinstance(node_id, str) and node_id:
+    if isinstance(node_id, _builtins.str) and node_id:
         _refs[node_id] = node
     node.next = _dict_to_list(d.get('next'), _refs)
     return node
@@ -232,7 +258,34 @@ const PYTHON_TRACE_SERIALIZE_FUNCTION_SNIPPET = resolveSharedPythonSnippet(
 # Sentinel to mark skipped values (functions, etc.) - distinct from None
 _SKIP_SENTINEL = "__TRACECODE_SKIP__"
 _MAX_SERIALIZE_DEPTH = 48
+_MAX_SERIALIZED_ITEMS = 64
 _MAX_OBJECT_FIELDS = 32
+_tracecode_global_object_refs = {}
+_tracecode_next_object_ref_id = 0
+
+def _tracecode_ref_id(obj_ref, node_refs):
+    global _tracecode_next_object_ref_id
+    if obj_ref in node_refs:
+        return node_refs[obj_ref]
+    if obj_ref in _tracecode_global_object_refs:
+        node_id = _tracecode_global_object_refs[obj_ref]
+    else:
+        node_id = f"ref-{_tracecode_next_object_ref_id}"
+        _tracecode_global_object_refs[obj_ref] = node_id
+        _tracecode_next_object_ref_id += 1
+    node_refs[obj_ref] = node_id
+    return node_id
+
+def _truncation_marker(total, emitted):
+    return {"__truncated__": True, "remaining": max(0, total - emitted)}
+
+def _serialize_sequence(values, depth, node_refs):
+    values_list = _builtins.list(values)
+    emitted = min(len(values_list), _MAX_SERIALIZED_ITEMS)
+    result = [_serialize(x, depth + 1, node_refs) for x in values_list[:emitted]]
+    if emitted < len(values_list):
+        result.append(_truncation_marker(len(values_list), emitted))
+    return result
 
 def _serialize(obj, depth=0, node_refs=None):
     if node_refs is None:
@@ -247,25 +300,36 @@ def _serialize(obj, depth=0, node_refs=None):
         return obj
     if depth > _MAX_SERIALIZE_DEPTH:
         return "<max depth>"
-    elif isinstance(obj, (list, tuple)):
-        return [_serialize(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, (_builtins.list, _builtins.tuple)):
+        return _serialize_sequence(obj, depth, node_refs)
     elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
-        return [_serialize(x, depth + 1, node_refs) for x in obj]
-    elif isinstance(obj, dict):
-        return {str(k): _serialize(v, depth + 1, node_refs) for k, v in obj.items()}
+        return _serialize_sequence(obj, depth, node_refs)
+    elif isinstance(obj, _builtins.dict):
+        items = _builtins.list(obj.items())
+        emitted = min(len(items), _MAX_SERIALIZED_ITEMS)
+        result = {str(k): _serialize(v, depth + 1, node_refs) for k, v in items[:emitted]}
+        if emitted < len(items):
+            result["__truncated__"] = True
+            result["remaining"] = len(items) - emitted
+        return result
     elif isinstance(obj, set):
         # Use try/except for sorting to handle heterogeneous sets
+        values = _builtins.list(obj)
+        emitted = min(len(values), _MAX_SERIALIZED_ITEMS)
         try:
-            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in obj])
+            sorted_vals = sorted([_serialize(x, depth + 1, node_refs) for x in values[:emitted]])
         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')):
-        obj_ref = id(obj)
+            sorted_vals = [_serialize(x, depth + 1, node_refs) for x in values[:emitted]]
+        result = {"__type__": "set", "values": sorted_vals}
+        if emitted < len(values):
+            result["__truncated__"] = True
+            result["remaining"] = len(values) - emitted
+        return result
+    elif isinstance(obj, TreeNode):
+        obj_ref = _builtins.id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
-        node_id = f"tree-{obj_ref}"
-        node_refs[obj_ref] = node_id
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
         result = {
             "__type__": "TreeNode",
             "__id__": node_id,
@@ -276,12 +340,11 @@ 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'):
-        obj_ref = id(obj)
+    elif isinstance(obj, ListNode):
+        obj_ref = _builtins.id(obj)
         if obj_ref in node_refs:
             return {"__ref__": node_refs[obj_ref]}
-        node_id = f"list-{obj_ref}"
-        node_refs[obj_ref] = node_id
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
         result = {
             "__type__": "ListNode",
             "__id__": node_id,
@@ -289,15 +352,17 @@ def _serialize(obj, depth=0, node_refs=None):
         }
         result["next"] = _serialize(obj.next, depth + 1, node_refs)
         return result
+    elif callable(obj):
+        # Skip functions entirely - return sentinel
+        return _SKIP_SENTINEL
     elif hasattr(obj, '__dict__'):
-        obj_ref = id(obj)
+        obj_ref = _builtins.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
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
         class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')
         result = {
-            "__type__": "object",
+            "__type__": class_name,
             "__class__": class_name,
             "__id__": node_id,
         }
@@ -305,26 +370,106 @@ def _serialize(obj, depth=0, node_refs=None):
             raw_fields = getattr(obj, '__dict__', None)
         except Exception:
             raw_fields = None
-        if isinstance(raw_fields, dict):
-            added = 0
+        if isinstance(raw_fields, _builtins.dict):
+            fields = []
             for key, value in raw_fields.items():
                 key_str = str(key)
                 if key_str.startswith('_'):
                     continue
                 if callable(value):
                     continue
+                fields.append((key_str, value))
+            for key_str, value in fields[:_MAX_OBJECT_FIELDS]:
                 result[key_str] = _serialize(value, depth + 1, node_refs)
-                added += 1
-                if added >= _MAX_OBJECT_FIELDS:
-                    result["__truncated__"] = True
-                    break
+            if len(fields) > _MAX_OBJECT_FIELDS:
+                result["__truncated__"] = True
+                result["remaining"] = len(fields) - _MAX_OBJECT_FIELDS
+        return result
+    else:
+        repr_str = repr(obj)
+        # Filter out function-like representations (e.g., <function foo at 0x...>)
+        if repr_str.startswith('<') and repr_str.endswith('>'):
+            return _SKIP_SENTINEL
+        return repr_str
+
+def _serialize_output(obj, depth=0, node_refs=None):
+    if node_refs is None:
+        node_refs = {}
+    if isinstance(obj, (bool, int, str, type(None))):
+        return obj
+    elif isinstance(obj, float):
+        if not math.isfinite(obj):
+            if math.isnan(obj):
+                return "NaN"
+            return "Infinity" if obj > 0 else "-Infinity"
+        return obj
+    if depth > _MAX_SERIALIZE_DEPTH:
+        return "<max depth>"
+    elif isinstance(obj, (_builtins.list, _builtins.tuple)):
+        return [_serialize_output(x, depth + 1, node_refs) for x in obj]
+    elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
+        return [_serialize_output(x, depth + 1, node_refs) for x in obj]
+    elif isinstance(obj, _builtins.dict):
+        return {str(k): _serialize_output(v, depth + 1, node_refs) for k, v in obj.items()}
+    elif isinstance(obj, set):
+        try:
+            sorted_vals = sorted([_serialize_output(x, depth + 1, node_refs) for x in obj])
+        except TypeError:
+            sorted_vals = [_serialize_output(x, depth + 1, node_refs) for x in obj]
+        return {"__type__": "set", "values": sorted_vals}
+    elif isinstance(obj, TreeNode):
+        obj_ref = _builtins.id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
+        result = {
+            "__type__": "TreeNode",
+            "__id__": node_id,
+            "val": _serialize_output(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        if hasattr(obj, 'left'):
+            result["left"] = _serialize_output(obj.left, depth + 1, node_refs)
+        if hasattr(obj, 'right'):
+            result["right"] = _serialize_output(obj.right, depth + 1, node_refs)
+        return result
+    elif isinstance(obj, ListNode):
+        obj_ref = _builtins.id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
+        result = {
+            "__type__": "ListNode",
+            "__id__": node_id,
+            "val": _serialize_output(getattr(obj, 'val', getattr(obj, 'value', None)), depth + 1, node_refs),
+        }
+        result["next"] = _serialize_output(obj.next, depth + 1, node_refs)
         return result
     elif callable(obj):
-        # Skip functions entirely - return sentinel
         return _SKIP_SENTINEL
+    elif hasattr(obj, '__dict__'):
+        obj_ref = _builtins.id(obj)
+        if obj_ref in node_refs:
+            return {"__ref__": node_refs[obj_ref]}
+        node_id = _tracecode_ref_id(obj_ref, node_refs)
+        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')
+        result = {
+            "__type__": class_name,
+            "__class__": class_name,
+            "__id__": node_id,
+        }
+        try:
+            raw_fields = getattr(obj, '__dict__', None)
+        except Exception:
+            raw_fields = None
+        if isinstance(raw_fields, _builtins.dict):
+            for key, value in raw_fields.items():
+                key_str = str(key)
+                if key_str.startswith('_') or callable(value):
+                    continue
+                result[key_str] = _serialize_output(value, depth + 1, node_refs)
+        return result
     else:
         repr_str = repr(obj)
-        # Filter out function-like representations (e.g., <function foo at 0x...>)
         if repr_str.startswith('<') and repr_str.endswith('>'):
             return _SKIP_SENTINEL
         return repr_str
@@ -347,30 +492,44 @@ def _serialize(obj, depth=0):
         return obj
     if depth > _MAX_SERIALIZE_DEPTH:
         return "<max depth>"
-    elif isinstance(obj, (list, tuple)):
+    elif isinstance(obj, (_builtins.list, _builtins.tuple)):
         return [_serialize(x, depth + 1) for x in obj]
     elif getattr(obj, '__class__', None) and getattr(obj.__class__, '__name__', '') == 'deque':
         return [_serialize(x, depth + 1) for x in obj]
-    elif isinstance(obj, dict):
+    elif isinstance(obj, _builtins.dict):
         return {str(k): _serialize(v, depth + 1) for k, v in obj.items()}
     elif isinstance(obj, set):
         try:
             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
     elif callable(obj):
         return None
+    elif hasattr(obj, '__dict__'):
+        class_name = getattr(getattr(obj, '__class__', None), '__name__', 'object')
+        result = {"__type__": class_name, "__class__": class_name}
+        try:
+            raw_fields = getattr(obj, '__dict__', None)
+        except Exception:
+            raw_fields = None
+        if isinstance(raw_fields, _builtins.dict):
+            for key, value in raw_fields.items():
+                key_str = str(key)
+                if key_str.startswith('_') or callable(value):
+                    continue
+                result[key_str] = _serialize(value, depth + 1)
+        return result
     else:
         repr_str = repr(obj)
         if repr_str.startswith('<') and repr_str.endswith('>'):
@@ -399,9 +558,7 @@ async function loadPyodideInstance() {
           try {
             importScripts(`${indexURL}pyodide.js`);
             loadedBootstrap = true;
-            if (WORKER_DEBUG) {
-              console.log('[PyodideWorker] Loaded bootstrap script from', indexURL);
-            }
+            emitRuntimeDiagnostic('info', 'bootstrap-loaded', 'Loaded Python runtime bootstrap script.', { indexURL });
             break;
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -420,9 +577,8 @@ async function loadPyodideInstance() {
       for (const indexURL of PYODIDE_INDEX_URLS) {
         try {
           pyodide = await self.loadPyodide({ indexURL });
-          if (WORKER_DEBUG) {
-            console.log('[PyodideWorker] Initialized runtime from', indexURL);
-          }
+          await ensurePythonLibraryPackages(pyodide);
+          emitRuntimeDiagnostic('info', 'runtime-initialized', 'Initialized Python runtime.', { indexURL });
           return pyodide;
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -460,15 +616,14 @@ function loadPyodideRuntimeCore() {
       for (const scriptPath of PYODIDE_RUNTIME_CORE_PATHS) {
         try {
           importScripts(scriptPath);
-          if (WORKER_DEBUG) {
-            console.log('[PyodideWorker] Loaded runtime core from', scriptPath);
-          }
+          emitRuntimeDiagnostic('info', 'runtime-core-loaded', 'Loaded Python runtime core.', { scriptPath });
           break;
         } catch (error) {
-          if (WORKER_DEBUG) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn('[PyodideWorker] Failed to load runtime core from', scriptPath, message);
-          }
+          const message = error instanceof Error ? error.message : String(error);
+          emitRuntimeDiagnostic('warn', 'runtime-core-load-failed', 'Failed to load Python runtime core.', {
+            scriptPath,
+            message,
+          });
         }
       }
     }
@@ -562,12 +717,19 @@ async function processMessage(data) {
     switch (type) {
       case 'init': {
         const startTime = performance.now();
-        await loadPyodideInstance();
         const loadTimeMs = performance.now() - startTime;
         self.postMessage({ id, type: 'init-result', payload: { success: true, loadTimeMs } });
         break;
       }
 
+      case 'warmup': {
+        const startTime = performance.now();
+        await loadPyodideInstance();
+        const loadTimeMs = performance.now() - startTime;
+        self.postMessage({ id, type: 'warmup-result', payload: { success: true, loadTimeMs } });
+        break;
+      }
+
       case 'execute-with-tracing': {
         const { code, functionName, inputs, executionStyle, options } = payload;
         const result = await executeWithTracing(code, functionName, inputs, executionStyle ?? 'function', options);
@@ -647,6 +809,7 @@ self.onmessage = function(event) {
 };
 
 // Notify that worker is ready
+emitRuntimeDiagnostic('info', 'worker-ready', 'Python worker is ready.');
 self.postMessage({ type: 'worker-ready' });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1568,9 +1731,7 @@ async function analyzeCodeAST(code) {
         throw error;
       }
 
-      if (WORKER_DEBUG) {
-        console.warn('[Pyodide Worker] analyze() missing; reinitializing AST analyzer');
-      }
+      emitRuntimeDiagnostic('warn', 'ast-analyzer-reinit', 'analyze() missing; reinitializing AST analyzer.');
       analyzerInitialized = false;
     }
   }