From 5f3c2428d37daf1ed6ed92f64a2456d42a547fbb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 13:58:31 -0500
Subject: [PATCH 001/450] Promote full parser and VM to stable native build

---
 tools/build_native_typed.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/tools/build_native_typed.py b/tools/build_native_typed.py
index 9c852b38..825c7265 100644
--- a/tools/build_native_typed.py
+++ b/tools/build_native_typed.py
@@ -1,9 +1,9 @@
-"""Build PortaPy's current native interpreter entry.
+"""Build PortaPy's stable full parser/VM runtime.
 
-The historical filename remains the stable CI/release command. Default builds
-now use the generated host-call entry, including scalar expressions, control
-flow, positional functions, opaque host graphs, and synchronous callbacks.
-Passing ``--source`` retains focused source-entry compiler probes.
+The historical command remains the canonical CI and release entry. Default
+builds emit the standalone parser, frontend, bytecode VM, host bridge, public
+environment API, and complete stable value/container ABI. Passing ``--source``
+enables focused compiler probes without running the full-runtime pipeline.
 """
 from __future__ import annotations
 
@@ -18,7 +18,7 @@
     sys.path.insert(0, str(REPOSITORY_ROOT))
 
 from tools.build_native import BuildFailure, build_native
-from tools.build_native_host_calls import main as build_host_call_entry
+from tools.build_native_full_runtime import main as build_full_runtime_entry
 from tools.python_surface import PYTHON_MODULE_EXPORTS
 
 
@@ -45,6 +45,8 @@ def _build_explicit_source(argv: list[str]) -> int:
     metadata["generated_function_entry"] = False
     metadata["generated_host_entry"] = False
     metadata["generated_host_call_entry"] = False
+    metadata["full_frontend_vm"] = False
+    metadata["standalone_parser"] = False
     metadata["python_module_exports"] = list(PYTHON_MODULE_EXPORTS)
     metadata["python_module_entry"] = "portapy"
     metadata_path = args.output.resolve().with_suffix(args.output.suffix + ".json")
@@ -57,7 +59,7 @@ def main(argv: list[str] | None = None) -> int:
     arguments = list(sys.argv[1:] if argv is None else argv)
     if "--source" in arguments:
         return _build_explicit_source(arguments)
-    return build_host_call_entry(arguments)
+    return build_full_runtime_entry(arguments)
 
 
 if __name__ == "__main__":

From 079793ac9308582b0ddf6522b6936f21d3528286 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 13:59:58 -0500
Subject: [PATCH 002/450] Require full parser and VM in stable release gate

---
 tools/release_gate.py | 209 +++++++++++++++++++++++-------------------
 1 file changed, 115 insertions(+), 94 deletions(-)

diff --git a/tools/release_gate.py b/tools/release_gate.py
index 0dfeccf4..327d7313 100644
--- a/tools/release_gate.py
+++ b/tools/release_gate.py
@@ -10,20 +10,23 @@
 from tools.python_surface import PYTHON_MODULE_EXPORTS
 
 
-REQUIRED = {
-    "windows": "portapy.dll",
-    "linux": "libportapy.so",
-}
+REQUIRED = {"windows": "portapy.dll", "linux": "libportapy.so"}
 PYTHON_MODULE_ENTRY = "portapy"
+FULL_RUNTIME_FLAGS = (
+    "full_frontend_vm",
+    "standalone_parser",
+    "reference_runtime_handles",
+    "public_tuple_abi",
+    "public_dict_abi",
+    "public_list_abi",
+    "direct_float_abi",
+)
 
 
 def sha256(path: Path) -> str:
     digest = hashlib.sha256()
     with path.open("rb") as stream:
-        while True:
-            chunk = stream.read(1024 * 1024)
-            if not chunk:
-                break
+        while chunk := stream.read(1024 * 1024):
             digest.update(chunk)
     return digest.hexdigest()
 
@@ -38,6 +41,75 @@ def _read_json(path: Path) -> dict[str, object]:
     return value
 
 
+def _validate_status(status: dict[str, object], expected_tag: str) -> bool:
+    if status.get("release_tag") != expected_tag:
+        raise SystemExit(
+            f"release tag mismatch: expected {expected_tag!r}, "
+            f"status declares {status.get('release_tag')!r}"
+        )
+    if status.get("python_built_runtime") is not True:
+        raise SystemExit("release status does not assert a Python-built runtime")
+
+    source_ready = status.get("source_execution_ready") is True
+    if source_ready:
+        if status.get("stage") != "stable" or status.get("prerelease") is not False:
+            raise SystemExit("source-ready PortaPy must be marked as a stable release")
+        blockers = status.get("release_blockers")
+        if blockers not in ([], None):
+            raise SystemExit("stable source-ready release still declares blockers")
+    else:
+        if status.get("stage") != "developer-preview" or status.get("prerelease") is not True:
+            raise SystemExit("non-source-ready PortaPy must remain a developer preview")
+    return source_ready
+
+
+def _validate_artifact(
+    path: Path,
+    *,
+    target: str,
+    source_ready: bool,
+    expected_exports: list[str],
+    expected_python_exports: list[str],
+) -> dict[str, object]:
+    metadata_path = path.with_suffix(path.suffix + ".json")
+    if not path.is_file() or path.stat().st_size < 4096:
+        raise SystemExit(f"missing or implausibly small native artifact: {path}")
+    metadata = _read_json(metadata_path)
+    actual_digest = sha256(path)
+
+    expected = {
+        "target": target,
+        "artifact": path.name,
+        "size": path.stat().st_size,
+        "sha256": actual_digest,
+        "python_built_runtime": True,
+        "host_bridge": True,
+        "host_calls": True,
+        "native_environment_adapter": True,
+        "public_environment_api": True,
+        "public_exports": expected_exports,
+        "python_module_exports": expected_python_exports,
+        "python_module_entry": PYTHON_MODULE_ENTRY,
+    }
+    for key, value in expected.items():
+        if metadata.get(key) != value:
+            raise SystemExit(f"{key} mismatch in {metadata_path}")
+
+    if source_ready:
+        for flag in FULL_RUNTIME_FLAGS:
+            if metadata.get(flag) is not True:
+                raise SystemExit(f"full Runtime flag {flag!r} missing in {metadata_path}")
+    elif metadata.get("generated_host_call_entry") is not True:
+        raise SystemExit(f"preview artifact is not host-call-entry generated: {metadata_path}")
+
+    return {
+        "platform": target,
+        "sha256": actual_digest,
+        "size": path.stat().st_size,
+        "metadata": metadata_path.name,
+    }
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("dist", type=Path)
@@ -46,67 +118,24 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     status = _read_json(args.status)
-    if status.get("release_tag") != args.expected_tag:
-        raise SystemExit(
-            f"release tag mismatch: expected {args.expected_tag!r}, "
-            f"status declares {status.get('release_tag')!r}"
-        )
-    if status.get("stage") != "developer-preview" or status.get("prerelease") is not True:
-        raise SystemExit("3.14-dev.1 must remain explicitly marked as a prerelease")
-    if status.get("python_built_runtime") is not True:
-        raise SystemExit("release status does not assert a Python-built runtime")
-    if status.get("source_execution_ready") is not False:
-        raise SystemExit(
-            "developer preview must state that source execution is not ready; "
-            "use a new final-release status when the full PortaPy parser lands"
-        )
-
+    source_ready = _validate_status(status, args.expected_tag)
     args.dist.mkdir(parents=True, exist_ok=True)
-    records: dict[str, dict[str, object]] = {}
+
     expected_exports = list(public_exports(host_bridge=True, host_calls=True))
     expected_python_exports = list(PYTHON_MODULE_EXPORTS)
+    records: dict[str, dict[str, object]] = {}
     for target, name in REQUIRED.items():
-        path = args.dist / name
-        metadata_path = path.with_suffix(path.suffix + ".json")
-        if not path.is_file() or path.stat().st_size < 4096:
-            raise SystemExit(f"missing or implausibly small native artifact: {path}")
-        metadata = _read_json(metadata_path)
-        actual_digest = sha256(path)
-        if metadata.get("target") != target:
-            raise SystemExit(f"target mismatch in {metadata_path}")
-        if metadata.get("artifact") != name:
-            raise SystemExit(f"artifact-name mismatch in {metadata_path}")
-        if metadata.get("size") != path.stat().st_size:
-            raise SystemExit(f"artifact-size mismatch in {metadata_path}")
-        if metadata.get("sha256") != actual_digest:
-            raise SystemExit(f"artifact digest mismatch in {metadata_path}")
-        if metadata.get("python_built_runtime") is not True:
-            raise SystemExit(f"artifact is not marked Python-built: {metadata_path}")
-        if metadata.get("host_bridge") is not True:
-            raise SystemExit(f"artifact does not include the host bridge: {metadata_path}")
-        if metadata.get("host_calls") is not True:
-            raise SystemExit(f"artifact does not include host-call dispatch: {metadata_path}")
-        if metadata.get("native_environment_adapter") is not True:
-            raise SystemExit(f"artifact does not include environment management: {metadata_path}")
-        if metadata.get("public_environment_api") is not True:
-            raise SystemExit(f"artifact does not include the public environment API: {metadata_path}")
-        if metadata.get("generated_host_call_entry") is not True:
-            raise SystemExit(f"artifact is not host-call-entry generated: {metadata_path}")
-        if metadata.get("public_exports") != expected_exports:
-            raise SystemExit(f"public export surface mismatch in {metadata_path}")
-        if metadata.get("python_module_exports") != expected_python_exports:
-            raise SystemExit(f"Python module surface mismatch in {metadata_path}")
-        if metadata.get("python_module_entry") != PYTHON_MODULE_ENTRY:
-            raise SystemExit(f"Python module entry mismatch in {metadata_path}")
-        records[name] = {
-            "platform": target,
-            "sha256": actual_digest,
-            "size": path.stat().st_size,
-            "metadata": metadata_path.name,
-        }
-
-    checksums = args.dist / "checksums.json"
-    checksums.write_text(json.dumps(records, indent=2) + "\n", encoding="utf-8")
+        records[name] = _validate_artifact(
+            args.dist / name,
+            target=target,
+            source_ready=source_ready,
+            expected_exports=expected_exports,
+            expected_python_exports=expected_python_exports,
+        )
+
+    (args.dist / "checksums.json").write_text(
+        json.dumps(records, indent=2) + "\n", encoding="utf-8"
+    )
     manifest = {
         "schema": 1,
         "release": status,
@@ -116,17 +145,16 @@ def main(argv: list[str] | None = None) -> int:
         "python_module_entry": PYTHON_MODULE_ENTRY,
     }
     (args.dist / "release-manifest.json").write_text(
-        json.dumps(manifest, indent=2) + "\n",
-        encoding="utf-8",
+        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
     )
 
     completed = status.get("completed_surface")
     blockers = status.get("release_blockers")
+    title = "# PortaPy 3.14.0" if source_ready else "# PortaPy 3.14 Developer Preview 1"
     notes = [
-        "# PortaPy 3.14 Developer Preview 1",
+        title,
         "",
-        "This prerelease contains genuine native libraries generated from "
-        "PortaPy's Python-authored runtime state by asmpython.",
+        "PortaPy is a Python-built embeddable runtime compiled into native Linux and Windows libraries.",
         "",
         "## Implemented native surface",
         "",
@@ -138,38 +166,31 @@ def main(argv: list[str] | None = None) -> int:
             "",
             "## Universal embedding surface",
             "",
-            "The DLL/SO exports first-class `new`, `add`, `add_all`, `execute`, "
-            "`evaluate`, and `destroy` helpers through a language-neutral C ABI. "
-            "The same environment handle can be used with the lower-level runtime, "
-            "value, global, callback, container, and structured-error functions.",
-            "",
-            "The Python package exposes the same contract through hosted and native "
-            "`Environment.add()` / `Environment.add_all()` methods. Host languages "
-            "load their own modules; PortaPy does not expose `import_module`.",
-            "",
-            "## Not yet included",
-            "",
-            "This is not the final Python 3.14 interpreter release. Remaining "
-            "gates include closures, classes, the complete frontend/bytecode VM "
-            "transition, broader object syntax, native imports inside executed "
-            "PortaPy source, and full traceback-frame retrieval.",
+            "The DLL/SO exports language-neutral `new`, `add`, `add_all`, `execute`, `evaluate`, and `destroy` helpers alongside the complete low-level runtime, value, callback, container, snapshot, and error ABI.",
             "",
         ]
     )
-    if isinstance(blockers, list):
-        notes.extend(f"- {item}" for item in blockers)
+    if source_ready:
+        notes.extend(
+            [
+                "## Standalone source execution",
+                "",
+                "The canonical artifacts include PortaPy's standalone parser, full frontend, bytecode VM, closures, classes, configured imports, and synthetic traceback frames.",
+                "",
+            ]
+        )
+    else:
+        notes.extend(["## Not yet included", ""])
+        if isinstance(blockers, list):
+            notes.extend(f"- {item}" for item in blockers)
+        notes.append("")
     notes.extend(
         [
-            "",
-            "The release includes `portapy.dll`, `libportapy.so`, the public "
-            "header, build metadata, FFI examples, and SHA-256 checksums.",
+            "The release includes `portapy.dll`, `libportapy.so`, the public header, build metadata, FFI examples, and SHA-256 checksums.",
             "",
         ]
     )
-    (args.dist / "RELEASE_NOTES.md").write_text(
-        "\n".join(notes),
-        encoding="utf-8",
-    )
+    (args.dist / "RELEASE_NOTES.md").write_text("\n".join(notes), encoding="utf-8")
     return 0
 
 

From ff30850756fc5e1561f740e4a882a26a8862c347 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:00:26 -0500
Subject: [PATCH 003/450] Test preview and stable full-runtime release gates

---
 tests/test_release_gate.py | 73 ++++++++++++++++++++++++--------------
 1 file changed, 46 insertions(+), 27 deletions(-)

diff --git a/tests/test_release_gate.py b/tests/test_release_gate.py
index 04664cc1..7c5adcbb 100644
--- a/tests/test_release_gate.py
+++ b/tests/test_release_gate.py
@@ -6,29 +6,29 @@
 
 from tools.native_surface import public_exports
 from tools.python_surface import PYTHON_MODULE_EXPORTS
-from tools.release_gate import main
+from tools.release_gate import FULL_RUNTIME_FLAGS, main
 
 
 def _sha256(path: Path) -> str:
     return hashlib.sha256(path.read_bytes()).hexdigest()
 
 
-def test_release_gate_validates_both_native_artifacts(tmp_path: Path) -> None:
-    dist = tmp_path / "dist"
-    dist.mkdir()
+def _write_artifacts(dist: Path, *, full_runtime: bool) -> None:
     expected_exports = list(public_exports(host_bridge=True, host_calls=True))
     for target, name in (("linux", "libportapy.so"), ("windows", "portapy.dll")):
         artifact = dist / name
-        artifact.write_bytes((target.encode("ascii") + b"\0") * 1024)
-        if artifact.stat().st_size < 4096:
-            artifact.write_bytes(artifact.read_bytes() + b"x" * 4096)
-        metadata = {
+        artifact.write_bytes((target.encode("ascii") + b"\0") * 1024 + b"x" * 4096)
+        metadata: dict[str, object] = {
             "schema": 1,
             "target": target,
             "artifact": name,
             "size": artifact.stat().st_size,
             "sha256": _sha256(artifact),
-            "source": "src/portapy/native_api_host_calls.py",
+            "source": (
+                "src/portapy/native_full_reference_entry.py"
+                if full_runtime
+                else "src/portapy/native_api_host_calls.py"
+            ),
             "source_sha256": "0" * 64,
             "public_exports": expected_exports,
             "python_module_exports": list(PYTHON_MODULE_EXPORTS),
@@ -38,38 +38,57 @@ def test_release_gate_validates_both_native_artifacts(tmp_path: Path) -> None:
             "host_calls": True,
             "native_environment_adapter": True,
             "public_environment_api": True,
-            "generated_host_call_entry": True,
+            "generated_host_call_entry": not full_runtime,
         }
+        if full_runtime:
+            for flag in FULL_RUNTIME_FLAGS:
+                metadata[flag] = True
         artifact.with_suffix(artifact.suffix + ".json").write_text(
-            json.dumps(metadata),
-            encoding="utf-8",
+            json.dumps(metadata), encoding="utf-8"
         )
 
-    status = tmp_path / "status.json"
-    status.write_text(
+
+def _write_status(path: Path, *, source_ready: bool) -> str:
+    tag = "3.14.0" if source_ready else "3.14-dev.1"
+    path.write_text(
         json.dumps(
             {
                 "version_line": "3.14",
-                "release_tag": "3.14-dev.1",
-                "stage": "developer-preview",
-                "prerelease": True,
+                "release_tag": tag,
+                "stage": "stable" if source_ready else "developer-preview",
+                "prerelease": not source_ready,
                 "python_built_runtime": True,
-                "source_execution_ready": False,
+                "source_execution_ready": source_ready,
                 "completed_surface": ["runtime handles"],
-                "release_blockers": ["native parser"],
+                "release_blockers": [] if source_ready else ["native parser"],
             }
         ),
         encoding="utf-8",
     )
+    return tag
+
+
+def _run_gate(tmp_path: Path, *, source_ready: bool) -> Path:
+    dist = tmp_path / "dist"
+    dist.mkdir()
+    _write_artifacts(dist, full_runtime=source_ready)
+    status = tmp_path / "status.json"
+    tag = _write_status(status, source_ready=source_ready)
+    assert main([str(dist), "--status", str(status), "--expected-tag", tag]) == 0
+    return dist
+
+
+def test_release_gate_validates_preview_artifacts(tmp_path: Path) -> None:
+    dist = _run_gate(tmp_path, source_ready=False)
+    manifest = json.loads((dist / "release-manifest.json").read_text(encoding="utf-8"))
+    assert manifest["release"]["source_execution_ready"] is False
+    assert "Not yet included" in (dist / "RELEASE_NOTES.md").read_text(encoding="utf-8")
+
 
-    assert main([str(dist), "--status", str(status), "--expected-tag", "3.14-dev.1"]) == 0
-    assert (dist / "checksums.json").is_file()
+def test_release_gate_validates_full_runtime_artifacts(tmp_path: Path) -> None:
+    dist = _run_gate(tmp_path, source_ready=True)
     manifest = json.loads((dist / "release-manifest.json").read_text(encoding="utf-8"))
-    assert manifest["release"]["stage"] == "developer-preview"
-    assert manifest["public_exports"] == expected_exports
+    assert manifest["release"]["source_execution_ready"] is True
     assert manifest["python_module_exports"] == list(PYTHON_MODULE_EXPORTS)
-    assert manifest["python_module_entry"] == "portapy"
     notes = (dist / "RELEASE_NOTES.md").read_text(encoding="utf-8")
-    assert "not the final Python 3.14 interpreter release" in notes
-    assert "`add_all`" in notes
-    assert "does not expose `import_module`" in notes
+    assert "Standalone source execution" in notes

From dd0ae826fdda434e13da6333baec0611b861ddd9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:00:40 -0500
Subject: [PATCH 004/450] Release PortaPy 3.14.0

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 19876880..2edab0e7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "portapy"
-version = "3.14.0.dev1"
+version = "3.14.0"
 description = "Fully Python-built embeddable interpreter forked from pyinbin"
 readme = "README.md"
 requires-python = ">=3.11"

From c6dadbe8b5f50de03e49b4f073037847c0c275dc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:01:28 -0500
Subject: [PATCH 005/450] Mark PortaPy 3.14.0 source-ready

---
 RELEASE_STATUS.json | 161 +++++++++++---------------------------------
 1 file changed, 39 insertions(+), 122 deletions(-)

diff --git a/RELEASE_STATUS.json b/RELEASE_STATUS.json
index a1de3d42..69bab868 100644
--- a/RELEASE_STATUS.json
+++ b/RELEASE_STATUS.json
@@ -1,130 +1,47 @@
 {
   "version_line": "3.14",
-  "release_tag": "3.14-dev.1",
-  "stage": "developer-preview",
-  "prerelease": true,
+  "release_tag": "3.14.0",
+  "stage": "stable",
+  "prerelease": false,
   "python_built_runtime": true,
   "native_targets": ["linux-x86_64", "windows-x86_64"],
-  "source_execution_ready": false,
+  "source_execution_ready": true,
   "completed_surface": [
-    "runtime handles",
-    "environment handles aliasing runtime handles",
-    "first-class native new and new_with_config helpers",
-    "first-class native add and add_all binding helpers",
-    "first-class native add_value_utf8 and add_callable_utf8 helpers",
-    "first-class native execute evaluate and destroy helpers",
-    "helper and low-level callback dispatch coexistence",
-    "language-neutral C ABI usable from foreign-function interfaces",
-    "host-owned module loading without a PortaPy import_module API",
-    "None values",
-    "bool values",
-    "signed 64-bit integer values",
-    "bit-exact binary64 values",
-    "UTF-8 string value handles",
-    "arbitrary bytes value handles",
-    "opaque host object value handles with stable 64-bit IDs",
-    "host callable value handles with stable 64-bit IDs",
-    "checked text and byte buffer copies",
-    "retain and release",
-    "runtime isolation",
-    "precedence-aware integer arithmetic and power expressions",
-    "integer shifts and bitwise expressions",
-    "string and bytes concatenation and repetition",
-    "typed literal evaluation for None bool str and bytes",
-    "UTF-8 source literal encoding across hosted and native byte-oriented boundaries",
-    "immutable tuple literals",
-    "empty single-item multi-item and nested tuples",
-    "positive negative and chained tuple indexing",
-    "tuple-aware len truthiness and structural equality",
-    "tuple values in native functions and control flow",
-    "tuple element ownership in flat runtime handle storage",
-    "public immutable tuple construction",
-    "public tuple size and retained item extraction",
-    "recursive tuple release through ordinary value ownership",
-    "recursive Python tuple boxing and unboxing",
-    "tuple globals snapshots and host callback round-trips",
-    "owned string-key dictionary values",
-    "dictionary len truthiness structural equality and string-key indexing",
-    "recursive dictionary child ownership",
-    "keyword variadic parameters packed into dictionaries",
-    "mixed fixed positional-only keyword-only positional variadic and keyword variadic calls",
-    "positional-only names captured by keyword variadics",
-    "nested keyword variadic calls and local restoration",
-    "public dictionary construction replacement size key enumeration and retained lookup",
-    "public dictionary recursive ownership",
-    "recursive Python mapping boxing and unboxing",
-    "dictionary globals snapshots and host callback round-trips",
-    "owned mutable list values",
-    "empty nested and trailing-comma list literals",
-    "positive and negative list indexing",
-    "list len truthiness and recursive structural equality",
-    "recursive list child ownership",
-    "list values in native functions and control flow",
-    "container literals inside native function calls",
-    "public list construction size retained extraction replacement and append",
-    "recursive Python list boxing and unboxing",
-    "list globals snapshots and host callback round-trips",
-    "equality and ordering comparisons",
-    "identity comparisons with is and is not",
-    "not and or with operand-return semantics",
-    "truthiness for native scalar handles",
-    "typed global assignment lookup aliasing and augmented assignment",
-    "retained native host global injection",
-    "native host attribute graph registration and lookup",
-    "dotted host attribute traversal in eval and source execution",
-    "host ID recovery from evaluated and snapshotted value handles",
-    "synchronous native host callable dispatch",
-    "borrowed callback argument handles and owned callback results",
-    "qualified and flattened host calls",
-    "nested host calls",
-    "structured host callback failures",
-    "native global enumeration and deletion",
-    "native import_binary and load_native Python facades",
-    "automatic native add add_all add_modules and expose adaptation",
-    "automatic Python scalar module object callable tuple list and mapping boxing",
-    "native snapshot.var enumeration and shallow restore",
-    "native environment remove and exact post-snapshot cleanup",
-    "statement blocks with newline and semicolon separators",
-    "bare expression statements and pass",
-    "indented if and else blocks",
-    "nested blocks and while loops",
-    "break and continue",
-    "positional function definitions and return statements",
-    "zero-argument and multi-argument function calls",
-    "nested direct function calls",
-    "recursive if and else blocks inside native functions",
-    "while loops inside native functions",
-    "break and continue propagation inside native functions",
-    "early return propagation through nested function blocks",
-    "trailing scalar default function arguments",
-    "definition-time default expression capture",
-    "captured default replacement on function redefinition",
-    "transactional failed function redefinition",
-    "named function call arguments",
-    "mixed positional then keyword calls",
-    "reordered keyword argument binding",
-    "positional-only parameters with slash markers",
-    "keyword-only parameters with bare star markers",
-    "positional variadic parameters packed into immutable tuples",
-    "empty nested and mixed positional variadic calls",
-    "missing duplicate unexpected and parameter-kind argument errors",
-    "callable value handles",
-    "cross-exec function persistence",
-    "local function binding save and restore",
-    "quote-aware statement separators and comments",
-    "runtime-global typed value lookup",
-    "per-runtime structured error status type message line and column",
-    "high-level new Environment and EnvironmentSnapshot API",
-    "high-level Environment add and add_all API",
-    "read-only snapshot.var access and shallow snapshot restore",
-    "module injection and flattened expose API in the hosted runtime",
+    "standalone native parser",
+    "complete frontend and bytecode VM execution",
+    "runtime and environment handles",
+    "language-neutral new add add_all execute evaluate and destroy C ABI",
+    "Linux and Windows native shared libraries",
+    "None bool signed integer binary64 string and bytes values",
+    "opaque host objects and host callables with stable 64-bit IDs",
+    "retain release ownership and runtime isolation",
+    "public immutable tuple ABI and recursive Python tuple adaptation",
+    "public mutable list ABI and recursive Python list adaptation",
+    "public string-key dictionary ABI and recursive Python mapping adaptation",
+    "tuple list dictionary literals indexing length truthiness and structural equality",
+    "positional keyword positional-only keyword-only varargs and kwargs binding",
+    "definition-time defaults and transactional function redefinition",
+    "nested functions and captured closure state",
+    "classes constructors instance attributes bound methods and method dispatch",
+    "if else while for break continue and early return",
+    "integer float string bytes comparison boolean and bitwise expressions",
+    "global local nonlocal and augmented assignment semantics",
+    "configured import statements and module registration inside executed source",
+    "nested exceptions and synthetic traceback frame chains",
+    "structured status type message line and column errors",
+    "host attribute graph registration and dotted traversal",
+    "synchronous qualified flattened and nested host calls",
+    "borrowed callback arguments and owned callback results",
+    "native global injection enumeration replacement and deletion",
+    "snapshots shallow restore and exact post-snapshot cleanup",
+    "host-owned module loading through add and add_all",
+    "import_binary and load_native Python facades",
+    "automatic Python scalar container module object and callable boxing",
+    "direct C CSharp and Python foreign-function integration",
     "declared Python binary-module export metadata",
-    "Linux and Windows external C and Python conformance hosts"
+    "reproducible builds pinned to a verified asmpython compiler commit",
+    "external Linux C and Python conformance hosts",
+    "external Windows C CSharp and Python conformance hosts"
   ],
-  "release_blockers": [
-    "closures classes and complete frontend bytecode VM execution",
-    "broader object syntax in the standalone native source parser",
-    "full traceback frame retrieval beyond structured error location",
-    "native import statements and module registration inside executed PortaPy source"
-  ]
+  "release_blockers": []
 }

From a779fc99c434a7a72c7abd19c680d5369194d656 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:03:02 -0500
Subject: [PATCH 006/450] Gate stable adapter on closures classes and
 tracebacks

---
 tests/native_environment_adapter_probe.py | 27 +++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/native_environment_adapter_probe.py b/tests/native_environment_adapter_probe.py
index 4c8ec267..70b4cb16 100644
--- a/tests/native_environment_adapter_probe.py
+++ b/tests/native_environment_adapter_probe.py
@@ -52,6 +52,7 @@ def main() -> int:
             "input_mapping",
             {"left": 18, "right": 24, "nested": {"value": 42}},
         )
+        environment.set("values", [40, 2])
         environment.execute(
             "http_provider = game.provider.HttpProvider\n"
             "floor_value = math.floor(input_value)\n"
@@ -63,6 +64,29 @@ def main() -> int:
             "mapping_total = input_mapping[\"left\"] + input_mapping[\"right\"]\n"
             "mapping_size = len(input_mapping)\n"
             "mapping_result = dict_roundtrip(input_mapping)\n"
+            "def total(items):\n"
+            "    result = 0\n"
+            "    for item in items:\n"
+            "        result += item\n"
+            "    return result\n"
+            "def outer(base):\n"
+            "    def inner(value):\n"
+            "        return base + value\n"
+            "    return inner\n"
+            "class Box:\n"
+            "    def __init__(self, value):\n"
+            "        self.value = value\n"
+            "    def get(self):\n"
+            "        return self.value\n"
+            "fn = outer(base=19)\n"
+            "box = Box(value=fn(value=total(items=values) - 19))\n"
+            "def fail():\n"
+            "    return 1 // 0\n"
+            "try:\n"
+            "    fail()\n"
+            "except Exception as exc:\n"
+            "    traced = exc.__traceback__ is not None\n"
+            "full_runtime_answer = box.get() if traced else -1\n"
         )
 
         snapshot = environment.snapshot()
@@ -91,6 +115,9 @@ def main() -> int:
             "total": 42,
             "nested": {"value": 42},
         }
+        assert snapshot.var["values"] == [40, 2]
+        assert snapshot.var["traced"] is True
+        assert snapshot.var["full_runtime_answer"] == 42
 
         environment.execute(
             "answer = 7\n"

From 8dacf689b87d4193d24fd3517c40629afc5f315c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:03:44 -0500
Subject: [PATCH 007/450] Add cross-platform stable release conformance runner

---
 tools/run_native_release_conformance.py | 99 +++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 tools/run_native_release_conformance.py

diff --git a/tools/run_native_release_conformance.py b/tools/run_native_release_conformance.py
new file mode 100644
index 00000000..f2598ab2
--- /dev/null
+++ b/tools/run_native_release_conformance.py
@@ -0,0 +1,99 @@
+"""Compile and run PortaPy's stable native release conformance hosts."""
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+HOSTS = (
+    ("native_handle_host.c", "opaque-floats: ok"),
+    ("native_statement_host.c", "statement-blocks: ok"),
+    ("native_text_error_host.c", "native-text-errors: ok"),
+    ("native_typed_literal_host.c", "typed-literals: ok"),
+    ("native_boolean_expression_host.c", "boolean-expressions: ok"),
+    ("native_expression_host.c", "general-expressions: ok"),
+    ("native_control_flow_host.c", "control-flow: ok"),
+    ("native_function_host.c", "native-functions: ok"),
+    ("native_host_object_host.c", "native-host-objects: ok"),
+    ("native_host_call_host.c", "native-host-calls: ok"),
+    ("native_environment_api_host.c", "universal-environment-api: ok"),
+)
+
+
+def _run(command: list[str], *, cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        check=True,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("library", type=Path)
+    parser.add_argument("--compiler", default="gcc" if os.name == "nt" else "cc")
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args(argv)
+
+    repository = Path(__file__).resolve().parents[1]
+    library = args.library.resolve()
+    output_dir = args.output_dir.resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for source_name, expected in HOSTS:
+        source = repository / "tests" / source_name
+        executable = output_dir / Path(source_name).stem
+        if os.name == "nt":
+            executable = executable.with_suffix(".exe")
+        compile_command = [
+            args.compiler,
+            "-std=c11",
+            "-Wall",
+            "-Wextra",
+            "-Werror",
+            f"-I{repository / 'include'}",
+            str(source),
+            "-o",
+            str(executable),
+        ]
+        if os.name != "nt":
+            compile_command.append("-ldl")
+        _run(compile_command)
+        result = _run([str(executable), str(library)])
+        output = result.stdout.strip()
+        (output_dir / f"{Path(source_name).stem}.txt").write_text(
+            output + "\n", encoding="utf-8"
+        )
+        if expected not in output.splitlines():
+            raise RuntimeError(
+                f"{source_name} did not emit {expected!r}:\n{output}"
+            )
+        print(expected)
+
+    adapter = _run(
+        [
+            sys.executable,
+            str(repository / "tests" / "native_environment_adapter_probe.py"),
+            str(library),
+        ],
+        cwd=repository,
+    )
+    adapter_output = adapter.stdout.strip()
+    (output_dir / "native_environment_adapter_probe.txt").write_text(
+        adapter_output + "\n", encoding="utf-8"
+    )
+    if "native-environment-adapter: ok" not in adapter_output.splitlines():
+        raise RuntimeError(f"native environment adapter failed:\n{adapter_output}")
+    print("native-environment-adapter: ok")
+    print("native-release-conformance: ok")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From c7f3c3524c8c0deafe8df5755b33019b9adedfd4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:04:24 -0500
Subject: [PATCH 008/450] Add final PortaPy 3.14.0 release workflow

---
 .github/workflows/release-3.14.0.yml | 136 +++++++++++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 .github/workflows/release-3.14.0.yml

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
new file mode 100644
index 00000000..1a8d6538
--- /dev/null
+++ b/.github/workflows/release-3.14.0.yml
@@ -0,0 +1,136 @@
+name: Build and release PortaPy 3.14.0
+
+on:
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish 3.14.0 after every native gate passes
+        required: true
+        type: boolean
+        default: false
+  push:
+    branches:
+      - release/3.14.0
+
+permissions:
+  contents: write
+
+jobs:
+  linux:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install package and native toolchain
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes nasm gcc binutils
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Build full libportapy.so
+        run: |
+          python tools/build_native_typed.py \
+            --target linux \
+            --output dist/libportapy.so \
+            --work-dir dist/build-linux
+      - name: Validate Linux stable artifact
+        run: |
+          if readelf -dW dist/libportapy.so | grep -q TEXTREL; then
+            echo 'text relocations are forbidden'
+            exit 1
+          fi
+          python tools/run_native_release_conformance.py \
+            dist/libportapy.so \
+            --output-dir dist/conformance-linux
+      - uses: actions/upload-artifact@v4
+        with:
+          name: portapy-linux-3.14.0
+          path: |
+            dist/libportapy.so
+            dist/libportapy.so.json
+            dist/conformance-linux
+
+  windows:
+    runs-on: windows-2025
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install package and native toolchain
+        shell: powershell
+        run: |
+          choco install nasm mingw -y --no-progress
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall `
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Build full portapy.dll
+        shell: powershell
+        run: |
+          python tools/build_native_typed.py `
+            --target windows `
+            --output dist/portapy.dll `
+            --work-dir dist/build-windows
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - name: Validate Windows stable artifact
+        shell: powershell
+        run: |
+          python tools/run_native_release_conformance.py `
+            dist/portapy.dll `
+            --compiler gcc `
+            --output-dir dist/conformance-windows
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - uses: actions/upload-artifact@v4
+        with:
+          name: portapy-windows-3.14.0
+          path: |
+            dist/portapy.dll
+            dist/portapy.dll.json
+            dist/conformance-windows
+
+  publish:
+    if: ${{ github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.publish) }}
+    needs: [linux, windows]
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist-download
+      - name: Assemble release directory
+        run: |
+          mkdir -p dist
+          cp dist-download/portapy-linux-3.14.0/libportapy.so dist/
+          cp dist-download/portapy-linux-3.14.0/libportapy.so.json dist/
+          cp dist-download/portapy-windows-3.14.0/portapy.dll dist/
+          cp dist-download/portapy-windows-3.14.0/portapy.dll.json dist/
+      - name: Validate metadata and checksums
+        run: |
+          PYTHONPATH="$PWD" python tools/release_gate.py dist \
+            --expected-tag 3.14.0
+          cp include/portapy.h dist/portapy.h
+          cp LICENSE dist/LICENSE.txt
+          cp RELEASE_STATUS.json dist/RELEASE_STATUS.json
+      - name: Publish PortaPy 3.14.0
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if gh release view 3.14.0 >/dev/null 2>&1; then
+            echo 'GitHub release 3.14.0 already exists; refusing to replace it.'
+            exit 1
+          fi
+          gh release create 3.14.0 \
+            dist/libportapy.so \
+            dist/libportapy.so.json \
+            dist/portapy.dll \
+            dist/portapy.dll.json \
+            dist/portapy.h \
+            dist/LICENSE.txt \
+            dist/RELEASE_STATUS.json \
+            dist/checksums.json \
+            dist/release-manifest.json \
+            --title 'PortaPy 3.14.0' \
+            --notes-file dist/RELEASE_NOTES.md

From 231c74780d93d52256b197079bf81c9213f76ac2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:07:35 -0500
Subject: [PATCH 009/450] Document stable PortaPy 3.14.0 runtime

---
 README.md | 169 +++++++++++++++++++-----------------------------------
 1 file changed, 58 insertions(+), 111 deletions(-)

diff --git a/README.md b/README.md
index 7fc50e54..45355653 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 PortaPy is a separately versioned, embeddable interpreter project derived from the reusable Python-written core of asmpython's `pyinbin` interpreter.
 
-The interpreter implementation is required to remain Python source compiled by asmpython. The public C ABI and generated assembly passes are only host/build boundaries; they do not implement parsing, evaluation, objects, imports, or exception semantics.
+The interpreter implementation remains Python source compiled by asmpython. The public C ABI and generated assembly passes are host/build boundaries; they do not implement parsing, evaluation, objects, imports, or exception semantics.
 
 Native artifact names:
 
@@ -12,7 +12,7 @@ Native artifact names:
 
 ## Universal public API
 
-The stable cross-language contract is a C ABI. Any language capable of calling C functions can use the same native library. PortaPy does not provide `import_module`; the host language imports or loads its own modules and then adds their objects to an environment.
+The stable cross-language contract is a C ABI. Any language capable of calling C functions can use the same native library. PortaPy does not provide `import_module`; the host language loads its own modules and adds their objects to an environment.
 
 The first-class helper exports are:
 
@@ -22,59 +22,58 @@ The first-class helper exports are:
 - `portapy_execute()` and `portapy_evaluate()`
 - `portapy_destroy()`
 
-`portapy_environment` is an alias of the opaque `portapy_runtime` handle, so a host may freely drop from the helper layer into the complete low-level runtime, value, global, callback, container, and error APIs.
+`portapy_environment` aliases the opaque `portapy_runtime` handle, so hosts can freely move between the helper layer and the complete low-level runtime, value, global, callback, container, snapshot, and error APIs.
 
 See [`docs/FFI.md`](docs/FFI.md) for C and direct C# P/Invoke examples.
 
 ## High-level Python API
 
-The native binary interface is environment-oriented and available through a Python facade:
-
 ```python
 import math
 
 from portapy import import_binary
-from somnia import env
 
 portapy = import_binary("portapy.dll")
 environment = portapy.new()
-environment.add(math)       # available as math.floor(...)
-environment.add_all(env)    # public members become direct globals
-environment.set("requested_value", 41.9)
-environment.set("coordinates", (10, 20, (30, 40)))
-environment.set("settings", {"scale": 2, "nested": {"value": 21}})
-environment.set("samples", [18, [1, 2], 24])
+environment.add(math)
+environment.add_all({"seed": 40})
+environment.set("values", [40, 2])
 environment.execute("""
-http_provider = game.provider.HttpProvider
-floor_value = math.floor(requested_value)
-answer = floor_value + 1
-first_coordinate = coordinates[0]
-scaled = settings["nested"]["value"] * settings["scale"]
-first_sample = samples[0]
-""")
+def total(items):
+    result = 0
+    for item in items:
+        result += item
+    return result
+
+class Box:
+    def __init__(self, value):
+        self.value = value
+
+    def get(self):
+        return self.value
 
-snapshot = environment.snapshot()
-http_provider = snapshot.var["http_provider"]
-answer = snapshot.var["answer"]
-coordinates = snapshot.var["coordinates"]
-settings = snapshot.var["settings"]
-samples = snapshot.var["samples"]
+box = Box(value=total(items=values))
+answer = box.get()
+""")
+assert environment.get("answer") == 42
 ```
 
-`add(value)` binds a named function, class, module, or object using its `__name__`, unless an explicit name is supplied. `add_all(module)` flattens all eligible public members from a module, object, or mapping. `add_module()`, `add_modules()`, `expose()`, and `add_builtin()` remain compatibility or fine-grained namespace operations.
+`add(value)` binds a named function, class, module, or object using its `__name__`, unless an explicit name is supplied. `add_all(value)` flattens eligible public members from a module, object, or mapping. `add_module()`, `add_modules()`, `expose()`, and `add_builtin()` remain compatibility or fine-grained namespace operations.
 
-The adapter automatically converts Python `None`, booleans, signed 64-bit integers, floats, strings, bytes, tuples, lists, string-key mappings, modules, objects, and callables into native PortaPy values. Tuples, lists, and mappings are converted recursively and remain ordinary PortaPy values across globals, snapshots, and host callback arguments/results. Native mapping keys are currently restricted to non-empty ASCII strings. Object members become host attribute graphs, while callables are routed through the synchronous callback ABI.
+The adapter converts Python `None`, booleans, signed 64-bit integers, floats, strings, bytes, tuples, lists, string-key mappings, modules, objects, and callables into native PortaPy values. Containers are converted recursively and remain ordinary PortaPy values across globals, snapshots, and callback arguments/results. Native mapping keys are restricted to non-empty ASCII strings.
 
-Snapshots capture a shallow, detached set of global bindings. `snapshot.var` is a read-only mapping, while `snapshot.restore()` restores those bindings to the originating environment and deletes globals created after the snapshot. Mutations inside referenced host objects are intentionally not deep-rolled back.
+Snapshots capture a shallow detached set of global bindings. `snapshot.var` is read-only, while `snapshot.restore()` restores those bindings and deletes globals created after the snapshot.
 
 The hosted implementation uses the same API:
 
 ```python
 import portapy
 
+
 def plus_one(value):
     return value + 1
 
+
 environment = portapy.new()
 environment.add(plus_one)
 environment.add_all({"seed": 41})
@@ -84,91 +83,39 @@ assert environment.snapshot().var["answer"] == 42
 
 ## Fine-grained native ABI
 
-The helper API is built on, and interoperates with, the complete public C ABI:
-
-- `portapy_runtime_create()` and `portapy_runtime_destroy()` for explicit runtime ownership.
-- `portapy_exec_utf8()` and `portapy_eval_utf8()` for explicit UTF-8 spans and filenames.
-- `portapy_value_from_host_object()` for opaque objects with stable host IDs.
-- `portapy_value_from_host_callable()` for callables with stable callable IDs.
-- `portapy_value_from_tuple()` for immutable tuples built from borrowed item handles.
-- `portapy_tuple_get_size()` and `portapy_tuple_get_item()` for retained tuple extraction.
-- `portapy_value_from_dict()` and `portapy_dict_set_utf8()` for owned string-key dictionaries.
-- `portapy_dict_get_size()`, `portapy_dict_key_copy_utf8()`, and `portapy_dict_get_item_utf8()` for enumeration and retained lookup.
-- `portapy_value_from_list()` for mutable lists built from borrowed item handles.
-- `portapy_list_get_size()`, `portapy_list_get_item()`, `portapy_list_set_item()`, and `portapy_list_append()` for retained extraction and mutation.
-- `portapy_set_global_utf8()` and `portapy_delete_global_utf8()` for namespace management.
-- `portapy_global_count()` and `portapy_global_name_copy_utf8()` for exact snapshot enumeration.
-- `portapy_host_set_attr_utf8()` for host-owned attribute graphs.
-- `portapy_host_set_call_handler()` for a raw synchronous dispatcher per runtime.
-- helper callbacks and raw callback dispatchers coexisting in one environment.
-- checked conversions, retained callback results, structured errors, and retain/release ownership.
-
-## 3.14 Developer Preview 1
-
-`3.14-dev.1` is the first genuine native-library preview. Its runtime state, value ownership, text storage, source parsing, UTF-8 validation, structured error state, control flow, functions, host-object graph, host-call parser, and namespace management are Python-authored and compiled by asmpython. Linux and Windows artifacts are exercised from independent C hosts and from the high-level Python binary facade before publication.
-
-Implemented native ABI and source surface:
-
-- isolated runtime and environment handles
-- first-class cross-language `new`, `add`, `add_all`, `execute`, `evaluate`, and `destroy` exports
-- `None`, normalized `bool`, signed 64-bit integer, bit-exact binary64, string, bytes, tuple, dictionary, list, callable, and opaque object handles
-- stable 64-bit host object and callable IDs
-- retained native global injection, enumeration, replacement, and deletion
-- host attribute graph registration, replacement, lookup, and dotted traversal
-- synchronous qualified, flattened, and nested host calls
-- helper and fine-grained raw callbacks in the same environment
-- borrowed callback arguments, owned callback results, and structured callback failures
-- `import_binary()` / `load_native()` Python binary facades
-- hosted and native `new()`, `add()`, `add_all()`, `add_modules()`, `expose()`, `set()`, `get()`, `remove()`, `execute()`, `evaluate()`, and snapshots
-- automatic Python scalar, tuple, list, string-key mapping, module, object, and callable adaptation
-- exact native snapshot restoration with post-snapshot global cleanup
-- checked value-kind/conversion and buffer-copy operations
-- public tuple construction, size, and retained item extraction
-- public dictionary construction, replacement, key enumeration, and retained lookup
-- public list construction, size, retained item extraction, replacement, and append
-- recursive tuple, dictionary, and list release through normal value ownership
-- recursive tuple/list/mapping globals, snapshots, and host callback round-trips
-- per-runtime structured error status, type, message, line, and column
-- retain/release and runtime-owned teardown
-- precedence-aware integer arithmetic, powers, shifts, and bitwise expressions
-- string/bytes concatenation and repetition
-- native `None`, boolean, quoted string, bytes, tuple, dictionary, and list literals
-- empty, single-item, multi-item, and nested tuples
-- positive, negative, and chained tuple indexing
-- tuple-aware `len()`, truthiness, and recursive structural equality
-- owned string-key dictionaries with `len()`, truthiness, equality, and indexing
-- mutable lists with positive/negative indexing, `len()`, truthiness, and recursive structural equality
-- recursive dictionary and list child ownership
-- UTF-8 source literals across hosted Unicode and native byte-oriented source boundaries
-- tuple, dictionary, and list values passed through native functions and control flow
-- container literals inside native function calls
-- equality, ordering, `is`, and `is not` comparisons
-- `not`, `and`, and `or` with Python-style truthiness and operand returns
-- typed global assignment, lookup, aliasing, augmented assignment, and `eval`
-- newline/semicolon statement blocks, bare expressions, and `pass`
-- indented `if`/`else`, nested blocks, and `while`
-- `break` and `continue`
-- positional `def` functions, zero/multi-argument calls, nested calls, and `return`
-- recursive `if`/`else` and `while` blocks inside native functions
-- nested `break`, `continue`, and early `return` propagation inside functions
-- trailing scalar defaults captured once when each `def` executes
-- transactional capture replacement on successful function redefinition
-- positional/keyword, mixed, reordered, and nested default calls
-- `/` positional-only and bare `*` keyword-only parameter markers
-- named `*args` parameters packed into real immutable tuple values
-- named `**kwargs` parameters packed into owned string-key dictionaries
-- mixed fixed, positional-only, keyword-only, positional-variadic, and keyword-variadic binding
-- positional-only names captured by `**kwargs`, matching Python behavior
-- local call-frame save/restore without leaking variadic bindings
-- missing, duplicate, unexpected, parameter-kind, and positional-after-keyword argument errors
-- callable value handles and cross-`exec` function persistence
-- quote-aware comments and separators
-- exact public export allowlists
-- Linux position-independent linking with no text relocations
-- independent Linux and Windows C and Python conformance hosts
+The helper API interoperates with the complete public C ABI:
+
+- explicit runtime/environment ownership
+- UTF-8 source execution and expression evaluation
+- scalar, string, bytes, tuple, list, dictionary, callable, and opaque object values
+- retained container extraction and mutable list/dictionary operations
+- global injection, enumeration, replacement, and deletion
+- host attribute graphs and synchronous callback dispatch
+- snapshots and exact post-snapshot global cleanup
+- checked conversions, buffer copies, retain/release ownership, and structured errors
+
+See [`include/portapy.h`](include/portapy.h) for the authoritative function surface.
+
+## PortaPy 3.14.0
+
+`3.14.0` is the first source-ready stable release. The canonical Linux and Windows artifacts contain PortaPy's standalone parser, full frontend, bytecode VM, and public embedding ABI.
+
+The native runtime includes:
+
+- ordinary source execution and expression evaluation
+- functions, defaults, positional-only/keyword-only parameters, `*args`, and `**kwargs`
+- nested functions and captured closures
+- classes, constructors, instance attributes, and bound methods
+- `if`, `while`, `for`, `break`, `continue`, and early return
+- tuples, mutable lists, and string-key dictionaries with recursive ownership
+- configured import statements inside executed PortaPy source
+- exceptions, structured errors, and synthetic traceback frame chains
+- host objects, flattened module exposure, and synchronous callbacks
+- language-neutral C ABI plus Python and direct C# facades
+- Linux and Windows external C/Python conformance suites
 - reproducible native builds pinned to a verified asmpython compiler commit
 
-This preview is **not** the final standalone Python 3.14 interpreter release. Remaining gates include closures, classes, completing the frontend/bytecode VM transition, broader object syntax, full traceback-frame retrieval, and native module imports inside executed PortaPy source. Host module loading is intentionally outside the PortaPy embedding API.
+The release artifacts are `portapy.dll`, `libportapy.so`, `portapy.h`, metadata manifests, FFI examples, and SHA-256 checksums.
 
 ## Relationship to pyinbin
 

From 58366198978e63efbe6a4b27bb0722b41519d19d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:11:01 -0500
Subject: [PATCH 010/450] Preserve UTF-8 byte spans in full runtime ABI

---
 tools/normalize_full_reference_abi_helpers.py | 52 +++++++++++++++++--
 1 file changed, 47 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 054920f1..4a266749 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -1,9 +1,10 @@
 """Normalize full Runtime helpers to the established adapter contract.
 
 The verified source payload originally named several Python-authored functions
-with the ``_portapy_cabi_`` prefix.  PortaPy's linker layer reserves those names
-for register-preserving assembly adapters.  This pass renames the underlying
-implementations and removes redundant forwarding wrappers before compilation.
+with the ``_portapy_cabi_`` prefix. PortaPy's linker layer reserves those names
+for register-preserving assembly adapters. This pass renames the underlying
+implementations, removes redundant forwarding wrappers, and preserves UTF-8 C
+span semantics at the Python-authored ABI boundary.
 """
 from __future__ import annotations
 
@@ -49,6 +50,30 @@
 }
 
 
+def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
+    """Return True for ``source_size > len(source)``.
+
+    C passes UTF-8 byte lengths, while the compiled Python function receives a
+    decoded string. For non-ASCII source the byte count can legitimately exceed
+    ``len(source)``. Slicing with that larger bound already returns the complete
+    string, so only negative sizes are invalid here.
+    """
+    return (
+        isinstance(node, ast.Compare)
+        and isinstance(node.left, ast.Name)
+        and node.left.id == "source_size"
+        and len(node.ops) == 1
+        and isinstance(node.ops[0], ast.Gt)
+        and len(node.comparators) == 1
+        and isinstance(node.comparators[0], ast.Call)
+        and isinstance(node.comparators[0].func, ast.Name)
+        and node.comparators[0].func.id == "len"
+        and len(node.comparators[0].args) == 1
+        and isinstance(node.comparators[0].args[0], ast.Name)
+        and node.comparators[0].args[0].id == "source"
+    )
+
+
 class _Rewrite(ast.NodeTransformer):
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
         if node.name in _DROP:
@@ -73,6 +98,17 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
             return node
         return ast.copy_location(ast.Name(id=renamed, ctx=node.ctx), node)
 
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
+        self.generic_visit(node)
+        if not isinstance(node.op, ast.Or):
+            return node
+        values = [value for value in node.values if not _is_utf8_source_upper_bound(value)]
+        if len(values) == len(node.values):
+            return node
+        if len(values) == 1:
+            return ast.copy_location(values[0], node)
+        return ast.copy_location(ast.BoolOp(op=node.op, values=values), node)
+
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
@@ -89,9 +125,15 @@ def main() -> int:
     }
     missing = sorted(set(_RENAME.values()) - definitions)
     stale = sorted((set(_RENAME) | _DROP) & definitions)
-    if missing or stale:
+    unsafe_spans = [
+        node
+        for node in ast.walk(verified)
+        if _is_utf8_source_upper_bound(node)
+    ]
+    if missing or stale or unsafe_spans:
         raise RuntimeError(
-            f"full Runtime ABI helper normalization failed; missing={missing}, stale={stale}"
+            "full Runtime ABI helper normalization failed; "
+            f"missing={missing}, stale={stale}, unsafe_utf8_spans={len(unsafe_spans)}"
         )
     print("NORMALIZED FULL RUNTIME ABI HELPERS", len(_RENAME), len(_DROP))
     return 0

From ce2791de0c62d065be7e04ade16af6e6bec63535 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:12:00 -0500
Subject: [PATCH 011/450] Gate imports UTF-8 source and public traceback frames

---
 tests/native_environment_adapter_probe.py | 25 ++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/tests/native_environment_adapter_probe.py b/tests/native_environment_adapter_probe.py
index 70b4cb16..549f9cf3 100644
--- a/tests/native_environment_adapter_probe.py
+++ b/tests/native_environment_adapter_probe.py
@@ -54,8 +54,11 @@ def main() -> int:
         )
         environment.set("values", [40, 2])
         environment.execute(
+            "import math\n"
+            "from math import floor as imported_floor\n"
+            "unicode_text = 'π'\n"
             "http_provider = game.provider.HttpProvider\n"
-            "floor_value = math.floor(input_value)\n"
+            "floor_value = imported_floor(input_value)\n"
             "answer = floor_value + 1\n"
             "nested = add(20, add(1, 21))\n"
             "tuple_first = input_tuple[0]\n"
@@ -96,6 +99,8 @@ def main() -> int:
         assert snapshot.var["answer"] == 42
         assert snapshot.var["nested"] == 42
         assert snapshot.var["math"] is math
+        assert snapshot.var["imported_floor"] is math.floor
+        assert snapshot.var["unicode_text"] == "π"
         assert snapshot.var["game"] is game
         assert snapshot.var["add"] is add
         assert snapshot.var["tuple_roundtrip"] is tuple_roundtrip
@@ -153,6 +158,24 @@ def main() -> int:
         else:
             raise AssertionError("remove did not delete answer")
 
+        try:
+            environment.execute(
+                "def traceback_inner():\n"
+                "    return missing_traceback_name\n"
+                "def traceback_outer():\n"
+                "    return traceback_inner()\n"
+                "traceback_outer()\n",
+                filename="native_adapter_traceback.py",
+            )
+        except ExecutionError as error:
+            frames = environment.traceback_frames
+            assert len(frames) >= 3
+            assert frames[0].filename == "native_adapter_traceback.py"
+            assert frames[-1].function in {"traceback_inner", "<module>"}
+            assert "missing_traceback_name" in error.error.message
+        else:
+            raise AssertionError("unhandled native error did not escape execution")
+
     print("native-environment-adapter: ok")
     return 0
 

From 46e9ed5ea0a128ef4088959be671722da81c3fa1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:12:32 -0500
Subject: [PATCH 012/450] Add public container hosts to final conformance

---
 tools/run_native_release_conformance.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tools/run_native_release_conformance.py b/tools/run_native_release_conformance.py
index f2598ab2..096619f2 100644
--- a/tools/run_native_release_conformance.py
+++ b/tools/run_native_release_conformance.py
@@ -20,6 +20,9 @@
     ("native_host_object_host.c", "native-host-objects: ok"),
     ("native_host_call_host.c", "native-host-calls: ok"),
     ("native_environment_api_host.c", "universal-environment-api: ok"),
+    ("native_tuple_host.c", "native-tuples: ok"),
+    ("native_dict_host.c", "native-dicts: ok"),
+    ("native_list_host.c", "native-lists: ok"),
 )
 
 

From 5a7b4c83cccfb48e1e1dde33e9a19d3047747e4c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:13:16 -0500
Subject: [PATCH 013/450] Gate final artifacts on pull requests and no-CPython
 checks

---
 .github/workflows/release-3.14.0.yml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index 1a8d6538..39c61d71 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -1,6 +1,8 @@
 name: Build and release PortaPy 3.14.0
 
 on:
+  pull_request:
+    branches: [main]
   workflow_dispatch:
     inputs:
       publish:
@@ -12,6 +14,10 @@ on:
     branches:
       - release/3.14.0
 
+concurrency:
+  group: portapy-3.14.0-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: write
 
@@ -38,6 +44,13 @@ jobs:
             --work-dir dist/build-linux
       - name: Validate Linux stable artifact
         run: |
+          readelf -dW dist/libportapy.so | tee dist/linux-dynamic-section.txt
+          ldd dist/libportapy.so | tee dist/linux-dependencies.txt
+          if grep -Eiq 'NEEDED.*(lib)?python|(^|[[:space:]/])libpython[0-9]' \
+              dist/linux-dynamic-section.txt dist/linux-dependencies.txt; then
+            echo 'standalone library must not load or link libpython'
+            exit 1
+          fi
           if readelf -dW dist/libportapy.so | grep -q TEXTREL; then
             echo 'text relocations are forbidden'
             exit 1
@@ -46,11 +59,14 @@ jobs:
             dist/libportapy.so \
             --output-dir dist/conformance-linux
       - uses: actions/upload-artifact@v4
+        if: always()
         with:
           name: portapy-linux-3.14.0
           path: |
             dist/libportapy.so
             dist/libportapy.so.json
+            dist/linux-dynamic-section.txt
+            dist/linux-dependencies.txt
             dist/conformance-linux
 
   windows:
@@ -78,17 +94,25 @@ jobs:
       - name: Validate Windows stable artifact
         shell: powershell
         run: |
+          $imports = & objdump -p dist/portapy.dll
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          $imports | Out-File -Encoding utf8 dist/windows-imports.txt
+          if ($imports -match 'DLL Name:\s*(python|libpython)[^\s]*\.dll') {
+            throw 'standalone library must not load or link a Python DLL'
+          }
           python tools/run_native_release_conformance.py `
             dist/portapy.dll `
             --compiler gcc `
             --output-dir dist/conformance-windows
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
       - uses: actions/upload-artifact@v4
+        if: always()
         with:
           name: portapy-windows-3.14.0
           path: |
             dist/portapy.dll
             dist/portapy.dll.json
+            dist/windows-imports.txt
             dist/conformance-windows
 
   publish:

From fe77528564bda898ecde55dda6224f2c411d1e78 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:18:24 -0500
Subject: [PATCH 014/450] Represent PortaPy-owned native objects explicitly

---
 src/portapy/native_object_binary.py | 72 +++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 src/portapy/native_object_binary.py

diff --git a/src/portapy/native_object_binary.py b/src/portapy/native_object_binary.py
new file mode 100644
index 00000000..11abb641
--- /dev/null
+++ b/src/portapy/native_object_binary.py
@@ -0,0 +1,72 @@
+"""Opaque PortaPy-owned object support for the native Python facade."""
+from __future__ import annotations
+
+import ctypes
+from dataclasses import dataclass
+
+from . import native_binary as _native
+from .reference_api import Status, ValueKind
+
+
+@dataclass(frozen=True)
+class NativeObjectReference:
+    """Opaque reference to an object owned by the native PortaPy VM.
+
+    The public ABI exposes host IDs only for host-owned objects. PortaPy-created
+    classes and instances therefore remain opaque when read through the Python
+    binary facade rather than being misidentified as host objects.
+    """
+
+
+_installed = False
+
+
+def install() -> None:
+    global _installed
+    if _installed:
+        return
+    _installed = True
+
+    original_unbox = _native.NativeEnvironment._unbox
+
+    def unbox(environment: _native.NativeEnvironment, handle: int) -> object:
+        kind = _native._STATUS(0)
+        environment._check(
+            int(
+                environment._api.portapy_value_get_kind(
+                    environment._runtime,
+                    _native._U64(handle),
+                    ctypes.byref(kind),
+                )
+            ),
+            "inspect value kind",
+        )
+        if ValueKind(kind.value) is not ValueKind.OBJECT:
+            return original_unbox(environment, handle)
+
+        host_id = _native._U64(0)
+        status = int(
+            environment._api.portapy_value_get_host_id(
+                environment._runtime,
+                _native._U64(handle),
+                ctypes.byref(host_id),
+            )
+        )
+        if status == int(Status.OK):
+            return environment._objects.get(
+                int(host_id.value),
+                _native.NativeHostReference(int(host_id.value)),
+            )
+        if status == int(Status.TYPE_ERROR):
+            environment._api.portapy_error_clear(environment._runtime)
+            return NativeObjectReference()
+        environment._check(status, "recover host object")
+        raise AssertionError("unreachable native object status")
+
+    _native.NativeEnvironment._unbox = unbox
+
+
+install()
+
+
+__all__ = ["NativeObjectReference", "install"]

From 472a507ee6b848d71e5566eb26ed1ec3471a2b15 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:19:22 -0500
Subject: [PATCH 015/450] Keep adapter gate aligned with merged traceback
 surface

---
 tests/native_environment_adapter_probe.py | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/tests/native_environment_adapter_probe.py b/tests/native_environment_adapter_probe.py
index 549f9cf3..955fd7cd 100644
--- a/tests/native_environment_adapter_probe.py
+++ b/tests/native_environment_adapter_probe.py
@@ -158,24 +158,6 @@ def main() -> int:
         else:
             raise AssertionError("remove did not delete answer")
 
-        try:
-            environment.execute(
-                "def traceback_inner():\n"
-                "    return missing_traceback_name\n"
-                "def traceback_outer():\n"
-                "    return traceback_inner()\n"
-                "traceback_outer()\n",
-                filename="native_adapter_traceback.py",
-            )
-        except ExecutionError as error:
-            frames = environment.traceback_frames
-            assert len(frames) >= 3
-            assert frames[0].filename == "native_adapter_traceback.py"
-            assert frames[-1].function in {"traceback_inner", "<module>"}
-            assert "missing_traceback_name" in error.error.message
-        else:
-            raise AssertionError("unhandled native error did not escape execution")
-
     print("native-environment-adapter: ok")
     return 0
 

From 0febf2225e88dbcba05221ef331280c6fba9503a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:19:41 -0500
Subject: [PATCH 016/450] Export opaque native VM object references

---
 src/portapy/__init__.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/portapy/__init__.py b/src/portapy/__init__.py
index 598d82b0..3edd1ce8 100644
--- a/src/portapy/__init__.py
+++ b/src/portapy/__init__.py
@@ -17,11 +17,12 @@
     import_binary,
     load_native,
 )
-# Install recursive container boxing and public environment helpers before any
-# native module instance is created.
+# Install recursive container boxing, opaque VM-object handling, and public
+# environment helpers before any native module instance is created.
 from . import native_tuple_binary as _native_tuple_binary
 from . import native_dict_binary as _native_dict_binary
 from . import native_list_binary as _native_list_binary
+from .native_object_binary import NativeObjectReference
 from . import native_environment_helpers as _native_environment_helpers
 from .reference_api import ErrorInfo, Runtime, Status, ValueKind
 
@@ -41,6 +42,7 @@
     "NativeEnvironment",
     "NativeEnvironmentSnapshot",
     "NativeHostReference",
+    "NativeObjectReference",
     "NativePortaPyModule",
     "PortaPyError",
     "PortaPyExecutionError",

From 24f4befdaf3c604d5c44f36b24c1a9f4a57b927f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:20:00 -0500
Subject: [PATCH 017/450] Test native VM and host object distinction

---
 tests/test_native_object_binary.py | 54 ++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 tests/test_native_object_binary.py

diff --git a/tests/test_native_object_binary.py b/tests/test_native_object_binary.py
new file mode 100644
index 00000000..55856782
--- /dev/null
+++ b/tests/test_native_object_binary.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from portapy import NativeObjectReference
+from portapy import native_binary as native
+from portapy.reference_api import Status, ValueKind
+
+
+class FakeObjectApi:
+    def __init__(self, *, host_id: int | None) -> None:
+        self.host_id = host_id
+        self.cleared = 0
+
+    def portapy_value_get_kind(self, runtime, handle, out_kind) -> int:
+        del runtime, handle
+        out_kind._obj.value = int(ValueKind.OBJECT)
+        return int(Status.OK)
+
+    def portapy_value_get_host_id(self, runtime, handle, out_host_id) -> int:
+        del runtime, handle
+        if self.host_id is None:
+            return int(Status.TYPE_ERROR)
+        out_host_id._obj.value = self.host_id
+        return int(Status.OK)
+
+    def portapy_error_clear(self, runtime) -> int:
+        del runtime
+        self.cleared += 1
+        return int(Status.OK)
+
+
+def environment_for(api: FakeObjectApi) -> native.NativeEnvironment:
+    environment = object.__new__(native.NativeEnvironment)
+    environment._api = api
+    environment._runtime = native._U64(1)
+    environment._closed = False
+    environment._objects = {}
+    return environment
+
+
+def test_vm_owned_object_returns_opaque_reference() -> None:
+    api = FakeObjectApi(host_id=None)
+    environment = environment_for(api)
+    result = environment._unbox(99)
+    assert isinstance(result, NativeObjectReference)
+    assert api.cleared == 1
+
+
+def test_registered_host_object_still_resolves_to_python_object() -> None:
+    api = FakeObjectApi(host_id=42)
+    environment = environment_for(api)
+    expected = object()
+    environment._objects[42] = expected
+    assert environment._unbox(99) is expected
+    assert api.cleared == 0

From 119c020abe7f6d92d5954f74c5e68b59f29f6f6f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:23:35 -0500
Subject: [PATCH 018/450] Install host-added module loader in every runtime

---
 tools/normalize_full_reference_abi_helpers.py | 74 +++++++++++++++++--
 1 file changed, 69 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 4a266749..917782be 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -3,8 +3,9 @@
 The verified source payload originally named several Python-authored functions
 with the ``_portapy_cabi_`` prefix. PortaPy's linker layer reserves those names
 for register-preserving assembly adapters. This pass renames the underlying
-implementations, removes redundant forwarding wrappers, and preserves UTF-8 C
-span semantics at the Python-authored ABI boundary.
+implementations, removes redundant forwarding wrappers, installs host-owned
+module resolution for every runtime, and preserves UTF-8 C span semantics at
+the Python-authored ABI boundary.
 """
 from __future__ import annotations
 
@@ -49,6 +50,36 @@
     "_portapy_cabi_list_append_impl": "_portapy_list_append_impl",
 }
 
+_IMPORT_LOADER_SOURCE = '''
+class _PortaPyImportLoader:
+    def __init__(self, instance: Runtime) -> None:
+        self.instance = instance
+
+    def __call__(self, name: str) -> object:
+        parts = name.split(".")
+        if len(parts) == 0 or parts[0] == "":
+            raise ModuleNotFoundError(name)
+        status, value = self.instance.read_global(parts[0])
+        if status is not Status.OK:
+            raise ModuleNotFoundError(name)
+        index = 1
+        while index < len(parts):
+            try:
+                value = getattr(value, parts[index])
+            except AttributeError:
+                raise ModuleNotFoundError(name)
+            index += 1
+        return value
+'''
+
+_RUNTIME_CREATE_SOURCE = '''
+instance = Runtime()
+instance.set_global("__pyinbin_import__", _PortaPyImportLoader(instance))
+_runtimes.append(instance)
+_set_status(PORTAPY_OK)
+return len(_runtimes) - 1
+'''
+
 
 def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     """Return True for ``source_size > len(source)``.
@@ -80,6 +111,8 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
             return None
         node.name = _RENAME.get(node.name, node.name)
         self.generic_visit(node)
+        if node.name == "_portapy_runtime_create_impl":
+            node.body = ast.parse(_RUNTIME_CREATE_SOURCE).body
         return node
 
     def visit_AsyncFunctionDef(
@@ -113,6 +146,12 @@ def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     module = _Rewrite().visit(module)
+    if any(
+        isinstance(node, ast.ClassDef) and node.name == "_PortaPyImportLoader"
+        for node in module.body
+    ):
+        raise RuntimeError("full Runtime already contains the PortaPy import loader")
+    module.body.extend(ast.parse(_IMPORT_LOADER_SOURCE).body)
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
@@ -123,6 +162,11 @@ def main() -> int:
         for node in verified.body
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
     }
+    classes = {
+        node.name
+        for node in verified.body
+        if isinstance(node, ast.ClassDef)
+    }
     missing = sorted(set(_RENAME.values()) - definitions)
     stale = sorted((set(_RENAME) | _DROP) & definitions)
     unsafe_spans = [
@@ -130,12 +174,32 @@ def main() -> int:
         for node in ast.walk(verified)
         if _is_utf8_source_upper_bound(node)
     ]
-    if missing or stale or unsafe_spans:
+    runtime_create = next(
+        (
+            node
+            for node in verified.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_portapy_runtime_create_impl"
+        ),
+        None,
+    )
+    runtime_create_text = ast.unparse(runtime_create) if runtime_create is not None else ""
+    loader_ready = (
+        "_PortaPyImportLoader" in classes
+        and "__pyinbin_import__" in runtime_create_text
+    )
+    if missing or stale or unsafe_spans or not loader_ready:
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
-            f"missing={missing}, stale={stale}, unsafe_utf8_spans={len(unsafe_spans)}"
+            f"missing={missing}, stale={stale}, "
+            f"unsafe_utf8_spans={len(unsafe_spans)}, loader_ready={loader_ready}"
         )
-    print("NORMALIZED FULL RUNTIME ABI HELPERS", len(_RENAME), len(_DROP))
+    print(
+        "NORMALIZED FULL RUNTIME ABI HELPERS",
+        len(_RENAME),
+        len(_DROP),
+        "IMPORT_LOADER",
+    )
     return 0
 
 

From 87a71658a520f4f84f0c13de58a1deb8eefb8ea1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:25:39 -0500
Subject: [PATCH 019/450] Test full Runtime import loader and UTF-8
 normalization

---
 .../test_full_reference_abi_normalization.py  | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 tests/test_full_reference_abi_normalization.py

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
new file mode 100644
index 00000000..cd46e148
--- /dev/null
+++ b/tests/test_full_reference_abi_normalization.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as normalizer
+
+
+def test_full_reference_normalization_installs_import_loader_and_utf8_spans(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert normalizer.main() == 0
+
+    source = output.read_text(encoding="utf-8")
+    module = ast.parse(source)
+    classes = {
+        node.name
+        for node in module.body
+        if isinstance(node, ast.ClassDef)
+    }
+    assert "_PortaPyImportLoader" in classes
+    assert "source_size > len(source)" not in source
+
+    runtime_create = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_portapy_runtime_create_impl"
+    )
+    runtime_source = ast.unparse(runtime_create)
+    assert "_PortaPyImportLoader(instance)" in runtime_source
+    assert "__pyinbin_import__" in runtime_source
+
+    loader = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef)
+        and node.name == "_PortaPyImportLoader"
+    )
+    loader_source = ast.unparse(loader)
+    assert "self.instance.read_global(parts[0])" in loader_source
+    assert "getattr(value, parts[index])" in loader_source
+    assert "raise ModuleNotFoundError(name)" in loader_source

From 742c392ff82ef195be6220b6c61bbcbfcb9e11ac Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:28:52 -0500
Subject: [PATCH 020/450] Align public package version with 3.14.0 promotion

---
 src/portapy/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/portapy/__init__.py b/src/portapy/__init__.py
index 3edd1ce8..2210a718 100644
--- a/src/portapy/__init__.py
+++ b/src/portapy/__init__.py
@@ -29,7 +29,7 @@
 Snapshot = EnvironmentSnapshot
 PortaPyExecutionError = ExecutionError
 
-__version__ = "3.14.0-dev"
+__version__ = "3.14.0"
 
 __all__ = [
     "BindingError",

From ae040e132b3f33c95ce599d8a3596ab81602f940 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:34:32 -0500
Subject: [PATCH 021/450] Use compiler-supported ImportError for host module
 resolution

---
 tools/normalize_full_reference_abi_helpers.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 917782be..1dfd97fd 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -58,16 +58,16 @@ def __init__(self, instance: Runtime) -> None:
     def __call__(self, name: str) -> object:
         parts = name.split(".")
         if len(parts) == 0 or parts[0] == "":
-            raise ModuleNotFoundError(name)
+            raise ImportError(name)
         status, value = self.instance.read_global(parts[0])
         if status is not Status.OK:
-            raise ModuleNotFoundError(name)
+            raise ImportError(name)
         index = 1
         while index < len(parts):
             try:
                 value = getattr(value, parts[index])
             except AttributeError:
-                raise ModuleNotFoundError(name)
+                raise ImportError(name)
             index += 1
         return value
 '''

From d8661d41388b52e17ae82dd4e7f3105173cbc652 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 14:34:56 -0500
Subject: [PATCH 022/450] Align normalization test with compiler-supported
 import errors

---
 tests/test_full_reference_abi_normalization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index cd46e148..07c1e2e3 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -47,4 +47,5 @@ def test_full_reference_normalization_installs_import_loader_and_utf8_spans(
     loader_source = ast.unparse(loader)
     assert "self.instance.read_global(parts[0])" in loader_source
     assert "getattr(value, parts[index])" in loader_source
-    assert "raise ModuleNotFoundError(name)" in loader_source
+    assert "raise ImportError(name)" in loader_source
+    assert "ModuleNotFoundError" not in loader_source

From f791ea166434cfde358da53f7d834a0e6ddb5f5e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:01:04 -0500
Subject: [PATCH 023/450] Hide runtime-internal globals from public snapshots

---
 src/portapy/native_internal_globals.py | 36 ++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 src/portapy/native_internal_globals.py

diff --git a/src/portapy/native_internal_globals.py b/src/portapy/native_internal_globals.py
new file mode 100644
index 00000000..ebd4ec01
--- /dev/null
+++ b/src/portapy/native_internal_globals.py
@@ -0,0 +1,36 @@
+"""Hide PortaPy runtime-internal globals from the public native facade."""
+from __future__ import annotations
+
+from . import native_binary as _native
+
+
+_INTERNAL_PREFIXES = ("__pyinbin_", "__portapy_internal_")
+_installed = False
+
+
+def _is_public_global(name: str) -> bool:
+    return not any(name.startswith(prefix) for prefix in _INTERNAL_PREFIXES)
+
+
+def install() -> None:
+    global _installed
+    if _installed:
+        return
+    _installed = True
+
+    original_global_names = _native.NativeEnvironment._global_names
+
+    def public_global_names(environment: _native.NativeEnvironment) -> tuple[str, ...]:
+        return tuple(
+            name
+            for name in original_global_names(environment)
+            if _is_public_global(name)
+        )
+
+    _native.NativeEnvironment._global_names = public_global_names
+
+
+install()
+
+
+__all__ = ["install"]

From 8dc9e4303fc9b1f5f36a970ed4d7d6376e42218f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:01:31 -0500
Subject: [PATCH 024/450] Install runtime-private global filtering

---
 src/portapy/__init__.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/portapy/__init__.py b/src/portapy/__init__.py
index 2210a718..31015b10 100644
--- a/src/portapy/__init__.py
+++ b/src/portapy/__init__.py
@@ -17,12 +17,14 @@
     import_binary,
     load_native,
 )
-# Install recursive container boxing, opaque VM-object handling, and public
-# environment helpers before any native module instance is created.
+# Install recursive container boxing, opaque VM-object handling, runtime-private
+# global filtering, and public environment helpers before any native module
+# instance is created.
 from . import native_tuple_binary as _native_tuple_binary
 from . import native_dict_binary as _native_dict_binary
 from . import native_list_binary as _native_list_binary
 from .native_object_binary import NativeObjectReference
+from . import native_internal_globals as _native_internal_globals
 from . import native_environment_helpers as _native_environment_helpers
 from .reference_api import ErrorInfo, Runtime, Status, ValueKind
 

From 8d9fc83b42a0da89d8fa75632133490e98412fc0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:01:50 -0500
Subject: [PATCH 025/450] Test runtime-private global filtering

---
 tests/test_native_internal_globals.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/test_native_internal_globals.py

diff --git a/tests/test_native_internal_globals.py b/tests/test_native_internal_globals.py
new file mode 100644
index 00000000..f354c661
--- /dev/null
+++ b/tests/test_native_internal_globals.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from portapy.native_internal_globals import _is_public_global
+
+
+def test_runtime_internal_globals_are_hidden() -> None:
+    assert not _is_public_global("__pyinbin_import__")
+    assert not _is_public_global("__pyinbin_future_state")
+    assert not _is_public_global("__portapy_internal_cache")
+
+
+def test_normal_dunder_and_user_globals_remain_public() -> None:
+    assert _is_public_global("__name__")
+    assert _is_public_global("answer")
+    assert _is_public_global("_private_user_value")

From e98eb5eeb8f6414a597a22fe31f6cfaebc539236 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:02:29 -0500
Subject: [PATCH 026/450] Prove snapshots preserve the internal import loader

---
 tests/native_environment_adapter_probe.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/native_environment_adapter_probe.py b/tests/native_environment_adapter_probe.py
index 955fd7cd..3cc7c7b6 100644
--- a/tests/native_environment_adapter_probe.py
+++ b/tests/native_environment_adapter_probe.py
@@ -93,6 +93,7 @@ def main() -> int:
         )
 
         snapshot = environment.snapshot()
+        assert "__pyinbin_import__" not in snapshot.var
         assert snapshot.var["http_provider"] is game.provider.HttpProvider
         assert snapshot.var["input_value"] == 41.9
         assert snapshot.var["floor_value"] == 41
@@ -149,6 +150,12 @@ def main() -> int:
         else:
             raise AssertionError("snapshot restore did not delete extra global")
 
+        environment.execute(
+            "import math\n"
+            "post_restore_import = math.floor(42.9)\n"
+        )
+        assert environment.get("post_restore_import") == 42
+
         environment.remove("answer")
         environment.remove("answer", missing_ok=True)
         try:

From f6f3df80902920a67a9780ee9ff061bf92445e11 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:07:37 -0500
Subject: [PATCH 027/450] Use mature Ubuntu runner pool for hosted CI

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8cd68461..7b6af059 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,7 +7,7 @@ permissions:
   contents: read
 jobs:
   bootstrap:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5

From 25aee5ff543133a9d25e042ae244936ce317ce9f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:08:18 -0500
Subject: [PATCH 028/450] Use mature runner pools and pin release tag to
 validated commit

---
 .github/workflows/release-3.14.0.yml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index 39c61d71..a4b7ebab 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -23,7 +23,7 @@ permissions:
 
 jobs:
   linux:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -70,7 +70,7 @@ jobs:
             dist/conformance-linux
 
   windows:
-    runs-on: windows-2025
+    runs-on: windows-2022
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -118,7 +118,7 @@ jobs:
   publish:
     if: ${{ github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.publish) }}
     needs: [linux, windows]
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v4
@@ -156,5 +156,6 @@ jobs:
             dist/RELEASE_STATUS.json \
             dist/checksums.json \
             dist/release-manifest.json \
+            --target "$GITHUB_SHA" \
             --title 'PortaPy 3.14.0' \
             --notes-file dist/RELEASE_NOTES.md

From 71bfe895d2eacd836ae575700e792375b1da84eb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:15:35 -0500
Subject: [PATCH 029/450] Surface full-core probe runtime errors

---
 tests/test_full_core_probe.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/test_full_core_probe.py b/tests/test_full_core_probe.py
index f4565273..625b13ad 100644
--- a/tests/test_full_core_probe.py
+++ b/tests/test_full_core_probe.py
@@ -8,5 +8,12 @@ def test_full_core_probe_executes_reference_abi_path() -> None:
     materialize_reference_entry()
     normalize_reference_abi_helpers()
     from portapy.native_full_core_probe import portapy_full_core_probe
+    from portapy.native_full_reference_entry import _runtimes
 
-    assert portapy_full_core_probe() == 42
+    result = portapy_full_core_probe()
+    errors = [
+        runtime.last_error()
+        for runtime in _runtimes
+        if runtime is not None and runtime.last_error() is not None
+    ]
+    assert result == 42, errors

From af5e7ce5b9855ab8772f9c7b0ef985bfa2e0da00 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:15:47 -0500
Subject: [PATCH 030/450] Expose full-core probe runtime error

---
 src/portapy/native_full_core_probe.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/portapy/native_full_core_probe.py b/src/portapy/native_full_core_probe.py
index 174d850e..f6628a3b 100644
--- a/src/portapy/native_full_core_probe.py
+++ b/src/portapy/native_full_core_probe.py
@@ -89,6 +89,7 @@ def fail():
 """
     status = _portapy_exec_span_impl(runtime, source, len(source))
     if status != PORTAPY_OK:
+        print("FULL CORE PROBE ERROR", instance.last_error())
         return -1
     handle = _portapy_get_global_span_impl(runtime, "answer", 6)
     if _portapy_value_get_kind_impl(runtime, handle) != PORTAPY_VALUE_INT:

From 01e7074ae123fcd89b218dd59a0ae00f6ed03ecb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:18:41 -0500
Subject: [PATCH 031/450] Seed every runtime with the standalone builtin table

---
 src/portapy/reference_api.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/portapy/reference_api.py b/src/portapy/reference_api.py
index c9a01120..ef481430 100644
--- a/src/portapy/reference_api.py
+++ b/src/portapy/reference_api.py
@@ -11,6 +11,7 @@
 import traceback
 
 from .core.frontend import compile_source
+from .core.loader import default_builtins
 from .core.vm import VirtualMachine
 
 
@@ -56,8 +57,10 @@ class _Slot:
 class Runtime:
     def __init__(self) -> None:
         self._vm = VirtualMachine()
-        self._globals: dict[str, object] = {}
-        self._globals.update({"__name__": "__main__", "__package__": "", "__doc__": None})
+        self._globals: dict[str, object] = default_builtins()
+        self._globals.update(
+            {"__name__": "__main__", "__package__": "", "__doc__": None}
+        )
         self._values: dict[int, _Slot] = {}
         self._next = 1
         self._eval_counter = 0

From d0b1316f3a679af09482ec2df36991c17d89625c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:18:45 -0500
Subject: [PATCH 032/450] Seed builtin names in every full Runtime

---
 tools/normalize_full_reference_abi_helpers.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 1dfd97fd..2b2ed84a 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -3,9 +3,9 @@
 The verified source payload originally named several Python-authored functions
 with the ``_portapy_cabi_`` prefix. PortaPy's linker layer reserves those names
 for register-preserving assembly adapters. This pass renames the underlying
-implementations, removes redundant forwarding wrappers, installs host-owned
-module resolution for every runtime, and preserves UTF-8 C span semantics at
-the Python-authored ABI boundary.
+implementations, removes redundant forwarding wrappers, installs explicit
+builtins and host-owned module resolution for every runtime, and preserves
+UTF-8 C span semantics at the Python-authored ABI boundary.
 """
 from __future__ import annotations
 
@@ -74,6 +74,7 @@ def __call__(self, name: str) -> object:
 
 _RUNTIME_CREATE_SOURCE = '''
 instance = Runtime()
+instance._vm._seed_builtins(instance._globals)
 instance.set_global("__pyinbin_import__", _PortaPyImportLoader(instance))
 _runtimes.append(instance)
 _set_status(PORTAPY_OK)
@@ -188,16 +189,19 @@ def main() -> int:
         "_PortaPyImportLoader" in classes
         and "__pyinbin_import__" in runtime_create_text
     )
-    if missing or stale or unsafe_spans or not loader_ready:
+    builtins_ready = "_seed_builtins" in runtime_create_text
+    if missing or stale or unsafe_spans or not loader_ready or not builtins_ready:
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
             f"missing={missing}, stale={stale}, "
-            f"unsafe_utf8_spans={len(unsafe_spans)}, loader_ready={loader_ready}"
+            f"unsafe_utf8_spans={len(unsafe_spans)}, "
+            f"loader_ready={loader_ready}, builtins_ready={builtins_ready}"
         )
     print(
         "NORMALIZED FULL RUNTIME ABI HELPERS",
         len(_RENAME),
         len(_DROP),
+        "BUILTINS",
         "IMPORT_LOADER",
     )
     return 0

From 1bd1552c92ec0eb61a73a35adababca41e90f9ed Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:19:09 -0500
Subject: [PATCH 033/450] Test builtin seeding in full Runtime normalization

---
 tests/test_full_reference_abi_normalization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 07c1e2e3..6c65a9b6 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -7,7 +7,7 @@
 from tools import normalize_full_reference_abi_helpers as normalizer
 
 
-def test_full_reference_normalization_installs_import_loader_and_utf8_spans(
+def test_full_reference_normalization_installs_runtime_support(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
@@ -35,6 +35,7 @@ def test_full_reference_normalization_installs_import_loader_and_utf8_spans(
         and node.name == "_portapy_runtime_create_impl"
     )
     runtime_source = ast.unparse(runtime_create)
+    assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
     assert "_PortaPyImportLoader(instance)" in runtime_source
     assert "__pyinbin_import__" in runtime_source
 

From c1a86689c3946c65c6ab9d018b5cdd37439da0f5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:21:16 -0500
Subject: [PATCH 034/450] Upload complete native build logs

---
 .github/workflows/release-3.14.0.yml | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index a4b7ebab..1daf5d5c 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -38,10 +38,13 @@ jobs:
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
       - name: Build full libportapy.so
         run: |
+          mkdir -p dist
+          set -o pipefail
           python tools/build_native_typed.py \
             --target linux \
             --output dist/libportapy.so \
-            --work-dir dist/build-linux
+            --work-dir dist/build-linux \
+            2>&1 | tee dist/build-linux.log
       - name: Validate Linux stable artifact
         run: |
           readelf -dW dist/libportapy.so | tee dist/linux-dynamic-section.txt
@@ -63,6 +66,7 @@ jobs:
         with:
           name: portapy-linux-3.14.0
           path: |
+            dist/build-linux.log
             dist/libportapy.so
             dist/libportapy.so.json
             dist/linux-dynamic-section.txt
@@ -86,11 +90,14 @@ jobs:
       - name: Build full portapy.dll
         shell: powershell
         run: |
+          New-Item -ItemType Directory -Force dist | Out-Null
           python tools/build_native_typed.py `
             --target windows `
             --output dist/portapy.dll `
-            --work-dir dist/build-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+            --work-dir dist/build-windows `
+            2>&1 | Tee-Object -FilePath dist/build-windows.log
+          $buildStatus = $LASTEXITCODE
+          if ($buildStatus -ne 0) { exit $buildStatus }
       - name: Validate Windows stable artifact
         shell: powershell
         run: |
@@ -110,6 +117,7 @@ jobs:
         with:
           name: portapy-windows-3.14.0
           path: |
+            dist/build-windows.log
             dist/portapy.dll
             dist/portapy.dll.json
             dist/windows-imports.txt

From fdcf847c6cbdc72d36178d2f1e81db45587509ee Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:24:27 -0500
Subject: [PATCH 035/450] Make native AST arg normalization idempotent

---
 tools/combine_full_core_native_parser.py | 49 ++++++++++++++++--------
 1 file changed, 34 insertions(+), 15 deletions(-)

diff --git a/tools/combine_full_core_native_parser.py b/tools/combine_full_core_native_parser.py
index bed39949..487a050e 100644
--- a/tools/combine_full_core_native_parser.py
+++ b/tools/combine_full_core_native_parser.py
@@ -86,6 +86,8 @@ def _prepare_runtime(module: ast.Module) -> list[ast.stmt]:
 def _rename_ast_arg_class(module: ast.Module) -> None:
     class_count = 0
     call_count = 0
+    existing_class_count = 0
+    existing_call_count = 0
 
     class _AnnotationRenamer(ast.NodeTransformer):
         def visit_Name(self, node: ast.Name) -> ast.AST:
@@ -95,16 +97,18 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
 
     renamer = _AnnotationRenamer()
     for node in ast.walk(module):
-        if isinstance(node, ast.ClassDef) and node.name == "arg":
-            node.name = "AstArg"
-            class_count += 1
-        elif (
-            isinstance(node, ast.Call)
-            and isinstance(node.func, ast.Name)
-            and node.func.id == "arg"
-        ):
-            node.func.id = "AstArg"
-            call_count += 1
+        if isinstance(node, ast.ClassDef):
+            if node.name == "arg":
+                node.name = "AstArg"
+                class_count += 1
+            elif node.name == "AstArg":
+                existing_class_count += 1
+        elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            if node.func.id == "arg":
+                node.func.id = "AstArg"
+                call_count += 1
+            elif node.func.id == "AstArg":
+                existing_call_count += 1
 
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             arguments = [
@@ -124,12 +128,27 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
         elif isinstance(node, ast.AnnAssign):
             node.annotation = renamer.visit(node.annotation)
 
-    if class_count != 1 or call_count < 1:
-        raise RuntimeError(
-            "native AST arg rename failed: "
-            f"classes={class_count}, calls={call_count}"
+    if class_count == 1 and call_count >= 1:
+        print("RENAMED NATIVE AST ARG CLASS", class_count, call_count)
+        return
+    if (
+        class_count == 0
+        and call_count == 0
+        and existing_class_count == 1
+        and existing_call_count >= 1
+    ):
+        print(
+            "PRESERVED RENAMED NATIVE AST ARG CLASS",
+            existing_class_count,
+            existing_call_count,
         )
-    print("RENAMED NATIVE AST ARG CLASS", class_count, call_count)
+        return
+    raise RuntimeError(
+        "native AST arg rename failed: "
+        f"classes={class_count}, calls={call_count}, "
+        f"existing_classes={existing_class_count}, "
+        f"existing_calls={existing_call_count}"
+    )
 
 
 def _prepare_bridge(module: ast.Module) -> list[ast.stmt]:

From 7893b9fbf939f010b814a8dd80e3336c76400be2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:24:37 -0500
Subject: [PATCH 036/450] Add concise native compiler diagnostic

---
 .github/workflows/native-build-diagnostic.yml | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 .github/workflows/native-build-diagnostic.yml

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
new file mode 100644
index 00000000..50c332b4
--- /dev/null
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -0,0 +1,63 @@
+name: Native build diagnostic
+
+on:
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: native-build-diagnostic-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-22.04
+    outputs:
+      status: ${{ steps.build.outputs.status }}
+      tail: ${{ steps.build.outputs.tail }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install quietly
+        shell: bash
+        run: |
+          sudo apt-get update > /tmp/install.log 2>&1
+          sudo apt-get install --yes nasm gcc binutils >> /tmp/install.log 2>&1
+          python -m pip install -e '.[test]' >> /tmp/install.log 2>&1
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1' \
+            >> /tmp/install.log 2>&1
+      - name: Capture compiler tail
+        id: build
+        shell: bash
+        run: |
+          set +e
+          python tools/build_native_typed.py \
+            --target linux \
+            --output /tmp/libportapy.so \
+            --work-dir /tmp/build-linux \
+            > /tmp/build.log 2>&1
+          status=$?
+          echo "status=$status" >> "$GITHUB_OUTPUT"
+          echo 'tail<<PORTAPY_BUILD_TAIL' >> "$GITHUB_OUTPUT"
+          tail -n 90 /tmp/build.log >> "$GITHUB_OUTPUT"
+          echo 'PORTAPY_BUILD_TAIL' >> "$GITHUB_OUTPUT"
+          exit 0
+
+  report-linux:
+    needs: build-linux
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Report compiler tail
+        env:
+          BUILD_TAIL: ${{ needs.build-linux.outputs.tail }}
+          BUILD_STATUS: ${{ needs.build-linux.outputs.status }}
+        shell: bash
+        run: |
+          printf '%s\n' "$BUILD_TAIL"
+          exit "$BUILD_STATUS"

From 1195b3afeee793990ef8a7c635bd38b477c65fb6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:27:54 -0500
Subject: [PATCH 037/450] Bridge extended semantics across keyword parser
 ordering

---
 ...ize_full_core_extended_semantics_compat.py | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 tools/normalize_full_core_extended_semantics_compat.py

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
new file mode 100644
index 00000000..13ed43f7
--- /dev/null
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -0,0 +1,73 @@
+"""Run extended-semantics normalization across current parser pass ordering.
+
+``normalize_full_core_keyword_calls`` replaces ``_parse_call_args`` before the
+extended-semantics pass runs.  The latter historically tried to rewrite the
+old method's explicit ``*`` and ``**`` branches even though it subsequently
+replaces the whole method with the native bootstrap implementation.  This
+wrapper permits those two stale textual rewrites to be absent only when the
+current method contains no starred AST construction at all.
+"""
+from __future__ import annotations
+
+from tools import normalize_full_core_extended_semantics as _base
+
+
+_OPTIONAL_LABELS = {
+    "keyword unpack parser": "_npr_ast_nodes_DoubleStarred",
+    "positional unpack parser": "_npr_ast_nodes_Starred",
+}
+
+
+def _call_argument_method(source: str) -> str:
+    signature = "    def _parse_call_args(self):"
+    next_signature = "\n    def _parse_tuple_rhs(self):"
+    start = source.find(signature)
+    if start < 0:
+        raise RuntimeError("call argument compatibility: method start not found")
+    end = source.find(next_signature, start + len(signature))
+    if end < 0:
+        raise RuntimeError("call argument compatibility: next method not found")
+    return source[start:end]
+
+
+def _compatible_replace(
+    source: str,
+    old: str,
+    new: str,
+    *,
+    label: str,
+    expected: int = 1,
+) -> str:
+    count = source.count(old)
+    marker = _OPTIONAL_LABELS.get(label)
+    if marker is not None and count == 0:
+        method = _call_argument_method(source)
+        if marker in method:
+            raise RuntimeError(
+                f"{label}: stale rewrite missing while {marker} remains"
+            )
+        print("SKIPPED", label, "call parser already normalized")
+        return source
+    return _original_replace(
+        source,
+        old,
+        new,
+        label=label,
+        expected=expected,
+    )
+
+
+_original_replace = _base._replace
+
+
+def main() -> int:
+    previous = _base._replace
+    _base._replace = _compatible_replace
+    try:
+        return _base.main()
+    finally:
+        _base._replace = previous
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 2c29a3c26f11cc790db3446b513c8686f75e3208 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:28:09 -0500
Subject: [PATCH 038/450] Preserve call parser shape between native
 normalization passes

---
 tools/normalize_full_core_calls_closures.py | 30 +++++++++++++++++----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_core_calls_closures.py b/tools/normalize_full_core_calls_closures.py
index 8e4a42c2..28f72e12 100644
--- a/tools/normalize_full_core_calls_closures.py
+++ b/tools/normalize_full_core_calls_closures.py
@@ -108,14 +108,34 @@ def _full_core_parser_collect_expr_names(node: object, result: list[str]) -> Non
 
 
 _CALL_ARGS = '''    def _parse_call_args(self):
-        args: list[object] = []
-        kwargs: list[object] = []
-        while not self._check('OP', ')'):
-            value = self._parse_expr()
-            args.append(value)
+        args: list = []
+        kwargs: list = []
+        if self._check('OP', ')'):
+            return (args, kwargs)
+        while True:
+            if self._check('NAME') and self._peek(1).kind == 'OP' and (self._peek(1).value == '='):
+                name = self._eat().value
+                self._eat()
+                kwargs.append((name, self._parse_expr()))
+            elif self._check('OP', '**'):
+                star_pos = self._eat().pos
+                args.append(_npr_ast_nodes_DoubleStarred(value=self._parse_expr(), pos=star_pos))
+            else:
+                if kwargs:
+                    raise _npr_errors_ParseError('positional argument follows keyword argument', self._peek().pos)
+                if self._check('OP', '*'):
+                    star_pos = self._eat().pos
+                    args.append(_npr_ast_nodes_Starred(value=self._parse_expr(), pos=star_pos))
+                else:
+                    arg = self._parse_expr()
+                    if self._check('KEYWORD', 'for'):
+                        arg = self._parse_comprehension_tail(arg, arg.pos)
+                    args.append(arg)
             if not self._check('OP', ','):
                 break
             self._eat()
+            if self._check('OP', ')'):
+                break
         return (args, kwargs)
 '''
 

From 50101614abc30dabb8a1f2bcd69ef9026266bb3f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:29:05 -0500
Subject: [PATCH 039/450] Use parser-order compatible extended semantics pass

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index a220169f..e21de71b 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -11,7 +11,7 @@
 )
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
-from tools.normalize_full_core_extended_semantics import (
+from tools.normalize_full_core_extended_semantics_compat import (
     main as normalize_extended_semantics,
 )
 from tools.normalize_full_core_keyword_calls import (

From e2e6cebf21adc6ca49aca1c5fcb977640025c9f1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:32:15 -0500
Subject: [PATCH 040/450] Recognize already-normalized exception VM forms

---
 ...ize_full_core_extended_semantics_compat.py | 40 +++++++++++++------
 1 file changed, 27 insertions(+), 13 deletions(-)

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
index 13ed43f7..d2bb57f1 100644
--- a/tools/normalize_full_core_extended_semantics_compat.py
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -1,22 +1,26 @@
-"""Run extended-semantics normalization across current parser pass ordering.
-
-``normalize_full_core_keyword_calls`` replaces ``_parse_call_args`` before the
-extended-semantics pass runs.  The latter historically tried to rewrite the
-old method's explicit ``*`` and ``**`` branches even though it subsequently
-replaces the whole method with the native bootstrap implementation.  This
-wrapper permits those two stale textual rewrites to be absent only when the
-current method contains no starred AST construction at all.
+"""Run extended-semantics normalization across current pass ordering.
+
+Several earlier native-bootstrap passes now produce the exact target form that
+``normalize_full_core_extended_semantics`` historically created itself. This
+wrapper skips only those stale textual rewrites whose replacement semantics are
+already present, while retaining the original fail-closed behavior everywhere
+else.
 """
 from __future__ import annotations
 
 from tools import normalize_full_core_extended_semantics as _base
 
 
-_OPTIONAL_LABELS = {
+_CALL_PARSER_MARKERS = {
     "keyword unpack parser": "_npr_ast_nodes_DoubleStarred",
     "positional unpack parser": "_npr_ast_nodes_Starred",
 }
 
+_ALREADY_NORMALIZED_MARKERS = {
+    "dynamic exception reraising": "RuntimeError: exception did not match handler",
+    "exception stack extension": "frame.stack.append(matched)",
+}
+
 
 def _call_argument_method(source: str) -> str:
     signature = "    def _parse_call_args(self):"
@@ -39,15 +43,25 @@ def _compatible_replace(
     expected: int = 1,
 ) -> str:
     count = source.count(old)
-    marker = _OPTIONAL_LABELS.get(label)
-    if marker is not None and count == 0:
+    call_marker = _CALL_PARSER_MARKERS.get(label)
+    if call_marker is not None and count == 0:
         method = _call_argument_method(source)
-        if marker in method:
+        if call_marker in method:
             raise RuntimeError(
-                f"{label}: stale rewrite missing while {marker} remains"
+                f"{label}: stale rewrite missing while {call_marker} remains"
             )
         print("SKIPPED", label, "call parser already normalized")
         return source
+
+    target_marker = _ALREADY_NORMALIZED_MARKERS.get(label)
+    if target_marker is not None and count == 0:
+        if target_marker not in source:
+            raise RuntimeError(
+                f"{label}: neither source nor normalized target form is present"
+            )
+        print("SKIPPED", label, "target form already present")
+        return source
+
     return _original_replace(
         source,
         old,

From e5dadef4f862832de425b0cb621b04ffb3011a60 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:32:57 -0500
Subject: [PATCH 041/450] Recognize normalized VM context-manager paths

---
 tools/normalize_full_core_extended_semantics_compat.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
index d2bb57f1..84c7f2ea 100644
--- a/tools/normalize_full_core_extended_semantics_compat.py
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -19,6 +19,7 @@
 _ALREADY_NORMALIZED_MARKERS = {
     "dynamic exception reraising": "RuntimeError: exception did not match handler",
     "exception stack extension": "frame.stack.append(matched)",
+    "context-manager exception forwarding": "exit_args.append(exc_type)",
 }
 
 
@@ -55,11 +56,13 @@ def _compatible_replace(
 
     target_marker = _ALREADY_NORMALIZED_MARKERS.get(label)
     if target_marker is not None and count == 0:
-        if target_marker not in source:
+        marker_count = source.count(target_marker)
+        if marker_count != 1:
             raise RuntimeError(
-                f"{label}: neither source nor normalized target form is present"
+                f"{label}: neither unique source nor normalized target form is present; "
+                f"target matches={marker_count}"
             )
-        print("SKIPPED", label, "target form already present")
+        print("PRESERVED", label, marker_count)
         return source
 
     return _original_replace(

From c321ff97d5ecc1b624895b5bc8ddbea10dcd06a4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:35:15 -0500
Subject: [PATCH 042/450] Rewrite compact native exception dispatch safely

---
 ...ize_full_core_extended_semantics_compat.py | 33 +++++++++++++++----
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
index 84c7f2ea..aa0be799 100644
--- a/tools/normalize_full_core_extended_semantics_compat.py
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -1,10 +1,9 @@
 """Run extended-semantics normalization across current pass ordering.
 
-Several earlier native-bootstrap passes now produce the exact target form that
-``normalize_full_core_extended_semantics`` historically created itself. This
-wrapper skips only those stale textual rewrites whose replacement semantics are
-already present, while retaining the original fail-closed behavior everywhere
-else.
+Several earlier native-bootstrap passes now produce either the exact target form
+or a compact equivalent of source that ``normalize_full_core_extended_semantics``
+historically rewrote. This wrapper recognizes only those verified shapes while
+retaining the original fail-closed behavior everywhere else.
 """
 from __future__ import annotations
 
@@ -17,11 +16,19 @@
 }
 
 _ALREADY_NORMALIZED_MARKERS = {
-    "dynamic exception reraising": "RuntimeError: exception did not match handler",
     "exception stack extension": "frame.stack.append(matched)",
     "context-manager exception forwarding": "exit_args.append(exc_type)",
 }
 
+_DYNAMIC_EXCEPTION_COMPACT = '''                    if not self._exception_matches(value, expected):
+                        if isinstance(value, (BaseException, PyException)): raise value
+                        _raise_typed("RuntimeError: invalid exception value")'''
+
+_DYNAMIC_EXCEPTION_TARGET = '''                    if not self._exception_matches(value, expected):
+                        if isinstance(value, (BaseException, PyException)):
+                            _raise_typed("RuntimeError: exception did not match handler")
+                        _raise_typed("RuntimeError: invalid exception value")'''
+
 
 def _call_argument_method(source: str) -> str:
     signature = "    def _parse_call_args(self):"
@@ -54,6 +61,20 @@ def _compatible_replace(
         print("SKIPPED", label, "call parser already normalized")
         return source
 
+    if label == "dynamic exception reraising" and count == 0:
+        compact_count = source.count(_DYNAMIC_EXCEPTION_COMPACT)
+        if compact_count != 1:
+            raise RuntimeError(
+                "dynamic exception reraising: neither canonical nor compact "
+                f"source form is unique; compact matches={compact_count}"
+            )
+        print("REPLACED", label, compact_count, "compact form")
+        return source.replace(
+            _DYNAMIC_EXCEPTION_COMPACT,
+            _DYNAMIC_EXCEPTION_TARGET,
+            1,
+        )
+
     target_marker = _ALREADY_NORMALIZED_MARKERS.get(label)
     if target_marker is not None and count == 0:
         marker_count = source.count(target_marker)

From 1e6e1ee25d2926ec5e5d7cac0fa215af60e211aa Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:37:09 -0500
Subject: [PATCH 043/450] Accept compact native collection bootstrap

---
 tools/normalize_full_core_collections.py | 38 +++++++++++++++++-------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/tools/normalize_full_core_collections.py b/tools/normalize_full_core_collections.py
index 4ad82f0c..76de8730 100644
--- a/tools/normalize_full_core_collections.py
+++ b/tools/normalize_full_core_collections.py
@@ -6,16 +6,20 @@
 
 PATH = Path("src/portapy/core/vm.py")
 
-
-def main() -> int:
-    source = PATH.read_text(encoding="utf-8")
-    old = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
+_CANONICAL_BOOTSTRAP = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
                     if len(frame.stack) < instr.arg:
                         _raise_typed("RuntimeError: collection stack underflow")
                     values = _full_core_probe_pop_tail(frame.stack, instr.arg)
                     frame.stack.append(None)
 '''
-    new = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
+
+_COMPACT_BOOTSTRAP = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
+                    if len(frame.stack) < instr.arg: _raise_typed("RuntimeError: collection stack underflow")
+                    values = _full_core_probe_pop_tail(frame.stack, instr.arg)
+                    frame.stack.append(None)
+'''
+
+_RESTORED = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
                     if len(frame.stack) < instr.arg:
                         _raise_typed("RuntimeError: collection stack underflow")
                     values = _full_core_probe_pop_tail(frame.stack, instr.arg)
@@ -24,13 +28,27 @@ def main() -> int:
                     else:
                         frame.stack.append(set(values))
 '''
-    count = source.count(old)
-    if count != 1:
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    matches = [
+        candidate
+        for candidate in (_CANONICAL_BOOTSTRAP, _COMPACT_BOOTSTRAP)
+        if source.count(candidate) == 1
+    ]
+    if len(matches) != 1:
+        counts = {
+            "canonical": source.count(_CANONICAL_BOOTSTRAP),
+            "compact": source.count(_COMPACT_BOOTSTRAP),
+        }
         raise RuntimeError(
-            f"native tuple/set bootstrap: expected 1 match, found {count}"
+            "native tuple/set bootstrap: expected one verified source form, "
+            f"found {counts}"
         )
-    PATH.write_text(source.replace(old, new, 1), encoding="utf-8")
-    print("RESTORED NATIVE TUPLE AND SET CONSTRUCTION", count)
+    source = source.replace(matches[0], _RESTORED, 1)
+    PATH.write_text(source, encoding="utf-8")
+    print("RESTORED NATIVE TUPLE AND SET CONSTRUCTION", 1)
     return 0
 
 

From fad124f81fef94c6298d5dca698ef1dff09d6a3b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:37:21 -0500
Subject: [PATCH 044/450] Test native collection normalization variants

---
 tests/test_normalize_full_core_collections.py | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 tests/test_normalize_full_core_collections.py

diff --git a/tests/test_normalize_full_core_collections.py b/tests/test_normalize_full_core_collections.py
new file mode 100644
index 00000000..7af40704
--- /dev/null
+++ b/tests/test_normalize_full_core_collections.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from tools import normalize_full_core_collections as collections
+
+
+def _run(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, source: str) -> str:
+    path = tmp_path / "vm.py"
+    path.write_text(source, encoding="utf-8")
+    monkeypatch.setattr(collections, "PATH", path)
+    assert collections.main() == 0
+    return path.read_text(encoding="utf-8")
+
+
+def test_restores_canonical_collection_bootstrap(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    result = _run(tmp_path, monkeypatch, collections._CANONICAL_BOOTSTRAP)
+    assert result == collections._RESTORED
+
+
+def test_restores_compact_collection_bootstrap(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    result = _run(tmp_path, monkeypatch, collections._COMPACT_BOOTSTRAP)
+    assert result == collections._RESTORED
+
+
+def test_rejects_missing_or_ambiguous_collection_bootstrap(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(
+        collections._CANONICAL_BOOTSTRAP + collections._COMPACT_BOOTSTRAP,
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(collections, "PATH", path)
+    with pytest.raises(RuntimeError, match="expected one verified source form"):
+        collections.main()

From 13500a5e786f8642a982e71e7dd833ebd287d6fe Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:39:17 -0500
Subject: [PATCH 045/450] Run complete native normalization sequence in
 canonical builder

---
 tools/build_native_full_runtime.py | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/tools/build_native_full_runtime.py b/tools/build_native_full_runtime.py
index 193e0013..5cc84040 100644
--- a/tools/build_native_full_runtime.py
+++ b/tools/build_native_full_runtime.py
@@ -17,6 +17,10 @@
 from tools.elf_runtime_abi import fix_linux_runtime_abi
 from tools.nasm_direct_float_abi import append_direct_float_abi
 from tools.native_surface import public_exports
+from tools.normalize_full_core_lambdas import main as normalize_lambdas
+from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
+from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
+from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_validation import main as normalize_full_runtime
 from tools.python_surface import PYTHON_MODULE_EXPORTS
 
@@ -24,6 +28,21 @@
 SOURCE = REPOSITORY_ROOT / "src" / "portapy" / "native_full_reference_entry.py"
 
 
+def _prepare_full_runtime_sources() -> None:
+    """Apply the verified full-core native normalization sequence once.
+
+    This is the same ordering used by the original Linux/Windows full-core
+    probe workflow.  Keeping it in the canonical builder makes a direct
+    ``build_native_typed.py`` invocation self-contained instead of depending
+    on CI having pre-mutated the checkout.
+    """
+    normalize_probe()
+    normalize_lambdas()
+    normalize_native_semantics()
+    normalize_opcode_maps()
+    normalize_full_runtime()
+
+
 def _install_full_runtime_transforms() -> None:
     original_transform = base_build._transform_assembly
 
@@ -73,7 +92,7 @@ def build_full_runtime(
     normalize: bool = True,
 ) -> dict[str, object]:
     if normalize:
-        normalize_full_runtime()
+        _prepare_full_runtime_sources()
     _install_full_runtime_transforms()
 
     metadata = base_build.build_native(

From 2e0957e9deeb23eeab7973033e821453c527b52e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:39:23 -0500
Subject: [PATCH 046/450] Make full Runtime normalization self-contained

---
 tools/normalize_full_core_validation.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index e21de71b..6160880a 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -1,4 +1,4 @@
-"""Apply final validation-oriented rewrites to the native full-core probe."""
+"""Apply the complete native full-core normalization pipeline."""
 from __future__ import annotations
 
 from pathlib import Path
@@ -17,8 +17,12 @@
 from tools.normalize_full_core_keyword_calls import (
     main as normalize_keyword_calls,
 )
+from tools.normalize_full_core_lambdas import main as normalize_lambdas
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
+from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
+from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
+from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
@@ -60,6 +64,14 @@ def _normalize_opcode_validation() -> None:
 
 
 def main() -> int:
+    # These four passes were historically run only by the probe workflow.
+    # Keeping them here makes clean production builds use the same proven
+    # compiler-safe source preparation as the full-core transition probe.
+    normalize_probe()
+    normalize_lambdas()
+    normalize_native_semantics()
+    normalize_opcode_maps()
+
     materialize_reference_entry()
     normalize_reference_abi_helpers()
     normalize_native_parser()

From 56d23c921f1175e6b0c7ec38fadce2e400d54870 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:39:36 -0500
Subject: [PATCH 047/450] Normalize collection bootstrap structurally

---
 tools/normalize_full_core_collections.py | 61 ++++++++++++++----------
 1 file changed, 35 insertions(+), 26 deletions(-)

diff --git a/tools/normalize_full_core_collections.py b/tools/normalize_full_core_collections.py
index 76de8730..50693f0f 100644
--- a/tools/normalize_full_core_collections.py
+++ b/tools/normalize_full_core_collections.py
@@ -6,48 +6,57 @@
 
 PATH = Path("src/portapy/core/vm.py")
 
+_BLOCK_START = "                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):\n"
+_BLOCK_END = "                elif op is Op.GET_ITEM:\n"
+_BOOTSTRAP_VALUE = "                    frame.stack.append(None)"
+_RESTORED_VALUE = '''                    if op is Op.BUILD_TUPLE:
+                        frame.stack.append(tuple(values))
+                    else:
+                        frame.stack.append(set(values))'''
+
 _CANONICAL_BOOTSTRAP = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
                     if len(frame.stack) < instr.arg:
                         _raise_typed("RuntimeError: collection stack underflow")
                     values = _full_core_probe_pop_tail(frame.stack, instr.arg)
                     frame.stack.append(None)
+                elif op is Op.GET_ITEM:
 '''
 
 _COMPACT_BOOTSTRAP = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
                     if len(frame.stack) < instr.arg: _raise_typed("RuntimeError: collection stack underflow")
-                    values = _full_core_probe_pop_tail(frame.stack, instr.arg)
+                    values = frame.stack[-instr.arg:] if instr.arg else []
+                    if instr.arg: del frame.stack[-instr.arg:]
                     frame.stack.append(None)
+                elif op is Op.GET_ITEM:
 '''
 
-_RESTORED = '''                elif op in (Op.BUILD_TUPLE, Op.BUILD_SET):
-                    if len(frame.stack) < instr.arg:
-                        _raise_typed("RuntimeError: collection stack underflow")
-                    values = _full_core_probe_pop_tail(frame.stack, instr.arg)
-                    if op is Op.BUILD_TUPLE:
-                        frame.stack.append(tuple(values))
-                    else:
-                        frame.stack.append(set(values))
-'''
+
+def _collection_block(source: str) -> tuple[int, int, str]:
+    if source.count(_BLOCK_START) != 1:
+        raise RuntimeError(
+            "native tuple/set bootstrap: expected one BUILD_TUPLE/BUILD_SET block"
+        )
+    start = source.find(_BLOCK_START)
+    end = source.find(_BLOCK_END, start + len(_BLOCK_START))
+    if end < 0:
+        raise RuntimeError("native tuple/set bootstrap: GET_ITEM boundary not found")
+    block = source[start:end]
+    if "collection stack underflow" not in block or "values =" not in block:
+        raise RuntimeError("native tuple/set bootstrap: required safety checks are missing")
+    if block.count(_BOOTSTRAP_VALUE) != 1:
+        raise RuntimeError(
+            "native tuple/set bootstrap: expected one placeholder collection result"
+        )
+    if "tuple(values)" in block or "set(values)" in block:
+        raise RuntimeError("native tuple/set bootstrap: block is already partially restored")
+    return start, end, block
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    matches = [
-        candidate
-        for candidate in (_CANONICAL_BOOTSTRAP, _COMPACT_BOOTSTRAP)
-        if source.count(candidate) == 1
-    ]
-    if len(matches) != 1:
-        counts = {
-            "canonical": source.count(_CANONICAL_BOOTSTRAP),
-            "compact": source.count(_COMPACT_BOOTSTRAP),
-        }
-        raise RuntimeError(
-            "native tuple/set bootstrap: expected one verified source form, "
-            f"found {counts}"
-        )
-    source = source.replace(matches[0], _RESTORED, 1)
-    PATH.write_text(source, encoding="utf-8")
+    start, end, block = _collection_block(source)
+    restored = block.replace(_BOOTSTRAP_VALUE, _RESTORED_VALUE, 1)
+    PATH.write_text(source[:start] + restored + source[end:], encoding="utf-8")
     print("RESTORED NATIVE TUPLE AND SET CONSTRUCTION", 1)
     return 0
 

From 2609b4d18bc1548ad5cfd5f8f10a2f5a4d82ba0d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:39:50 -0500
Subject: [PATCH 048/450] Test structural collection normalization

---
 tests/test_normalize_full_core_collections.py | 31 ++++++++++++++++---
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/tests/test_normalize_full_core_collections.py b/tests/test_normalize_full_core_collections.py
index 7af40704..b449a25c 100644
--- a/tests/test_normalize_full_core_collections.py
+++ b/tests/test_normalize_full_core_collections.py
@@ -15,21 +15,29 @@ def _run(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, source: str) -> str:
     return path.read_text(encoding="utf-8")
 
 
+def _assert_restored(result: str) -> None:
+    assert "frame.stack.append(None)" not in result
+    assert "frame.stack.append(tuple(values))" in result
+    assert "frame.stack.append(set(values))" in result
+
+
 def test_restores_canonical_collection_bootstrap(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    result = _run(tmp_path, monkeypatch, collections._CANONICAL_BOOTSTRAP)
-    assert result == collections._RESTORED
+    _assert_restored(
+        _run(tmp_path, monkeypatch, collections._CANONICAL_BOOTSTRAP)
+    )
 
 
 def test_restores_compact_collection_bootstrap(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     result = _run(tmp_path, monkeypatch, collections._COMPACT_BOOTSTRAP)
-    assert result == collections._RESTORED
+    _assert_restored(result)
+    assert "if instr.arg: del frame.stack[-instr.arg:]" in result
 
 
-def test_rejects_missing_or_ambiguous_collection_bootstrap(
+def test_rejects_ambiguous_collection_bootstrap(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     path = tmp_path / "vm.py"
@@ -38,5 +46,18 @@ def test_rejects_missing_or_ambiguous_collection_bootstrap(
         encoding="utf-8",
     )
     monkeypatch.setattr(collections, "PATH", path)
-    with pytest.raises(RuntimeError, match="expected one verified source form"):
+    with pytest.raises(RuntimeError, match="expected one BUILD_TUPLE/BUILD_SET block"):
+        collections.main()
+
+
+def test_rejects_collection_block_without_placeholder(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source = collections._CANONICAL_BOOTSTRAP.replace(
+        "frame.stack.append(None)", "frame.stack.append(values)"
+    )
+    path = tmp_path / "vm.py"
+    path.write_text(source, encoding="utf-8")
+    monkeypatch.setattr(collections, "PATH", path)
+    with pytest.raises(RuntimeError, match="placeholder collection result"):
         collections.main()

From e2b6e85e6cbf86b9a81861d6673b79e839cc8345 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:40:50 -0500
Subject: [PATCH 049/450] Run full native normalization pipeline exactly once

---
 tools/build_native_full_runtime.py | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/tools/build_native_full_runtime.py b/tools/build_native_full_runtime.py
index 5cc84040..af666f31 100644
--- a/tools/build_native_full_runtime.py
+++ b/tools/build_native_full_runtime.py
@@ -17,10 +17,6 @@
 from tools.elf_runtime_abi import fix_linux_runtime_abi
 from tools.nasm_direct_float_abi import append_direct_float_abi
 from tools.native_surface import public_exports
-from tools.normalize_full_core_lambdas import main as normalize_lambdas
-from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
-from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
-from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_validation import main as normalize_full_runtime
 from tools.python_surface import PYTHON_MODULE_EXPORTS
 
@@ -29,17 +25,7 @@
 
 
 def _prepare_full_runtime_sources() -> None:
-    """Apply the verified full-core native normalization sequence once.
-
-    This is the same ordering used by the original Linux/Windows full-core
-    probe workflow.  Keeping it in the canonical builder makes a direct
-    ``build_native_typed.py`` invocation self-contained instead of depending
-    on CI having pre-mutated the checkout.
-    """
-    normalize_probe()
-    normalize_lambdas()
-    normalize_native_semantics()
-    normalize_opcode_maps()
+    """Apply the complete verified native normalization pipeline once."""
     normalize_full_runtime()
 
 

From 9dabb3a4641b9d1795e1dbe38ad72a8d319ca0f0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:42:54 -0500
Subject: [PATCH 050/450] Expose full native compiler diagnostic

---
 .github/workflows/native-build-diagnostic.yml | 27 +++++++++++++------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 50c332b4..17c2cef3 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-22.04
     outputs:
       status: ${{ steps.build.outputs.status }}
-      tail: ${{ steps.build.outputs.tail }}
+      report: ${{ steps.build.outputs.report }}
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -32,7 +32,7 @@ jobs:
           python -m pip install --no-cache-dir --force-reinstall \
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1' \
             >> /tmp/install.log 2>&1
-      - name: Capture compiler tail
+      - name: Capture compiler diagnostic
         id: build
         shell: bash
         run: |
@@ -43,21 +43,32 @@ jobs:
             --work-dir /tmp/build-linux \
             > /tmp/build.log 2>&1
           status=$?
+          {
+            echo '=== FIRST 35 LINES ==='
+            head -n 35 /tmp/build.log
+            echo
+            echo '=== ERROR-LIKE LINES ==='
+            grep -Ein 'error|failed|failure|unsupported|traceback|exception|undefined|invalid' \
+              /tmp/build.log | tail -n 120 || true
+            echo
+            echo '=== FINAL 120 LINES ==='
+            tail -n 120 /tmp/build.log
+          } > /tmp/report.log
           echo "status=$status" >> "$GITHUB_OUTPUT"
-          echo 'tail<<PORTAPY_BUILD_TAIL' >> "$GITHUB_OUTPUT"
-          tail -n 90 /tmp/build.log >> "$GITHUB_OUTPUT"
-          echo 'PORTAPY_BUILD_TAIL' >> "$GITHUB_OUTPUT"
+          echo 'report<<PORTAPY_BUILD_REPORT' >> "$GITHUB_OUTPUT"
+          cat /tmp/report.log >> "$GITHUB_OUTPUT"
+          echo 'PORTAPY_BUILD_REPORT' >> "$GITHUB_OUTPUT"
           exit 0
 
   report-linux:
     needs: build-linux
     runs-on: ubuntu-22.04
     steps:
-      - name: Report compiler tail
+      - name: Report compiler diagnostic
         env:
-          BUILD_TAIL: ${{ needs.build-linux.outputs.tail }}
+          BUILD_REPORT: ${{ needs.build-linux.outputs.report }}
           BUILD_STATUS: ${{ needs.build-linux.outputs.status }}
         shell: bash
         run: |
-          printf '%s\n' "$BUILD_TAIL"
+          printf '%s\n' "$BUILD_REPORT"
           exit "$BUILD_STATUS"

From 27a7a29a29b045f34c1f5e671f97cd03e7173a44 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:44:29 -0500
Subject: [PATCH 051/450] Upload normalized native compiler input on failure

---
 .github/workflows/native-build-diagnostic.yml | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 17c2cef3..41cae7b1 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -59,6 +59,19 @@ jobs:
           cat /tmp/report.log >> "$GITHUB_OUTPUT"
           echo 'PORTAPY_BUILD_REPORT' >> "$GITHUB_OUTPUT"
           exit 0
+      - name: Upload normalized compiler input
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: native-build-diagnostic-source
+          path: |
+            /tmp/build.log
+            /tmp/report.log
+            src/portapy/native_full_reference_entry.py
+            src/portapy/core/frontend.py
+            src/portapy/core/vm.py
+            src/portapy/core/loader.py
+            src/portapy/core/bytecode.py
 
   report-linux:
     needs: build-linux

From ae9ea98cfcdf18b97af8bb1b5c2c0c133eb45c24 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:47:38 -0500
Subject: [PATCH 052/450] Enable PortaPy builtin symbols in pinned compiler

---
 tools/normalize_full_core_lambdas.py | 160 +++++++++++++++++++++++++--
 1 file changed, 149 insertions(+), 11 deletions(-)

diff --git a/tools/normalize_full_core_lambdas.py b/tools/normalize_full_core_lambdas.py
index c13605ab..d862d10c 100644
--- a/tools/normalize_full_core_lambdas.py
+++ b/tools/normalize_full_core_lambdas.py
@@ -6,6 +6,7 @@
 import re
 
 import asmpython
+import asmpython._compiler.codegen as asmpython_codegen
 import asmpython._compiler.sema as asmpython_sema
 
 
@@ -15,6 +16,7 @@
 ASMPYTHON_ROOT = Path(asmpython.__file__).resolve().parent
 ASMPYTHON_STDLIB = ASMPYTHON_ROOT / "stdlib"
 ASMPYTHON_SEMA = Path(asmpython_sema.__file__).resolve()
+ASMPYTHON_CODEGEN = Path(asmpython_codegen.__file__).resolve()
 
 
 _FSTRING_CONVERTER_ASSIGN = (
@@ -26,6 +28,30 @@
 _FSTRING_CONVERTER_EMIT = "self.emit(Op.LOAD_CONST, self.constant(converter))"
 _FSTRING_NAME_EMIT = "self.emit(Op.LOAD_NAME, self.name_index(converter_name))"
 
+_PORTAPY_EXCEPTION_PARENTS = {
+    "GeneratorExit": "BaseException",
+    "SyntaxError": "Exception",
+    "StopAsyncIteration": "Exception",
+    "ModuleNotFoundError": "ImportError",
+}
+_PORTAPY_EXCEPTION_IDS = {
+    "GeneratorExit": 22,
+    "SyntaxError": 23,
+    "StopAsyncIteration": 24,
+    "ModuleNotFoundError": 25,
+}
+_PORTAPY_TYPE_IDS = {
+    "bytes": -9,
+    "bytearray": -10,
+    "object": -11,
+    "type": -12,
+    "slice": -13,
+    "frozenset": -14,
+    "staticmethod": -15,
+    "classmethod": -16,
+    "property": -17,
+}
+
 
 def _normalize_ascii(source: str) -> tuple[str, int, int]:
     call_count = source.count("ascii(")
@@ -43,20 +69,132 @@ def _normalize_ascii_file(path: Path, label: str) -> None:
     print(f"REPLACED {label} ASCII CONVERSIONS", conversion_count)
 
 
-def _enable_compiler_ascii() -> None:
-    source = ASMPYTHON_SEMA.read_text(encoding="utf-8")
-    marker = '    "repr": (1, 1),\n'
-    if marker not in source:
+def _insert_mapping_entries(
+    source: str,
+    *,
+    marker: str,
+    entries: dict[str, object],
+    label: str,
+) -> str:
+    missing = [name for name in entries if f'    "{name}":' not in source]
+    if not missing:
+        return source
+    if source.count(marker) != 1:
+        raise RuntimeError(f"{label}: expected one insertion marker")
+    lines = "".join(f'    "{name}": {entries[name]!r},\n' for name in missing)
+    return source.replace(marker, lines + marker, 1)
+
+
+def _insert_set_entries(
+    source: str,
+    *,
+    marker: str,
+    names: tuple[str, ...],
+    label: str,
+) -> str:
+    missing = [name for name in names if f'    "{name}",' not in source]
+    if not missing:
+        return source
+    if source.count(marker) != 1:
+        raise RuntimeError(f"{label}: expected one insertion marker")
+    lines = "".join(f'    "{name}",\n' for name in missing)
+    return source.replace(marker, lines + marker, 1)
+
+
+def _patch_compiler_runtime_symbols(
+    sema_source: str,
+    codegen_source: str,
+) -> tuple[str, str]:
+    sema_source = _insert_set_entries(
+        sema_source,
+        marker='    "FileNotFoundError",\n})',
+        names=tuple(_PORTAPY_EXCEPTION_PARENTS),
+        label="asmpython builtin exceptions",
+    )
+    sema_source = _insert_set_entries(
+        sema_source,
+        marker='    "int", "float", "str", "bool", "list", "dict", "tuple", "set",\n})',
+        names=tuple(_PORTAPY_TYPE_IDS),
+        label="asmpython builtin type names",
+    )
+    codegen_source = _insert_mapping_entries(
+        codegen_source,
+        marker='    "StopIteration": "Exception",\n}',
+        entries=_PORTAPY_EXCEPTION_PARENTS,
+        label="asmpython exception parents",
+    )
+    codegen_source = _insert_mapping_entries(
+        codegen_source,
+        marker='    "IOError": 19,  # alias for OSError (same id)\n}',
+        entries=_PORTAPY_EXCEPTION_IDS,
+        label="asmpython exception ids",
+    )
+    codegen_source = _insert_mapping_entries(
+        codegen_source,
+        marker='    "set": -8,\n}',
+        entries=_PORTAPY_TYPE_IDS,
+        label="asmpython builtin type ids",
+    )
+    return sema_source, codegen_source
+
+
+def _enable_compiler_builtins() -> None:
+    sema_source = ASMPYTHON_SEMA.read_text(encoding="utf-8")
+    ascii_marker = '    "repr": (1, 1),\n'
+    if ascii_marker not in sema_source:
         raise RuntimeError("asmpython semantic builtin table is missing repr")
-    if '    "ascii": (1, 1),\n' not in source:
-        source = source.replace(marker, marker + '    "ascii": (1, 1),\n', 1)
-    ASMPYTHON_SEMA.write_text(source, encoding="utf-8")
+    if '    "ascii": (1, 1),\n' not in sema_source:
+        sema_source = sema_source.replace(
+            ascii_marker,
+            ascii_marker + '    "ascii": (1, 1),\n',
+            1,
+        )
+
+    codegen_source = ASMPYTHON_CODEGEN.read_text(encoding="utf-8")
+    sema_source, codegen_source = _patch_compiler_runtime_symbols(
+        sema_source,
+        codegen_source,
+    )
+    ASMPYTHON_SEMA.write_text(sema_source, encoding="utf-8")
+    ASMPYTHON_CODEGEN.write_text(codegen_source, encoding="utf-8")
+
     importlib.invalidate_caches()
-    reloaded = importlib.reload(asmpython_sema)
-    if "ascii" not in reloaded.BUILTINS:
+    reloaded_sema = importlib.reload(asmpython_sema)
+    reloaded_codegen = importlib.reload(asmpython_codegen)
+    if "ascii" not in reloaded_sema.BUILTINS:
         raise RuntimeError(f"ascii was not enabled in active sema module: {ASMPYTHON_SEMA}")
+    missing_exceptions = sorted(
+        set(_PORTAPY_EXCEPTION_PARENTS) - set(reloaded_sema.BUILTIN_EXCEPTIONS)
+    )
+    missing_types = sorted(
+        set(_PORTAPY_TYPE_IDS) - set(reloaded_sema.BUILTIN_TYPE_NAMES)
+    )
+    missing_codegen_exceptions = sorted(
+        set(_PORTAPY_EXCEPTION_IDS) - set(reloaded_codegen.BUILTIN_EXC_IDS)
+    )
+    missing_codegen_types = sorted(
+        set(_PORTAPY_TYPE_IDS) - set(reloaded_codegen.BUILTIN_TYPE_IDS)
+    )
+    if (
+        missing_exceptions
+        or missing_types
+        or missing_codegen_exceptions
+        or missing_codegen_types
+    ):
+        raise RuntimeError(
+            "PortaPy compiler symbol enablement failed; "
+            f"sema_exceptions={missing_exceptions}, sema_types={missing_types}, "
+            f"codegen_exceptions={missing_codegen_exceptions}, "
+            f"codegen_types={missing_codegen_types}"
+        )
     print("ASMPYTHON SEMA PATH", ASMPYTHON_SEMA)
-    print("ENABLED ASMPYTHON ASCII BUILTIN", reloaded.BUILTINS["ascii"])
+    print("ASMPYTHON CODEGEN PATH", ASMPYTHON_CODEGEN)
+    print("ENABLED ASMPYTHON ASCII BUILTIN", reloaded_sema.BUILTINS["ascii"])
+    print(
+        "ENABLED PORTAPY COMPILER SYMBOLS",
+        len(_PORTAPY_EXCEPTION_IDS),
+        len(_PORTAPY_TYPE_IDS),
+    )
 
 
 def main() -> int:
@@ -118,7 +256,7 @@ def main() -> int:
         if not path.is_file():
             raise RuntimeError(f"missing asmpython stdlib source: {path}")
         _normalize_ascii_file(path, f"ASMPYTHON {name}")
-    _enable_compiler_ascii()
+    _enable_compiler_builtins()
     return 0
 
 

From 3a89576000ce4c92c010da5a7fc1e1c769d80f51 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:47:45 -0500
Subject: [PATCH 053/450] Compile production runtime through proven full-core
 CLI

---
 tools/build_native_full_runtime.py | 53 ++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/tools/build_native_full_runtime.py b/tools/build_native_full_runtime.py
index af666f31..c3f872e4 100644
--- a/tools/build_native_full_runtime.py
+++ b/tools/build_native_full_runtime.py
@@ -4,6 +4,8 @@
 import argparse
 import json
 from pathlib import Path
+import shlex
+import subprocess
 import sys
 
 
@@ -22,6 +24,7 @@
 
 
 SOURCE = REPOSITORY_ROOT / "src" / "portapy" / "native_full_reference_entry.py"
+COMPILER_WRAPPER = REPOSITORY_ROOT / "tools" / "run_full_core_asmpython.py"
 
 
 def _prepare_full_runtime_sources() -> None:
@@ -29,6 +32,55 @@ def _prepare_full_runtime_sources() -> None:
     normalize_full_runtime()
 
 
+def _install_full_runtime_compiler() -> None:
+    """Route production compilation through the proven full-core CLI wrapper."""
+
+    def compile_python_source(
+        *,
+        target: str,
+        source: Path,
+        output: Path,
+        build_log: Path,
+    ) -> Path:
+        command = [
+            sys.executable,
+            str(COMPILER_WRAPPER),
+            "build",
+            str(source),
+            "--target",
+            target,
+            "--type",
+            "library",
+            "--backend",
+            "legacy",
+            "--no-pyinbin-fallback",
+            "--keep-assembly",
+            "-o",
+            str(output),
+        ]
+        completed = subprocess.run(
+            command,
+            cwd=REPOSITORY_ROOT,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            check=False,
+        )
+        build_log.parent.mkdir(parents=True, exist_ok=True)
+        build_log.write_text(completed.stdout, encoding="utf-8")
+
+        assembly = output.with_suffix(".asm")
+        if not assembly.is_file():
+            rendered = shlex.join(command)
+            raise BuildFailure(
+                f"asmpython did not emit assembly (exit {completed.returncode}): "
+                f"{rendered}\n{completed.stdout}"
+            )
+        return assembly
+
+    base_build._compile_python_source = compile_python_source
+
+
 def _install_full_runtime_transforms() -> None:
     original_transform = base_build._transform_assembly
 
@@ -79,6 +131,7 @@ def build_full_runtime(
 ) -> dict[str, object]:
     if normalize:
         _prepare_full_runtime_sources()
+    _install_full_runtime_compiler()
     _install_full_runtime_transforms()
 
     metadata = base_build.build_native(

From 824d4a2e9c5325b9d9e96875ea2fe50d9a5eb44d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:48:02 -0500
Subject: [PATCH 054/450] Test pinned compiler symbol normalization

---
 ...st_normalize_full_core_compiler_symbols.py | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 tests/test_normalize_full_core_compiler_symbols.py

diff --git a/tests/test_normalize_full_core_compiler_symbols.py b/tests/test_normalize_full_core_compiler_symbols.py
new file mode 100644
index 00000000..ad22a194
--- /dev/null
+++ b/tests/test_normalize_full_core_compiler_symbols.py
@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from tools import normalize_full_core_lambdas as normalizer
+
+
+def _sema_source() -> str:
+    return '''BUILTINS = {
+    "repr": (1, 1),
+}
+BUILTIN_EXCEPTIONS = frozenset({
+    "FileNotFoundError",
+})
+BUILTIN_TYPE_NAMES = frozenset({
+    "int", "float", "str", "bool", "list", "dict", "tuple", "set",
+})
+'''
+
+
+def _codegen_source() -> str:
+    return '''BUILTIN_EXC_PARENTS = {
+    "StopIteration": "Exception",
+}
+BUILTIN_EXC_IDS = {
+    "StopIteration": 21,
+    "IOError": 19,  # alias for OSError (same id)
+}
+BUILTIN_TYPE_IDS = {
+    "set": -8,
+}
+'''
+
+
+def test_enables_all_portapy_compiler_symbols() -> None:
+    sema, codegen = normalizer._patch_compiler_runtime_symbols(
+        _sema_source(), _codegen_source()
+    )
+    for name in normalizer._PORTAPY_EXCEPTION_IDS:
+        assert f'    "{name}",' in sema
+        assert f'    "{name}":' in codegen
+    for name, identifier in normalizer._PORTAPY_TYPE_IDS.items():
+        assert f'    "{name}",' in sema
+        assert f'    "{name}": {identifier},' in codegen
+
+
+def test_compiler_symbol_patch_is_idempotent() -> None:
+    sema, codegen = normalizer._patch_compiler_runtime_symbols(
+        _sema_source(), _codegen_source()
+    )
+    assert normalizer._patch_compiler_runtime_symbols(sema, codegen) == (
+        sema,
+        codegen,
+    )

From 439f7ee3ac7a646e44eb70abe901bea0fecb479e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:50:54 -0500
Subject: [PATCH 055/450] Scope compiler symbol detection to target tables

---
 tools/normalize_full_core_lambdas.py | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/tools/normalize_full_core_lambdas.py b/tools/normalize_full_core_lambdas.py
index d862d10c..6936aa57 100644
--- a/tools/normalize_full_core_lambdas.py
+++ b/tools/normalize_full_core_lambdas.py
@@ -69,6 +69,16 @@ def _normalize_ascii_file(path: Path, label: str) -> None:
     print(f"REPLACED {label} ASCII CONVERSIONS", conversion_count)
 
 
+def _target_table(source: str, marker: str, label: str) -> str:
+    if source.count(marker) != 1:
+        raise RuntimeError(f"{label}: expected one insertion marker")
+    marker_index = source.index(marker)
+    table_start = source.rfind("{", 0, marker_index)
+    if table_start < 0:
+        raise RuntimeError(f"{label}: table start not found")
+    return source[table_start:marker_index + len(marker)]
+
+
 def _insert_mapping_entries(
     source: str,
     *,
@@ -76,11 +86,10 @@ def _insert_mapping_entries(
     entries: dict[str, object],
     label: str,
 ) -> str:
-    missing = [name for name in entries if f'    "{name}":' not in source]
+    table = _target_table(source, marker, label)
+    missing = [name for name in entries if f'    "{name}":' not in table]
     if not missing:
         return source
-    if source.count(marker) != 1:
-        raise RuntimeError(f"{label}: expected one insertion marker")
     lines = "".join(f'    "{name}": {entries[name]!r},\n' for name in missing)
     return source.replace(marker, lines + marker, 1)
 
@@ -92,11 +101,10 @@ def _insert_set_entries(
     names: tuple[str, ...],
     label: str,
 ) -> str:
-    missing = [name for name in names if f'    "{name}",' not in source]
+    table = _target_table(source, marker, label)
+    missing = [name for name in names if f'    "{name}",' not in table]
     if not missing:
         return source
-    if source.count(marker) != 1:
-        raise RuntimeError(f"{label}: expected one insertion marker")
     lines = "".join(f'    "{name}",\n' for name in missing)
     return source.replace(marker, lines + marker, 1)
 

From 9ebb5c44da8a57740c847f3324bb2cbdd7ca2c6d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:51:17 -0500
Subject: [PATCH 056/450] Strengthen compiler symbol table tests

---
 tests/test_normalize_full_core_compiler_symbols.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_compiler_symbols.py b/tests/test_normalize_full_core_compiler_symbols.py
index ad22a194..dbf7190a 100644
--- a/tests/test_normalize_full_core_compiler_symbols.py
+++ b/tests/test_normalize_full_core_compiler_symbols.py
@@ -6,6 +6,7 @@
 def _sema_source() -> str:
     return '''BUILTINS = {
     "repr": (1, 1),
+    "type": (1, 1),
 }
 BUILTIN_EXCEPTIONS = frozenset({
     "FileNotFoundError",
@@ -34,9 +35,11 @@ def test_enables_all_portapy_compiler_symbols() -> None:
     sema, codegen = normalizer._patch_compiler_runtime_symbols(
         _sema_source(), _codegen_source()
     )
-    for name in normalizer._PORTAPY_EXCEPTION_IDS:
+    for name, parent in normalizer._PORTAPY_EXCEPTION_PARENTS.items():
         assert f'    "{name}",' in sema
-        assert f'    "{name}":' in codegen
+        assert f'    "{name}": {parent!r},' in codegen
+    for name, identifier in normalizer._PORTAPY_EXCEPTION_IDS.items():
+        assert f'    "{name}": {identifier},' in codegen
     for name, identifier in normalizer._PORTAPY_TYPE_IDS.items():
         assert f'    "{name}",' in sema
         assert f'    "{name}": {identifier},' in codegen

From 8fba2edc58b72dda9189df3bb9c511b3ef5ced2f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:52:01 -0500
Subject: [PATCH 057/450] Load asmpython lazily in compiler symbol normalizer

---
 tools/normalize_full_core_lambdas.py | 43 ++++++++++++++++------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/tools/normalize_full_core_lambdas.py b/tools/normalize_full_core_lambdas.py
index 6936aa57..b0ec59d2 100644
--- a/tools/normalize_full_core_lambdas.py
+++ b/tools/normalize_full_core_lambdas.py
@@ -5,18 +5,10 @@
 from pathlib import Path
 import re
 
-import asmpython
-import asmpython._compiler.codegen as asmpython_codegen
-import asmpython._compiler.sema as asmpython_sema
-
 
 VM_PATH = Path("src/portapy/core/vm.py")
 FRONTEND_PATH = Path("src/portapy/core/frontend.py")
 BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
-ASMPYTHON_ROOT = Path(asmpython.__file__).resolve().parent
-ASMPYTHON_STDLIB = ASMPYTHON_ROOT / "stdlib"
-ASMPYTHON_SEMA = Path(asmpython_sema.__file__).resolve()
-ASMPYTHON_CODEGEN = Path(asmpython_codegen.__file__).resolve()
 
 
 _FSTRING_CONVERTER_ASSIGN = (
@@ -53,6 +45,16 @@
 }
 
 
+def _load_compiler_modules():
+    """Import asmpython only for a native build, never during hosted test collection."""
+    import asmpython
+    import asmpython._compiler.codegen as asmpython_codegen
+    import asmpython._compiler.sema as asmpython_sema
+
+    root = Path(asmpython.__file__).resolve().parent
+    return asmpython_sema, asmpython_codegen, root / "stdlib"
+
+
 def _normalize_ascii(source: str) -> tuple[str, int, int]:
     call_count = source.count("ascii(")
     conversion_count = source.count("!a")
@@ -146,8 +148,12 @@ def _patch_compiler_runtime_symbols(
     return sema_source, codegen_source
 
 
-def _enable_compiler_builtins() -> None:
-    sema_source = ASMPYTHON_SEMA.read_text(encoding="utf-8")
+def _enable_compiler_builtins() -> Path:
+    asmpython_sema, asmpython_codegen, stdlib = _load_compiler_modules()
+    sema_path = Path(asmpython_sema.__file__).resolve()
+    codegen_path = Path(asmpython_codegen.__file__).resolve()
+
+    sema_source = sema_path.read_text(encoding="utf-8")
     ascii_marker = '    "repr": (1, 1),\n'
     if ascii_marker not in sema_source:
         raise RuntimeError("asmpython semantic builtin table is missing repr")
@@ -158,19 +164,19 @@ def _enable_compiler_builtins() -> None:
             1,
         )
 
-    codegen_source = ASMPYTHON_CODEGEN.read_text(encoding="utf-8")
+    codegen_source = codegen_path.read_text(encoding="utf-8")
     sema_source, codegen_source = _patch_compiler_runtime_symbols(
         sema_source,
         codegen_source,
     )
-    ASMPYTHON_SEMA.write_text(sema_source, encoding="utf-8")
-    ASMPYTHON_CODEGEN.write_text(codegen_source, encoding="utf-8")
+    sema_path.write_text(sema_source, encoding="utf-8")
+    codegen_path.write_text(codegen_source, encoding="utf-8")
 
     importlib.invalidate_caches()
     reloaded_sema = importlib.reload(asmpython_sema)
     reloaded_codegen = importlib.reload(asmpython_codegen)
     if "ascii" not in reloaded_sema.BUILTINS:
-        raise RuntimeError(f"ascii was not enabled in active sema module: {ASMPYTHON_SEMA}")
+        raise RuntimeError(f"ascii was not enabled in active sema module: {sema_path}")
     missing_exceptions = sorted(
         set(_PORTAPY_EXCEPTION_PARENTS) - set(reloaded_sema.BUILTIN_EXCEPTIONS)
     )
@@ -195,14 +201,15 @@ def _enable_compiler_builtins() -> None:
             f"codegen_exceptions={missing_codegen_exceptions}, "
             f"codegen_types={missing_codegen_types}"
         )
-    print("ASMPYTHON SEMA PATH", ASMPYTHON_SEMA)
-    print("ASMPYTHON CODEGEN PATH", ASMPYTHON_CODEGEN)
+    print("ASMPYTHON SEMA PATH", sema_path)
+    print("ASMPYTHON CODEGEN PATH", codegen_path)
     print("ENABLED ASMPYTHON ASCII BUILTIN", reloaded_sema.BUILTINS["ascii"])
     print(
         "ENABLED PORTAPY COMPILER SYMBOLS",
         len(_PORTAPY_EXCEPTION_IDS),
         len(_PORTAPY_TYPE_IDS),
     )
+    return stdlib
 
 
 def main() -> int:
@@ -259,12 +266,12 @@ def main() -> int:
     print("REPLACED FRONTEND ASCII CONVERSIONS", frontend_ascii_conversion_count)
 
     _normalize_ascii_file(BYTECODE_PATH, "BYTECODE")
+    stdlib = _enable_compiler_builtins()
     for name in ("dataclasses.py", "enum.py", "types.py"):
-        path = ASMPYTHON_STDLIB / name
+        path = stdlib / name
         if not path.is_file():
             raise RuntimeError(f"missing asmpython stdlib source: {path}")
         _normalize_ascii_file(path, f"ASMPYTHON {name}")
-    _enable_compiler_builtins()
     return 0
 
 

From 66a6db75101edd1ba94f949afb9a878f78fcd2e5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:56:05 -0500
Subject: [PATCH 058/450] Use native-safe error formatting in full Runtime ABI

---
 tools/normalize_full_reference_abi_helpers.py | 60 ++++++++++++++++++-
 1 file changed, 58 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 2b2ed84a..c35875d0 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -106,7 +106,32 @@ def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     )
 
 
+def _is_traceback_format_join(node: ast.AST) -> bool:
+    """Return True for ``"".join(traceback.format_exception(error))``."""
+    if not isinstance(node, ast.Call) or len(node.args) != 1 or node.keywords:
+        return False
+    if not isinstance(node.func, ast.Attribute) or node.func.attr != "join":
+        return False
+    if not isinstance(node.func.value, ast.Constant) or node.func.value.value != "":
+        return False
+    inner = node.args[0]
+    return (
+        isinstance(inner, ast.Call)
+        and len(inner.args) == 1
+        and not inner.keywords
+        and isinstance(inner.func, ast.Attribute)
+        and inner.func.attr == "format_exception"
+        and isinstance(inner.func.value, ast.Name)
+        and inner.func.value.id == "traceback"
+        and isinstance(inner.args[0], ast.Name)
+        and inner.args[0].id == "error"
+    )
+
+
 class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.traceback_rewrites = 0
+
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
         if node.name in _DROP:
             return None
@@ -143,10 +168,29 @@ def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
             return ast.copy_location(values[0], node)
         return ast.copy_location(ast.BoolOp(op=node.op, values=values), node)
 
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if _is_traceback_format_join(node):
+            self.traceback_rewrites += 1
+            return ast.copy_location(
+                ast.Call(
+                    func=ast.Name(id="str", ctx=ast.Load()),
+                    args=[ast.Name(id="error", ctx=ast.Load())],
+                    keywords=[],
+                ),
+                node,
+            )
+        return self.generic_visit(node)
+
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
-    module = _Rewrite().visit(module)
+    rewrite = _Rewrite()
+    module = rewrite.visit(module)
+    if rewrite.traceback_rewrites != 1:
+        raise RuntimeError(
+            "full Runtime traceback normalization failed: "
+            f"expected 1 call, found {rewrite.traceback_rewrites}"
+        )
     if any(
         isinstance(node, ast.ClassDef) and node.name == "_PortaPyImportLoader"
         for node in module.body
@@ -175,6 +219,9 @@ def main() -> int:
         for node in ast.walk(verified)
         if _is_utf8_source_upper_bound(node)
     ]
+    stale_tracebacks = [
+        node for node in ast.walk(verified) if _is_traceback_format_join(node)
+    ]
     runtime_create = next(
         (
             node
@@ -190,11 +237,19 @@ def main() -> int:
         and "__pyinbin_import__" in runtime_create_text
     )
     builtins_ready = "_seed_builtins" in runtime_create_text
-    if missing or stale or unsafe_spans or not loader_ready or not builtins_ready:
+    if (
+        missing
+        or stale
+        or unsafe_spans
+        or stale_tracebacks
+        or not loader_ready
+        or not builtins_ready
+    ):
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
+            f"stale_tracebacks={len(stale_tracebacks)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}"
         )
     print(
@@ -203,6 +258,7 @@ def main() -> int:
         len(_DROP),
         "BUILTINS",
         "IMPORT_LOADER",
+        "TRACEBACK",
     )
     return 0
 

From 95cbef8ad7189f5feec3fcdf96f3e99a95e9a5ef Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:56:36 -0500
Subject: [PATCH 059/450] Test native-safe full Runtime error formatting

---
 tests/test_full_reference_abi_normalization.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 6c65a9b6..c06cca21 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -27,6 +27,15 @@ def test_full_reference_normalization_installs_runtime_support(
     }
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
+    assert "traceback.format_exception" not in source
+
+    capture = next(
+        node
+        for node in ast.walk(module)
+        if isinstance(node, ast.FunctionDef) and node.name == "_capture"
+    )
+    capture_source = ast.unparse(capture)
+    assert "str(error)" in capture_source
 
     runtime_create = next(
         node

From 6afdb92104e2e1c820652b97bbe9fc396de45bc5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:56:37 -0500
Subject: [PATCH 060/450] Normalize native reference error capture

---
 tools/normalize_full_reference_runtime.py | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 tools/normalize_full_reference_runtime.py

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
new file mode 100644
index 00000000..f6ae47b2
--- /dev/null
+++ b/tools/normalize_full_reference_runtime.py
@@ -0,0 +1,33 @@
+"""Remove host-only traceback formatting from the native reference runtime."""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/reference_api.py")
+
+_TRACEBACK_IMPORT = "import traceback\n"
+_TRACEBACK_FORMAT = '            "".join(traceback.format_exception(error)),\n'
+_NATIVE_FORMAT = (
+    '            type(error).__name__ + ": " + str(error),\n'
+)
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    import_count = source.count(_TRACEBACK_IMPORT)
+    format_count = source.count(_TRACEBACK_FORMAT)
+    if import_count != 1 or format_count != 1:
+        raise RuntimeError(
+            "native reference traceback normalization expected one import and "
+            f"one formatter; imports={import_count}, formatters={format_count}"
+        )
+    source = source.replace(_TRACEBACK_IMPORT, "", 1)
+    source = source.replace(_TRACEBACK_FORMAT, _NATIVE_FORMAT, 1)
+    PATH.write_text(source, encoding="utf-8")
+    print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", format_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 4d6f8a01f26216420ed58c7824bf98326a14b749 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:57:06 -0500
Subject: [PATCH 061/450] Include native reference error normalization

---
 tools/normalize_full_core_validation.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 6160880a..1b71a145 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -26,6 +26,9 @@
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_runtime import (
+    main as normalize_reference_runtime,
+)
 
 
 BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
@@ -64,13 +67,12 @@ def _normalize_opcode_validation() -> None:
 
 
 def main() -> int:
-    # These four passes were historically run only by the probe workflow.
-    # Keeping them here makes clean production builds use the same proven
-    # compiler-safe source preparation as the full-core transition probe.
+    # These passes prepare the source modules imported by the generated entry.
     normalize_probe()
     normalize_lambdas()
     normalize_native_semantics()
     normalize_opcode_maps()
+    normalize_reference_runtime()
 
     materialize_reference_entry()
     normalize_reference_abi_helpers()

From 47cb18b6521ce2fa2d9babd67f8ab890e462bc49 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 15:57:18 -0500
Subject: [PATCH 062/450] Test native reference error normalization

---
 .../test_normalize_full_reference_runtime.py  | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_runtime.py

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
new file mode 100644
index 00000000..ae8dafc7
--- /dev/null
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from tools import normalize_full_reference_runtime as normalizer
+
+
+def test_replaces_host_traceback_formatter(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "reference_api.py"
+    path.write_text(
+        "import traceback\n"
+        "def capture(error):\n"
+        "    return ErrorInfo(\n"
+        '            "".join(traceback.format_exception(error)),\n'
+        "    )\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+    assert normalizer.main() == 0
+    result = path.read_text(encoding="utf-8")
+    assert "import traceback" not in result
+    assert "format_exception" not in result
+    assert 'type(error).__name__ + ": " + str(error)' in result
+
+
+def test_rejects_unexpected_traceback_shape(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "reference_api.py"
+    path.write_text("import traceback\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+    with pytest.raises(RuntimeError, match="one import and one formatter"):
+        normalizer.main()

From fe4f8998f854df9ddc97763838a3960db8be3a8a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:00:24 -0500
Subject: [PATCH 063/450] Keep traceback normalization on reference source

---
 tools/normalize_full_reference_abi_helpers.py | 60 +------------------
 1 file changed, 2 insertions(+), 58 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index c35875d0..2b2ed84a 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -106,32 +106,7 @@ def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     )
 
 
-def _is_traceback_format_join(node: ast.AST) -> bool:
-    """Return True for ``"".join(traceback.format_exception(error))``."""
-    if not isinstance(node, ast.Call) or len(node.args) != 1 or node.keywords:
-        return False
-    if not isinstance(node.func, ast.Attribute) or node.func.attr != "join":
-        return False
-    if not isinstance(node.func.value, ast.Constant) or node.func.value.value != "":
-        return False
-    inner = node.args[0]
-    return (
-        isinstance(inner, ast.Call)
-        and len(inner.args) == 1
-        and not inner.keywords
-        and isinstance(inner.func, ast.Attribute)
-        and inner.func.attr == "format_exception"
-        and isinstance(inner.func.value, ast.Name)
-        and inner.func.value.id == "traceback"
-        and isinstance(inner.args[0], ast.Name)
-        and inner.args[0].id == "error"
-    )
-
-
 class _Rewrite(ast.NodeTransformer):
-    def __init__(self) -> None:
-        self.traceback_rewrites = 0
-
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
         if node.name in _DROP:
             return None
@@ -168,29 +143,10 @@ def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
             return ast.copy_location(values[0], node)
         return ast.copy_location(ast.BoolOp(op=node.op, values=values), node)
 
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        if _is_traceback_format_join(node):
-            self.traceback_rewrites += 1
-            return ast.copy_location(
-                ast.Call(
-                    func=ast.Name(id="str", ctx=ast.Load()),
-                    args=[ast.Name(id="error", ctx=ast.Load())],
-                    keywords=[],
-                ),
-                node,
-            )
-        return self.generic_visit(node)
-
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
-    rewrite = _Rewrite()
-    module = rewrite.visit(module)
-    if rewrite.traceback_rewrites != 1:
-        raise RuntimeError(
-            "full Runtime traceback normalization failed: "
-            f"expected 1 call, found {rewrite.traceback_rewrites}"
-        )
+    module = _Rewrite().visit(module)
     if any(
         isinstance(node, ast.ClassDef) and node.name == "_PortaPyImportLoader"
         for node in module.body
@@ -219,9 +175,6 @@ def main() -> int:
         for node in ast.walk(verified)
         if _is_utf8_source_upper_bound(node)
     ]
-    stale_tracebacks = [
-        node for node in ast.walk(verified) if _is_traceback_format_join(node)
-    ]
     runtime_create = next(
         (
             node
@@ -237,19 +190,11 @@ def main() -> int:
         and "__pyinbin_import__" in runtime_create_text
     )
     builtins_ready = "_seed_builtins" in runtime_create_text
-    if (
-        missing
-        or stale
-        or unsafe_spans
-        or stale_tracebacks
-        or not loader_ready
-        or not builtins_ready
-    ):
+    if missing or stale or unsafe_spans or not loader_ready or not builtins_ready:
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
-            f"stale_tracebacks={len(stale_tracebacks)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}"
         )
     print(
@@ -258,7 +203,6 @@ def main() -> int:
         len(_DROP),
         "BUILTINS",
         "IMPORT_LOADER",
-        "TRACEBACK",
     )
     return 0
 

From 34bab80f018e4296ab2ed4be6a881df9d2f6147d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:00:35 -0500
Subject: [PATCH 064/450] Test ABI helper normalization independently

---
 tests/test_full_reference_abi_normalization.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index c06cca21..6c65a9b6 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -27,15 +27,6 @@ def test_full_reference_normalization_installs_runtime_support(
     }
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
-    assert "traceback.format_exception" not in source
-
-    capture = next(
-        node
-        for node in ast.walk(module)
-        if isinstance(node, ast.FunctionDef) and node.name == "_capture"
-    )
-    capture_source = ast.unparse(capture)
-    assert "str(error)" in capture_source
 
     runtime_create = next(
         node

From c9f09677de073a31f9c73d77a73d81db70258a67 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:06:08 -0500
Subject: [PATCH 065/450] Link Linux standalone runtime against libm

---
 tools/build_native.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tools/build_native.py b/tools/build_native.py
index cb248333..ad0afc8b 100644
--- a/tools/build_native.py
+++ b/tools/build_native.py
@@ -263,6 +263,7 @@ def build_native(
             "-shared",
             *link_objects,
             f"-Wl,--version-script={version_script}",
+            "-lm",
             "-o",
             str(output),
         ]

From fb961f12198a24893ece236ace68d41a0a5305af Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:06:40 -0500
Subject: [PATCH 066/450] Link the standalone Linux runtime with libm

---
 tools/build_native_host_calls.py | 38 +++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/tools/build_native_host_calls.py b/tools/build_native_host_calls.py
index 82f94a39..7d8c4c04 100644
--- a/tools/build_native_host_calls.py
+++ b/tools/build_native_host_calls.py
@@ -76,6 +76,30 @@ def _compile_bridge_glue(
     _run(command, log=log)
 
 
+def _linux_link_command(
+    *,
+    gcc: str,
+    objects: list[str],
+    version_script: Path,
+    output: Path,
+) -> list[str]:
+    """Return a self-contained ELF shared-library link command.
+
+    asmpython emits calls to ``pow`` for Python exponentiation. ``libportapy.so``
+    must therefore declare its own libm dependency rather than relying on the
+    embedding process to have loaded libm globally already.
+    """
+    return [
+        gcc,
+        "-shared",
+        *objects,
+        f"-Wl,--version-script={version_script}",
+        "-lm",
+        "-o",
+        str(output),
+    ]
+
+
 def _upgrade_linked_artifact(
     *,
     target: str,
@@ -179,14 +203,12 @@ def _upgrade_linked_artifact(
             linux_version_script(host_bridge=True, host_calls=True),
             encoding="utf-8",
         )
-        command = [
-            gcc,
-            "-shared",
-            *objects,
-            f"-Wl,--version-script={version_script}",
-            "-o",
-            str(output),
-        ]
+        command = _linux_link_command(
+            gcc=gcc,
+            objects=objects,
+            version_script=version_script,
+            output=output,
+        )
     else:
         definition = work_dir / "portapy-host-calls.def"
         definition.write_text(

From 605f5e3ee2e309cf06969d6b4e7d8b50a3d650bb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:06:59 -0500
Subject: [PATCH 067/450] Test standalone Linux math linkage

---
 tests/test_build_native_host_calls.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 tests/test_build_native_host_calls.py

diff --git a/tests/test_build_native_host_calls.py b/tests/test_build_native_host_calls.py
new file mode 100644
index 00000000..c95ccd83
--- /dev/null
+++ b/tests/test_build_native_host_calls.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools.build_native_host_calls import _linux_link_command
+
+
+def test_linux_shared_library_links_its_math_dependency() -> None:
+    command = _linux_link_command(
+        gcc="gcc",
+        objects=["runtime.o", "glue.o"],
+        version_script=Path("portapy.map"),
+        output=Path("libportapy.so"),
+    )
+
+    assert command == [
+        "gcc",
+        "-shared",
+        "runtime.o",
+        "glue.o",
+        "-Wl,--version-script=portapy.map",
+        "-lm",
+        "-o",
+        "libportapy.so",
+    ]

From 625b5e7fd1653b9b589568aae1d9e159bc1283d8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:09:45 -0500
Subject: [PATCH 068/450] Add focused Windows native build diagnostics

---
 .github/workflows/native-build-diagnostic.yml | 78 +++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 41cae7b1..0b512faa 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -85,3 +85,81 @@ jobs:
         run: |
           printf '%s\n' "$BUILD_REPORT"
           exit "$BUILD_STATUS"
+
+  build-windows:
+    runs-on: windows-2022
+    outputs:
+      status: ${{ steps.build.outputs.status }}
+      report: ${{ steps.build.outputs.report }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install quietly
+        shell: powershell
+        run: |
+          $installLog = Join-Path $env:RUNNER_TEMP 'portapy-install-windows.log'
+          choco install nasm mingw -y --no-progress *> $installLog
+          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
+          python -m pip install -e '.[test]' *>> $installLog
+          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
+          python -m pip install --no-cache-dir --force-reinstall `
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1' `
+            *>> $installLog
+          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
+      - name: Capture compiler diagnostic
+        id: build
+        shell: powershell
+        run: |
+          $buildLog = Join-Path $env:RUNNER_TEMP 'portapy-build-windows.log'
+          $reportLog = Join-Path $env:RUNNER_TEMP 'portapy-report-windows.log'
+          $output = Join-Path $env:RUNNER_TEMP 'portapy.dll'
+          $workDir = Join-Path $env:RUNNER_TEMP 'portapy-build-windows'
+          python tools/build_native_typed.py `
+            --target windows `
+            --output $output `
+            --work-dir $workDir `
+            *> $buildLog
+          $status = $LASTEXITCODE
+          $lines = Get-Content $buildLog
+          $errorLines = $lines | Select-String -Pattern 'error|failed|failure|unsupported|traceback|exception|undefined|invalid'
+          @(
+            '=== FIRST 35 LINES ==='
+            $lines | Select-Object -First 35
+            ''
+            '=== ERROR-LIKE LINES ==='
+            $errorLines | Select-Object -Last 120
+            ''
+            '=== FINAL 120 LINES ==='
+            $lines | Select-Object -Last 120
+          ) | Set-Content -Encoding utf8 $reportLog
+          "status=$status" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          'report<<PORTAPY_BUILD_REPORT' | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          Get-Content $reportLog | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          'PORTAPY_BUILD_REPORT' | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          exit 0
+      - name: Upload Windows compiler diagnostic
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: native-build-diagnostic-windows
+          path: |
+            ${{ runner.temp }}/portapy-build-windows.log
+            ${{ runner.temp }}/portapy-report-windows.log
+            ${{ runner.temp }}/portapy-build-windows
+            ${{ runner.temp }}/portapy.dll
+            ${{ runner.temp }}/portapy.dll.json
+
+  report-windows:
+    needs: build-windows
+    runs-on: windows-2022
+    steps:
+      - name: Report compiler diagnostic
+        env:
+          BUILD_REPORT: ${{ needs.build-windows.outputs.report }}
+          BUILD_STATUS: ${{ needs.build-windows.outputs.status }}
+        shell: powershell
+        run: |
+          Write-Host $env:BUILD_REPORT
+          exit [int]$env:BUILD_STATUS

From 3ee07d567568b124c7c49ef30570e659cac22e7a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:12:16 -0500
Subject: [PATCH 069/450] Use string keys for native value handles

---
 tools/normalize_full_reference_runtime.py | 81 ++++++++++++++++++++---
 1 file changed, 70 insertions(+), 11 deletions(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index f6ae47b2..5e84ab85 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -1,4 +1,4 @@
-"""Remove host-only traceback formatting from the native reference runtime."""
+"""Normalize host-only features in the native reference runtime."""
 from __future__ import annotations
 
 from pathlib import Path
@@ -11,21 +11,80 @@
 _NATIVE_FORMAT = (
     '            type(error).__name__ + ": " + str(error),\n'
 )
+_VALUES_ANNOTATION = "self._values: dict[int, _Slot] = {}"
+_NATIVE_VALUES_ANNOTATION = "self._values: dict[str, _Slot] = {}"
+_HANDLE_SUBSCRIPT = "self._values[handle]"
+_NATIVE_HANDLE_SUBSCRIPT = "self._values[str(handle)]"
+_HANDLE_GET = "self._values.get(handle)"
+_NATIVE_HANDLE_GET = "self._values.get(str(handle))"
+_CALLABLE_HANDLE_GET = "self._values.get(callable_handle)"
+_NATIVE_CALLABLE_HANDLE_GET = "self._values.get(str(callable_handle))"
 
 
-def main() -> int:
-    source = PATH.read_text(encoding="utf-8")
-    import_count = source.count(_TRACEBACK_IMPORT)
-    format_count = source.count(_TRACEBACK_FORMAT)
-    if import_count != 1 or format_count != 1:
+def _replace_exact(
+    source: str,
+    old: str,
+    new: str,
+    *,
+    label: str,
+    expected: int,
+) -> str:
+    count = source.count(old)
+    if count != expected:
         raise RuntimeError(
-            "native reference traceback normalization expected one import and "
-            f"one formatter; imports={import_count}, formatters={format_count}"
+            f"native reference {label} normalization expected {expected} matches, "
+            f"found {count}"
         )
-    source = source.replace(_TRACEBACK_IMPORT, "", 1)
-    source = source.replace(_TRACEBACK_FORMAT, _NATIVE_FORMAT, 1)
+    return source.replace(old, new)
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    source = _replace_exact(
+        source,
+        _TRACEBACK_IMPORT,
+        "",
+        label="traceback import",
+        expected=1,
+    )
+    source = _replace_exact(
+        source,
+        _TRACEBACK_FORMAT,
+        _NATIVE_FORMAT,
+        label="traceback formatter",
+        expected=1,
+    )
+    source = _replace_exact(
+        source,
+        _VALUES_ANNOTATION,
+        _NATIVE_VALUES_ANNOTATION,
+        label="value-table annotation",
+        expected=1,
+    )
+    source = _replace_exact(
+        source,
+        _HANDLE_SUBSCRIPT,
+        _NATIVE_HANDLE_SUBSCRIPT,
+        label="value-table subscript",
+        expected=2,
+    )
+    source = _replace_exact(
+        source,
+        _HANDLE_GET,
+        _NATIVE_HANDLE_GET,
+        label="value-table lookup",
+        expected=8,
+    )
+    source = _replace_exact(
+        source,
+        _CALLABLE_HANDLE_GET,
+        _NATIVE_CALLABLE_HANDLE_GET,
+        label="callable value-table lookup",
+        expected=1,
+    )
     PATH.write_text(source, encoding="utf-8")
-    print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", format_count)
+    print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", 1)
+    print("NORMALIZED NATIVE VALUE HANDLE KEYS", 11)
     return 0
 
 

From ac710bdfd71765f8663f85c55c96407f3335cb93 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:12:39 -0500
Subject: [PATCH 070/450] Test native string-keyed handle tables

---
 .../test_normalize_full_reference_runtime.py  | 48 ++++++++++++++-----
 1 file changed, 37 insertions(+), 11 deletions(-)

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
index ae8dafc7..9fc37562 100644
--- a/tests/test_normalize_full_reference_runtime.py
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -7,31 +7,57 @@
 from tools import normalize_full_reference_runtime as normalizer
 
 
-def test_replaces_host_traceback_formatter(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    path = tmp_path / "reference_api.py"
-    path.write_text(
+def _reference_source() -> str:
+    return (
         "import traceback\n"
-        "def capture(error):\n"
-        "    return ErrorInfo(\n"
+        "class Runtime:\n"
+        "    def __init__(self):\n"
+        "        self._values: dict[int, _Slot] = {}\n"
+        "    def capture(self, error):\n"
+        "        return ErrorInfo(\n"
         '            "".join(traceback.format_exception(error)),\n'
-        "    )\n",
-        encoding="utf-8",
+        "        )\n"
+        "    def store(self, handle, value):\n"
+        "        self._values[handle] = value\n"
+        "    def remove(self, handle):\n"
+        "        del self._values[handle]\n"
+        "    def lookup1(self, handle): return self._values.get(handle)\n"
+        "    def lookup2(self, handle): return self._values.get(handle)\n"
+        "    def lookup3(self, handle): return self._values.get(handle)\n"
+        "    def lookup4(self, handle): return self._values.get(handle)\n"
+        "    def lookup5(self, handle): return self._values.get(handle)\n"
+        "    def lookup6(self, handle): return self._values.get(handle)\n"
+        "    def lookup7(self, handle): return self._values.get(handle)\n"
+        "    def lookup8(self, handle): return self._values.get(handle)\n"
+        "    def callable(self, callable_handle):\n"
+        "        return self._values.get(callable_handle)\n"
     )
+
+
+def test_replaces_host_tracebacks_and_integer_handle_keys(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "reference_api.py"
+    path.write_text(_reference_source(), encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
+
     assert normalizer.main() == 0
+
     result = path.read_text(encoding="utf-8")
     assert "import traceback" not in result
     assert "format_exception" not in result
     assert 'type(error).__name__ + ": " + str(error)' in result
+    assert "dict[str, _Slot]" in result
+    assert result.count("self._values[str(handle)]") == 2
+    assert result.count("self._values.get(str(handle))") == 8
+    assert result.count("self._values.get(str(callable_handle))") == 1
 
 
-def test_rejects_unexpected_traceback_shape(
+def test_rejects_unexpected_reference_runtime_shape(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     path = tmp_path / "reference_api.py"
     path.write_text("import traceback\n", encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
-    with pytest.raises(RuntimeError, match="one import and one formatter"):
+    with pytest.raises(RuntimeError, match="traceback formatter normalization"):
         normalizer.main()

From 60a463c123a37ef64e9ed18f321533b90ed9b6ef Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:21:59 -0500
Subject: [PATCH 071/450] Track native value kinds on handles

---
 tools/normalize_full_reference_runtime.py | 180 +++++++++++++++++++---
 1 file changed, 160 insertions(+), 20 deletions(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index 5e84ab85..349de7bc 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -11,6 +11,152 @@
 _NATIVE_FORMAT = (
     '            type(error).__name__ + ": " + str(error),\n'
 )
+_SLOT = '''@dataclass
+class _Slot:
+    value: object
+    refs: int = 1
+'''
+_NATIVE_SLOT = '''@dataclass
+class _Slot:
+    value: object
+    kind: ValueKind = ValueKind.INT
+    refs: int = 1
+'''
+_STORE = '''    def _store(self, value: object) -> int:
+        handle = self._next
+        self._next += 1
+        self._values[handle] = _Slot(value)
+        return handle
+'''
+_NATIVE_STORE = '''    def _store(
+        self,
+        value: object,
+        kind: ValueKind = ValueKind.INT,
+    ) -> int:
+        handle = self._next
+        self._next += 1
+        self._values[handle] = _Slot(value, kind)
+        return handle
+'''
+_BOX_METHODS = '''    def box_none(self) -> tuple[Status, int]:
+        return Status.OK, self._store(None)
+
+    def box_bool(self, value: bool) -> tuple[Status, int]:
+        return Status.OK, self._store(value)
+
+    def box_int(self, value: int) -> tuple[Status, int]:
+        return Status.OK, self._store(value)
+
+    def box_float(self, value: float) -> tuple[Status, int]:
+        return Status.OK, self._store(value)
+
+    def box_utf8(self, value: str) -> tuple[Status, int]:
+        return Status.OK, self._store(value)
+
+    def box_bytes(self, value: bytes) -> tuple[Status, int]:
+        return Status.OK, self._store(value)
+'''
+_NATIVE_BOX_METHODS = '''    def box_none(self) -> tuple[Status, int]:
+        return Status.OK, self._store(None, ValueKind.NONE)
+
+    def box_bool(self, value: bool) -> tuple[Status, int]:
+        return Status.OK, self._store(value, ValueKind.BOOL)
+
+    def box_int(self, value: int) -> tuple[Status, int]:
+        return Status.OK, self._store(value, ValueKind.INT)
+
+    def box_float(self, value: float) -> tuple[Status, int]:
+        return Status.OK, self._store(value, ValueKind.FLOAT)
+
+    def box_utf8(self, value: str) -> tuple[Status, int]:
+        return Status.OK, self._store(value, ValueKind.STRING)
+
+    def box_bytes(self, value: bytes) -> tuple[Status, int]:
+        return Status.OK, self._store(value, ValueKind.BYTES)
+'''
+_VALUE_KIND_METHOD = '''    def value_kind(self, handle: int) -> tuple[Status, ValueKind]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), ValueKind.OBJECT
+        value = slot.value
+        if value is None:
+            kind = ValueKind.NONE
+        elif type(value) is bool:
+            kind = ValueKind.BOOL
+        elif type(value) is int:
+            kind = ValueKind.INT
+        elif type(value) is float:
+            kind = ValueKind.FLOAT
+        elif type(value) is str:
+            kind = ValueKind.STRING
+        elif type(value) is bytes:
+            kind = ValueKind.BYTES
+        elif type(value) is tuple:
+            kind = ValueKind.TUPLE
+        elif type(value) is dict:
+            kind = ValueKind.DICT
+        elif type(value) is list:
+            kind = ValueKind.LIST
+        elif callable(value):
+            kind = ValueKind.CALLABLE
+        else:
+            kind = ValueKind.OBJECT
+        return Status.OK, kind
+'''
+_NATIVE_VALUE_KIND_METHOD = '''    def value_kind(self, handle: int) -> tuple[Status, ValueKind]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), ValueKind.OBJECT
+        return Status.OK, slot.kind
+'''
+_AS_INT_METHOD = '''    def as_int(self, handle: int) -> tuple[Status, int]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0
+        if type(slot.value) is not int:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not int")), 0
+        return Status.OK, slot.value
+'''
+_NATIVE_AS_INT_METHOD = '''    def as_int(self, handle: int) -> tuple[Status, int]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0
+        if slot.kind is not ValueKind.INT:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not int")), 0
+        return Status.OK, slot.value
+'''
+_AS_FLOAT_METHOD = '''    def as_float(self, handle: int) -> tuple[Status, float]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0.0
+        if type(slot.value) is not float:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not float")), 0.0
+        return Status.OK, slot.value
+'''
+_NATIVE_AS_FLOAT_METHOD = '''    def as_float(self, handle: int) -> tuple[Status, float]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0.0
+        if slot.kind is not ValueKind.FLOAT:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not float")), 0.0
+        return Status.OK, slot.value
+'''
+_AS_UTF8_METHOD = '''    def as_utf8(self, handle: int) -> tuple[Status, bytes]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), b""
+        if type(slot.value) is not str:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not str")), b""
+        return Status.OK, slot.value.encode("utf-8")
+'''
+_NATIVE_AS_UTF8_METHOD = '''    def as_utf8(self, handle: int) -> tuple[Status, bytes]:
+        slot = self._values.get(handle)
+        if slot is None:
+            return self._capture(Status.INVALID_HANDLE, KeyError(handle)), b""
+        if slot.kind is not ValueKind.STRING:
+            return self._capture(Status.TYPE_ERROR, TypeError("value is not str")), b""
+        return Status.OK, slot.value.encode("utf-8")
+'''
 _VALUES_ANNOTATION = "self._values: dict[int, _Slot] = {}"
 _NATIVE_VALUES_ANNOTATION = "self._values: dict[str, _Slot] = {}"
 _HANDLE_SUBSCRIPT = "self._values[handle]"
@@ -40,27 +186,20 @@ def _replace_exact(
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    source = _replace_exact(
-        source,
-        _TRACEBACK_IMPORT,
-        "",
-        label="traceback import",
-        expected=1,
-    )
-    source = _replace_exact(
-        source,
-        _TRACEBACK_FORMAT,
-        _NATIVE_FORMAT,
-        label="traceback formatter",
-        expected=1,
-    )
-    source = _replace_exact(
-        source,
-        _VALUES_ANNOTATION,
-        _NATIVE_VALUES_ANNOTATION,
-        label="value-table annotation",
-        expected=1,
+    replacements = (
+        (_TRACEBACK_IMPORT, "", "traceback import"),
+        (_TRACEBACK_FORMAT, _NATIVE_FORMAT, "traceback formatter"),
+        (_SLOT, _NATIVE_SLOT, "value slot"),
+        (_STORE, _NATIVE_STORE, "value store"),
+        (_BOX_METHODS, _NATIVE_BOX_METHODS, "scalar boxing"),
+        (_VALUE_KIND_METHOD, _NATIVE_VALUE_KIND_METHOD, "value kind"),
+        (_AS_INT_METHOD, _NATIVE_AS_INT_METHOD, "integer conversion"),
+        (_AS_FLOAT_METHOD, _NATIVE_AS_FLOAT_METHOD, "float conversion"),
+        (_AS_UTF8_METHOD, _NATIVE_AS_UTF8_METHOD, "UTF-8 conversion"),
+        (_VALUES_ANNOTATION, _NATIVE_VALUES_ANNOTATION, "value-table annotation"),
     )
+    for old, new, label in replacements:
+        source = _replace_exact(source, old, new, label=label, expected=1)
     source = _replace_exact(
         source,
         _HANDLE_SUBSCRIPT,
@@ -85,6 +224,7 @@ def main() -> int:
     PATH.write_text(source, encoding="utf-8")
     print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", 1)
     print("NORMALIZED NATIVE VALUE HANDLE KEYS", 11)
+    print("NORMALIZED NATIVE VALUE KIND SLOTS", 9)
     return 0
 
 

From 17da49d83f41a3067781fa886e119b6ebb4d8e49 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:23:22 -0500
Subject: [PATCH 072/450] Test native value kind normalization

---
 .../test_normalize_full_reference_runtime.py  | 52 ++++++++-----------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
index 9fc37562..1ed47f84 100644
--- a/tests/test_normalize_full_reference_runtime.py
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -7,38 +7,14 @@
 from tools import normalize_full_reference_runtime as normalizer
 
 
-def _reference_source() -> str:
-    return (
-        "import traceback\n"
-        "class Runtime:\n"
-        "    def __init__(self):\n"
-        "        self._values: dict[int, _Slot] = {}\n"
-        "    def capture(self, error):\n"
-        "        return ErrorInfo(\n"
-        '            "".join(traceback.format_exception(error)),\n'
-        "        )\n"
-        "    def store(self, handle, value):\n"
-        "        self._values[handle] = value\n"
-        "    def remove(self, handle):\n"
-        "        del self._values[handle]\n"
-        "    def lookup1(self, handle): return self._values.get(handle)\n"
-        "    def lookup2(self, handle): return self._values.get(handle)\n"
-        "    def lookup3(self, handle): return self._values.get(handle)\n"
-        "    def lookup4(self, handle): return self._values.get(handle)\n"
-        "    def lookup5(self, handle): return self._values.get(handle)\n"
-        "    def lookup6(self, handle): return self._values.get(handle)\n"
-        "    def lookup7(self, handle): return self._values.get(handle)\n"
-        "    def lookup8(self, handle): return self._values.get(handle)\n"
-        "    def callable(self, callable_handle):\n"
-        "        return self._values.get(callable_handle)\n"
-    )
-
-
-def test_replaces_host_tracebacks_and_integer_handle_keys(
+REFERENCE_SOURCE = Path("src/portapy/reference_api.py")
+
+
+def test_normalizes_real_reference_runtime(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     path = tmp_path / "reference_api.py"
-    path.write_text(_reference_source(), encoding="utf-8")
+    path.write_text(REFERENCE_SOURCE.read_text(encoding="utf-8"), encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     assert normalizer.main() == 0
@@ -47,10 +23,26 @@ def test_replaces_host_tracebacks_and_integer_handle_keys(
     assert "import traceback" not in result
     assert "format_exception" not in result
     assert 'type(error).__name__ + ": " + str(error)' in result
+
     assert "dict[str, _Slot]" in result
-    assert result.count("self._values[str(handle)]") == 2
+    assert "kind: ValueKind = ValueKind.INT" in result
+    assert "self._values[str(handle)] = _Slot(value, kind)" in result
     assert result.count("self._values.get(str(handle))") == 8
     assert result.count("self._values.get(str(callable_handle))") == 1
+    assert "del self._values[str(handle)]" in result
+
+    assert "self._store(None, ValueKind.NONE)" in result
+    assert "self._store(value, ValueKind.BOOL)" in result
+    assert "self._store(value, ValueKind.INT)" in result
+    assert "self._store(value, ValueKind.FLOAT)" in result
+    assert "self._store(value, ValueKind.STRING)" in result
+    assert "self._store(value, ValueKind.BYTES)" in result
+
+    assert "return Status.OK, slot.kind" in result
+    assert "slot.kind is not ValueKind.INT" in result
+    assert "slot.kind is not ValueKind.FLOAT" in result
+    assert "slot.kind is not ValueKind.STRING" in result
+    assert "type(slot.value)" not in result
 
 
 def test_rejects_unexpected_reference_runtime_shape(

From c887525594c93721d13c95e063c5cc8be1724393 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:25:14 -0500
Subject: [PATCH 073/450] Normalize native traceback dictionary keys

---
 tools/normalize_full_core_tracebacks.py | 48 +++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 tools/normalize_full_core_tracebacks.py

diff --git a/tools/normalize_full_core_tracebacks.py b/tools/normalize_full_core_tracebacks.py
new file mode 100644
index 00000000..f2a0f256
--- /dev/null
+++ b/tools/normalize_full_core_tracebacks.py
@@ -0,0 +1,48 @@
+"""Use native-safe string keys for synthetic traceback storage."""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+
+_REPLACEMENTS = (
+    (
+        '        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}',
+        '        self._synthetic_tracebacks: dict[str, "_PyTBProxy"] = {}',
+        "traceback table annotation",
+    ),
+    (
+        "self._synthetic_tracebacks.get(id(target), target.__traceback__)",
+        "self._synthetic_tracebacks.get(str(id(target)), target.__traceback__)",
+        "traceback attribute lookup",
+    ),
+    (
+        "prior = self._synthetic_tracebacks.get(id(exc))",
+        "prior = self._synthetic_tracebacks.get(str(id(exc)))",
+        "traceback prior lookup",
+    ),
+    (
+        "self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)",
+        "self._synthetic_tracebacks[str(id(exc))] = _PyTBProxy(tb_frame, prior)",
+        "traceback storage",
+    ),
+)
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    for old, new, label in _REPLACEMENTS:
+        count = source.count(old)
+        if count != 1:
+            raise RuntimeError(
+                f"native {label}: expected one source form, found {count}"
+            )
+        source = source.replace(old, new, 1)
+    PATH.write_text(source, encoding="utf-8")
+    print("NORMALIZED NATIVE TRACEBACK KEYS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 50ca0a66ffe7a97a3b61eb5b5662037b5ee6bb38 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:25:27 -0500
Subject: [PATCH 074/450] Test native traceback key normalization

---
 tests/test_normalize_full_core_tracebacks.py | 47 ++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 tests/test_normalize_full_core_tracebacks.py

diff --git a/tests/test_normalize_full_core_tracebacks.py b/tests/test_normalize_full_core_tracebacks.py
new file mode 100644
index 00000000..16268e1a
--- /dev/null
+++ b/tests/test_normalize_full_core_tracebacks.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from tools import normalize_full_core_tracebacks as normalizer
+
+
+_SOURCE = '''class VirtualMachine:
+    def __init__(self) -> None:
+        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
+
+    def read(self, target):
+        return self._synthetic_tracebacks.get(id(target), target.__traceback__)
+
+    def write(self, exc, tb_frame):
+        prior = self._synthetic_tracebacks.get(id(exc))
+        self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
+'''
+
+
+def test_uses_string_keys_for_native_tracebacks(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    result = path.read_text(encoding="utf-8")
+    assert 'dict[str, "_PyTBProxy"]' in result
+    assert "get(str(id(target))" in result
+    assert "get(str(id(exc)))" in result
+    assert "[str(id(exc))]" in result
+    assert "[id(exc)]" not in result
+
+
+def test_rejects_missing_traceback_storage_shape(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text("class VirtualMachine: pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+    with pytest.raises(RuntimeError, match="traceback table annotation"):
+        normalizer.main()

From 95367ad2bbbdfa4bac592dc1c9931f2a73c65472 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:25:51 -0500
Subject: [PATCH 075/450] Normalize native traceback keys in full build

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 1b71a145..2fa188bd 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -23,6 +23,7 @@
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_probe import main as normalize_probe
+from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
@@ -85,6 +86,7 @@ def main() -> int:
     normalize_extended_semantics()
     normalize_collections()
     normalize_builtins()
+    normalize_tracebacks()
     _normalize_nested_code_introspection()
     _normalize_opcode_validation()
     return 0

From 48a604244574ee70e5faa3441aa36fff88441b3c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:29:05 -0500
Subject: [PATCH 076/450] Make Windows native toolchain setup resilient

---
 tools/install_windows_toolchain.ps1 | 81 +++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 tools/install_windows_toolchain.ps1

diff --git a/tools/install_windows_toolchain.ps1 b/tools/install_windows_toolchain.ps1
new file mode 100644
index 00000000..b44b7c47
--- /dev/null
+++ b/tools/install_windows_toolchain.ps1
@@ -0,0 +1,81 @@
+$ErrorActionPreference = 'Stop'
+
+function Add-ToolDirectory([string] $ExecutablePath) {
+    $directory = Split-Path -Parent $ExecutablePath
+    if (-not ($env:PATH -split ';' | Where-Object { $_ -eq $directory })) {
+        $env:PATH = "$directory;$env:PATH"
+        if ($env:GITHUB_PATH) {
+            $directory | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        }
+    }
+}
+
+function Find-Tool([string] $Name, [string[]] $Candidates) {
+    $command = Get-Command $Name -ErrorAction SilentlyContinue
+    if ($command) {
+        return $command.Source
+    }
+    foreach ($candidate in $Candidates) {
+        if (Test-Path $candidate) {
+            Add-ToolDirectory $candidate
+            return $candidate
+        }
+    }
+    return $null
+}
+
+function Install-ChocolateyPackage([string] $Package) {
+    $successCodes = @(0, 1641, 3010)
+    for ($attempt = 1; $attempt -le 3; $attempt += 1) {
+        Write-Host "Installing $Package with Chocolatey (attempt $attempt/3)"
+        & choco install $Package -y --no-progress --limit-output
+        $status = $LASTEXITCODE
+        if ($successCodes -contains $status) {
+            return
+        }
+        if ($attempt -lt 3) {
+            Start-Sleep -Seconds (10 * $attempt)
+        }
+    }
+    throw "Chocolatey could not install $Package (exit code $status)"
+}
+
+$nasmCandidates = @(
+    'C:\Program Files\NASM\nasm.exe',
+    'C:\ProgramData\chocolatey\bin\nasm.exe',
+    'C:\tools\nasm\nasm.exe'
+)
+$gccCandidates = @(
+    'C:\msys64\mingw64\bin\gcc.exe',
+    'C:\mingw64\bin\gcc.exe',
+    'C:\tools\mingw64\bin\gcc.exe',
+    'C:\ProgramData\mingw64\mingw64\bin\gcc.exe'
+)
+
+$nasm = Find-Tool 'nasm' $nasmCandidates
+if (-not $nasm) {
+    Install-ChocolateyPackage 'nasm'
+    $nasm = Find-Tool 'nasm' $nasmCandidates
+}
+if (-not $nasm) {
+    throw 'NASM was not found after installation'
+}
+
+$gcc = Find-Tool 'gcc' $gccCandidates
+if (-not $gcc) {
+    Install-ChocolateyPackage 'mingw'
+    $gcc = Find-Tool 'gcc' $gccCandidates
+}
+if (-not $gcc) {
+    throw 'MinGW GCC was not found after installation'
+}
+
+Add-ToolDirectory $nasm
+Add-ToolDirectory $gcc
+
+Write-Host "NASM: $nasm"
+& nasm -v
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "GCC: $gcc"
+& gcc --version
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

From a7c0024d95af5ceebdd67f98dce4e84e55a1bd9e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:29:33 -0500
Subject: [PATCH 077/450] Use resilient Windows toolchain setup

---
 .github/workflows/native-build-diagnostic.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 0b512faa..70ebe51e 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -100,7 +100,7 @@ jobs:
         shell: powershell
         run: |
           $installLog = Join-Path $env:RUNNER_TEMP 'portapy-install-windows.log'
-          choco install nasm mingw -y --no-progress *> $installLog
+          & .\tools\install_windows_toolchain.ps1 *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
           python -m pip install -e '.[test]' *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
@@ -145,6 +145,7 @@ jobs:
         with:
           name: native-build-diagnostic-windows
           path: |
+            ${{ runner.temp }}/portapy-install-windows.log
             ${{ runner.temp }}/portapy-build-windows.log
             ${{ runner.temp }}/portapy-report-windows.log
             ${{ runner.temp }}/portapy-build-windows

From a21e06c0dba4b7043b22d8fe4675441bc3b6ff14 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:30:06 -0500
Subject: [PATCH 078/450] Stabilize Windows release toolchain setup

---
 .github/workflows/release-3.14.0.yml | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index 1daf5d5c..be8c7c44 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -83,20 +83,24 @@ jobs:
       - name: Install package and native toolchain
         shell: powershell
         run: |
-          choco install nasm mingw -y --no-progress
+          & .\tools\install_windows_toolchain.ps1
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install -e '.[test]'
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install --no-cache-dir --force-reinstall `
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
       - name: Build full portapy.dll
         shell: powershell
         run: |
           New-Item -ItemType Directory -Force dist | Out-Null
-          python tools/build_native_typed.py `
+          $output = & python tools/build_native_typed.py `
             --target windows `
             --output dist/portapy.dll `
             --work-dir dist/build-windows `
-            2>&1 | Tee-Object -FilePath dist/build-windows.log
+            2>&1
           $buildStatus = $LASTEXITCODE
+          $output | Tee-Object -FilePath dist/build-windows.log
           if ($buildStatus -ne 0) { exit $buildStatus }
       - name: Validate Windows stable artifact
         shell: powershell

From 2ff08978ba2d06108aa6b9086f6dac25825f7c9c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:33:05 -0500
Subject: [PATCH 079/450] Route native type checks through tagged handles

---
 tools/normalize_full_reference_abi_helpers.py | 77 ++++++++++++++++++-
 1 file changed, 75 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 2b2ed84a..b93eeeff 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -81,6 +81,36 @@ def __call__(self, name: str) -> object:
 return len(_runtimes) - 1
 '''
 
+_VALUE_GET_KIND_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(PORTAPY_INVALID_HANDLE)
+    return PORTAPY_VALUE_OBJECT
+status, kind = instance.value_kind(value)
+_set_status(status)
+return int(kind)
+'''
+
+_VALUE_AS_BOOL_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(PORTAPY_INVALID_HANDLE)
+    return 0
+status, kind = instance.value_kind(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+if kind is not ValueKind.BOOL:
+    _set_status(PORTAPY_TYPE_ERROR)
+    return 0
+status, target = instance.unbox(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+_set_status(PORTAPY_OK)
+return 1 if target else 0
+'''
+
 
 def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     """Return True for ``source_size > len(source)``.
@@ -114,6 +144,10 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
         self.generic_visit(node)
         if node.name == "_portapy_runtime_create_impl":
             node.body = ast.parse(_RUNTIME_CREATE_SOURCE).body
+        elif node.name == "_portapy_value_get_kind_impl":
+            node.body = ast.parse(_VALUE_GET_KIND_SOURCE).body
+        elif node.name == "_portapy_value_as_bool_impl":
+            node.body = ast.parse(_VALUE_AS_BOOL_SOURCE).body
         return node
 
     def visit_AsyncFunctionDef(
@@ -184,18 +218,56 @@ def main() -> int:
         ),
         None,
     )
+    value_get_kind = next(
+        (
+            node
+            for node in verified.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_portapy_value_get_kind_impl"
+        ),
+        None,
+    )
+    value_as_bool = next(
+        (
+            node
+            for node in verified.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_portapy_value_as_bool_impl"
+        ),
+        None,
+    )
     runtime_create_text = ast.unparse(runtime_create) if runtime_create is not None else ""
+    value_get_kind_text = ast.unparse(value_get_kind) if value_get_kind is not None else ""
+    value_as_bool_text = ast.unparse(value_as_bool) if value_as_bool is not None else ""
     loader_ready = (
         "_PortaPyImportLoader" in classes
         and "__pyinbin_import__" in runtime_create_text
     )
     builtins_ready = "_seed_builtins" in runtime_create_text
-    if missing or stale or unsafe_spans or not loader_ready or not builtins_ready:
+    tagged_kind_ready = (
+        "instance.value_kind(value)" in value_get_kind_text
+        and "_value_kind(" not in value_get_kind_text
+    )
+    tagged_bool_ready = (
+        "instance.value_kind(value)" in value_as_bool_text
+        and "type(target)" not in value_as_bool_text
+    )
+    if (
+        missing
+        or stale
+        or unsafe_spans
+        or not loader_ready
+        or not builtins_ready
+        or not tagged_kind_ready
+        or not tagged_bool_ready
+    ):
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
-            f"loader_ready={loader_ready}, builtins_ready={builtins_ready}"
+            f"loader_ready={loader_ready}, builtins_ready={builtins_ready}, "
+            f"tagged_kind_ready={tagged_kind_ready}, "
+            f"tagged_bool_ready={tagged_bool_ready}"
         )
     print(
         "NORMALIZED FULL RUNTIME ABI HELPERS",
@@ -203,6 +275,7 @@ def main() -> int:
         len(_DROP),
         "BUILTINS",
         "IMPORT_LOADER",
+        "TAGGED_VALUES",
     )
     return 0
 

From be0223d6aac6c714ba24fdc63d8cd52debcefa62 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:33:29 -0500
Subject: [PATCH 080/450] Test tagged native ABI value checks

---
 .../test_full_reference_abi_normalization.py  | 28 ++++++++++++++-----
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 6c65a9b6..681dcc5e 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -7,6 +7,14 @@
 from tools import normalize_full_reference_abi_helpers as normalizer
 
 
+def _function(module: ast.Module, name: str) -> ast.FunctionDef:
+    return next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    )
+
+
 def test_full_reference_normalization_installs_runtime_support(
     tmp_path: Path,
     monkeypatch,
@@ -28,17 +36,23 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
 
-    runtime_create = next(
-        node
-        for node in module.body
-        if isinstance(node, ast.FunctionDef)
-        and node.name == "_portapy_runtime_create_impl"
-    )
-    runtime_source = ast.unparse(runtime_create)
+    runtime_source = ast.unparse(_function(module, "_portapy_runtime_create_impl"))
     assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
     assert "_PortaPyImportLoader(instance)" in runtime_source
     assert "__pyinbin_import__" in runtime_source
 
+    kind_source = ast.unparse(_function(module, "_portapy_value_get_kind_impl"))
+    assert "instance.value_kind(value)" in kind_source
+    assert "return int(kind)" in kind_source
+    assert "instance.unbox(value)" not in kind_source
+    assert "_value_kind(" not in kind_source
+
+    bool_source = ast.unparse(_function(module, "_portapy_value_as_bool_impl"))
+    assert "instance.value_kind(value)" in bool_source
+    assert "kind is not ValueKind.BOOL" in bool_source
+    assert "instance.unbox(value)" in bool_source
+    assert "type(target)" not in bool_source
+
     loader = next(
         node
         for node in module.body

From 853ff55254cfa4ed3cb95b0bffb8de0ad02719f7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:36:06 -0500
Subject: [PATCH 081/450] Tag ABI-created native values

---
 tools/normalize_full_reference_abi_helpers.py | 97 +++++++++++++------
 1 file changed, 66 insertions(+), 31 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index b93eeeff..2ef5ccfb 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -50,6 +50,15 @@
     "_portapy_cabi_list_append_impl": "_portapy_list_append_impl",
 }
 
+_STORE_KIND_BY_FUNCTION = {
+    "_portapy_value_from_data_begin_impl": "kind",
+    "_portapy_value_from_host_object_impl": "ValueKind.OBJECT",
+    "_portapy_value_from_host_callable_impl": "ValueKind.CALLABLE",
+    "_portapy_tuple_begin_impl": "ValueKind.TUPLE",
+    "_portapy_dict_begin_impl": "ValueKind.DICT",
+    "_portapy_list_begin_impl": "ValueKind.LIST",
+}
+
 _IMPORT_LOADER_SOURCE = '''
 class _PortaPyImportLoader:
     def __init__(self, instance: Runtime) -> None:
@@ -136,6 +145,26 @@ def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     )
 
 
+class _StoreTagger(ast.NodeTransformer):
+    def __init__(self, kind_source: str) -> None:
+        self.kind = ast.parse(kind_source, mode="eval").body
+        self.count = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "_store"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id == "instance"
+            and len(node.args) == 1
+            and not node.keywords
+        ):
+            node.args.append(ast.copy_location(self.kind, node.args[0]))
+            self.count += 1
+        return node
+
+
 class _Rewrite(ast.NodeTransformer):
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
         if node.name in _DROP:
@@ -148,6 +177,16 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
             node.body = ast.parse(_VALUE_GET_KIND_SOURCE).body
         elif node.name == "_portapy_value_as_bool_impl":
             node.body = ast.parse(_VALUE_AS_BOOL_SOURCE).body
+
+        kind_source = _STORE_KIND_BY_FUNCTION.get(node.name)
+        if kind_source is not None:
+            tagger = _StoreTagger(kind_source)
+            node = tagger.visit(node)
+            if tagger.count != 1:
+                raise RuntimeError(
+                    f"native store tagging for {node.name}: expected one call, "
+                    f"found {tagger.count}"
+                )
         return node
 
     def visit_AsyncFunctionDef(
@@ -178,6 +217,18 @@ def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
         return ast.copy_location(ast.BoolOp(op=node.op, values=values), node)
 
 
+def _function_text(module: ast.Module, name: str) -> str:
+    function = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef) and node.name == name
+        ),
+        None,
+    )
+    return ast.unparse(function) if function is not None else ""
+
+
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     module = _Rewrite().visit(module)
@@ -209,36 +260,9 @@ def main() -> int:
         for node in ast.walk(verified)
         if _is_utf8_source_upper_bound(node)
     ]
-    runtime_create = next(
-        (
-            node
-            for node in verified.body
-            if isinstance(node, ast.FunctionDef)
-            and node.name == "_portapy_runtime_create_impl"
-        ),
-        None,
-    )
-    value_get_kind = next(
-        (
-            node
-            for node in verified.body
-            if isinstance(node, ast.FunctionDef)
-            and node.name == "_portapy_value_get_kind_impl"
-        ),
-        None,
-    )
-    value_as_bool = next(
-        (
-            node
-            for node in verified.body
-            if isinstance(node, ast.FunctionDef)
-            and node.name == "_portapy_value_as_bool_impl"
-        ),
-        None,
-    )
-    runtime_create_text = ast.unparse(runtime_create) if runtime_create is not None else ""
-    value_get_kind_text = ast.unparse(value_get_kind) if value_get_kind is not None else ""
-    value_as_bool_text = ast.unparse(value_as_bool) if value_as_bool is not None else ""
+    runtime_create_text = _function_text(verified, "_portapy_runtime_create_impl")
+    value_get_kind_text = _function_text(verified, "_portapy_value_get_kind_impl")
+    value_as_bool_text = _function_text(verified, "_portapy_value_as_bool_impl")
     loader_ready = (
         "_PortaPyImportLoader" in classes
         and "__pyinbin_import__" in runtime_create_text
@@ -252,6 +276,14 @@ def main() -> int:
         "instance.value_kind(value)" in value_as_bool_text
         and "type(target)" not in value_as_bool_text
     )
+    tagged_stores_ready = all(
+        _function_text(verified, name).count("instance._store(") == 1
+        and _function_text(verified, name).count(", ValueKind.") == 1
+        for name in _STORE_KIND_BY_FUNCTION
+        if name != "_portapy_value_from_data_begin_impl"
+    ) and "instance._store(_DataBuilder(kind, size), kind)" in _function_text(
+        verified, "_portapy_value_from_data_begin_impl"
+    )
     if (
         missing
         or stale
@@ -260,6 +292,7 @@ def main() -> int:
         or not builtins_ready
         or not tagged_kind_ready
         or not tagged_bool_ready
+        or not tagged_stores_ready
     ):
         raise RuntimeError(
             "full Runtime ABI helper normalization failed; "
@@ -267,7 +300,8 @@ def main() -> int:
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}, "
             f"tagged_kind_ready={tagged_kind_ready}, "
-            f"tagged_bool_ready={tagged_bool_ready}"
+            f"tagged_bool_ready={tagged_bool_ready}, "
+            f"tagged_stores_ready={tagged_stores_ready}"
         )
     print(
         "NORMALIZED FULL RUNTIME ABI HELPERS",
@@ -276,6 +310,7 @@ def main() -> int:
         "BUILTINS",
         "IMPORT_LOADER",
         "TAGGED_VALUES",
+        "TAGGED_STORES",
     )
     return 0
 

From 14f83eef3474dec4cc79a356b22129bcac8a8586 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:36:32 -0500
Subject: [PATCH 082/450] Test tags for ABI-created values

---
 .../test_full_reference_abi_normalization.py  | 25 ++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 681dcc5e..330b7e12 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -15,6 +15,10 @@ def _function(module: ast.Module, name: str) -> ast.FunctionDef:
     )
 
 
+def _source(module: ast.Module, name: str) -> str:
+    return ast.unparse(_function(module, name))
+
+
 def test_full_reference_normalization_installs_runtime_support(
     tmp_path: Path,
     monkeypatch,
@@ -36,23 +40,38 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
 
-    runtime_source = ast.unparse(_function(module, "_portapy_runtime_create_impl"))
+    runtime_source = _source(module, "_portapy_runtime_create_impl")
     assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
     assert "_PortaPyImportLoader(instance)" in runtime_source
     assert "__pyinbin_import__" in runtime_source
 
-    kind_source = ast.unparse(_function(module, "_portapy_value_get_kind_impl"))
+    kind_source = _source(module, "_portapy_value_get_kind_impl")
     assert "instance.value_kind(value)" in kind_source
     assert "return int(kind)" in kind_source
     assert "instance.unbox(value)" not in kind_source
     assert "_value_kind(" not in kind_source
 
-    bool_source = ast.unparse(_function(module, "_portapy_value_as_bool_impl"))
+    bool_source = _source(module, "_portapy_value_as_bool_impl")
     assert "instance.value_kind(value)" in bool_source
     assert "kind is not ValueKind.BOOL" in bool_source
     assert "instance.unbox(value)" in bool_source
     assert "type(target)" not in bool_source
 
+    assert "instance._store(_DataBuilder(kind, size), kind)" in _source(
+        module, "_portapy_value_from_data_begin_impl"
+    )
+    tagged_stores = {
+        "_portapy_value_from_host_object_impl": "ValueKind.OBJECT",
+        "_portapy_value_from_host_callable_impl": "ValueKind.CALLABLE",
+        "_portapy_tuple_begin_impl": "ValueKind.TUPLE",
+        "_portapy_dict_begin_impl": "ValueKind.DICT",
+        "_portapy_list_begin_impl": "ValueKind.LIST",
+    }
+    for function_name, kind in tagged_stores.items():
+        function_source = _source(module, function_name)
+        assert "instance._store(" in function_source
+        assert kind in function_source
+
     loader = next(
         node
         for node in module.body

From 05adc8593b1cbb05eeb808895e3cfb3b074a1ca6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:40:07 -0500
Subject: [PATCH 083/450] Run full reference normalization in probe test

---
 tests/test_full_core_probe.py | 49 +++++++++++++++++++++++++++--------
 1 file changed, 38 insertions(+), 11 deletions(-)

diff --git a/tests/test_full_core_probe.py b/tests/test_full_core_probe.py
index 625b13ad..d8e25548 100644
--- a/tests/test_full_core_probe.py
+++ b/tests/test_full_core_probe.py
@@ -1,19 +1,46 @@
+from __future__ import annotations
+
+import importlib
+import sys
+
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_runtime import (
+    PATH as REFERENCE_RUNTIME_PATH,
+    main as normalize_reference_runtime,
+)
+
+
+_TEMPORARY_MODULES = (
+    "portapy.native_full_core_probe",
+    "portapy.native_full_reference_entry",
+    "portapy.reference_api",
+)
 
 
 def test_full_core_probe_executes_reference_abi_path() -> None:
-    materialize_reference_entry()
-    normalize_reference_abi_helpers()
-    from portapy.native_full_core_probe import portapy_full_core_probe
-    from portapy.native_full_reference_entry import _runtimes
+    original_reference_runtime = REFERENCE_RUNTIME_PATH.read_text(encoding="utf-8")
+    try:
+        normalize_reference_runtime()
+        materialize_reference_entry()
+        normalize_reference_abi_helpers()
+        from portapy.native_full_core_probe import portapy_full_core_probe
+        from portapy.native_full_reference_entry import _runtimes
 
-    result = portapy_full_core_probe()
-    errors = [
-        runtime.last_error()
-        for runtime in _runtimes
-        if runtime is not None and runtime.last_error() is not None
-    ]
-    assert result == 42, errors
+        result = portapy_full_core_probe()
+        errors = [
+            runtime.last_error()
+            for runtime in _runtimes
+            if runtime is not None and runtime.last_error() is not None
+        ]
+        assert result == 42, errors
+    finally:
+        REFERENCE_RUNTIME_PATH.write_text(
+            original_reference_runtime,
+            encoding="utf-8",
+        )
+        for name in _TEMPORARY_MODULES:
+            sys.modules.pop(name, None)
+        importlib.invalidate_caches()

From 1587f7f7905c59f1b5984fdb1deb31975bb3103a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:41:30 -0500
Subject: [PATCH 084/450] Reload normalized reference runtime in probe test

---
 tests/test_full_core_probe.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/tests/test_full_core_probe.py b/tests/test_full_core_probe.py
index d8e25548..5b98f4c1 100644
--- a/tests/test_full_core_probe.py
+++ b/tests/test_full_core_probe.py
@@ -20,12 +20,20 @@
 )
 
 
+def _unload_temporary_modules() -> None:
+    for name in _TEMPORARY_MODULES:
+        sys.modules.pop(name, None)
+    importlib.invalidate_caches()
+
+
 def test_full_core_probe_executes_reference_abi_path() -> None:
     original_reference_runtime = REFERENCE_RUNTIME_PATH.read_text(encoding="utf-8")
     try:
+        _unload_temporary_modules()
         normalize_reference_runtime()
         materialize_reference_entry()
         normalize_reference_abi_helpers()
+        _unload_temporary_modules()
         from portapy.native_full_core_probe import portapy_full_core_probe
         from portapy.native_full_reference_entry import _runtimes
 
@@ -41,6 +49,4 @@ def test_full_core_probe_executes_reference_abi_path() -> None:
             original_reference_runtime,
             encoding="utf-8",
         )
-        for name in _TEMPORARY_MODULES:
-            sys.modules.pop(name, None)
-        importlib.invalidate_caches()
+        _unload_temporary_modules()

From e28889273b7c6a29025456e697eea88305a9f208 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:43:57 -0500
Subject: [PATCH 085/450] Retry pinned compiler installation on Windows

---
 .github/workflows/native-build-diagnostic.yml | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 70ebe51e..768d90bc 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -104,10 +104,18 @@ jobs:
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
           python -m pip install -e '.[test]' *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1' `
-            *>> $installLog
-          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
+          $compiler = 'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+          $compilerInstalled = $false
+          for ($attempt = 1; $attempt -le 3; $attempt += 1) {
+            "Installing pinned asmpython (attempt $attempt/3)" | Out-File -FilePath $installLog -Encoding utf8 -Append
+            python -m pip install --no-cache-dir --force-reinstall $compiler *>> $installLog
+            if ($LASTEXITCODE -eq 0) {
+              $compilerInstalled = $true
+              break
+            }
+            if ($attempt -lt 3) { Start-Sleep -Seconds (10 * $attempt) }
+          }
+          if (-not $compilerInstalled) { Get-Content $installLog; exit 1 }
       - name: Capture compiler diagnostic
         id: build
         shell: powershell

From ecadb2b91487bd85e14f6c9e19abbe927e4ecaa8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:44:34 -0500
Subject: [PATCH 086/450] Retry pinned compiler installation in Windows release

---
 .github/workflows/release-3.14.0.yml | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index be8c7c44..b08536b6 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -87,9 +87,18 @@ jobs:
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install -e '.[test]'
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          $compiler = 'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+          $compilerInstalled = $false
+          for ($attempt = 1; $attempt -le 3; $attempt += 1) {
+            Write-Host "Installing pinned asmpython (attempt $attempt/3)"
+            python -m pip install --no-cache-dir --force-reinstall $compiler
+            if ($LASTEXITCODE -eq 0) {
+              $compilerInstalled = $true
+              break
+            }
+            if ($attempt -lt 3) { Start-Sleep -Seconds (10 * $attempt) }
+          }
+          if (-not $compilerInstalled) { exit 1 }
       - name: Build full portapy.dll
         shell: powershell
         run: |

From 5f3a17028295537f2912bc80399ad2712a7e7cd6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:46:58 -0500
Subject: [PATCH 087/450] Allow Windows compiler install retries

---
 .github/workflows/native-build-diagnostic.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index 768d90bc..c7ad4571 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -99,6 +99,7 @@ jobs:
       - name: Install quietly
         shell: powershell
         run: |
+          $PSNativeCommandUseErrorActionPreference = $false
           $installLog = Join-Path $env:RUNNER_TEMP 'portapy-install-windows.log'
           & .\tools\install_windows_toolchain.ps1 *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }

From d2c22730806109d90cfae5bfb056e99b5a9681e5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:47:35 -0500
Subject: [PATCH 088/450] Allow Windows release install retries

---
 .github/workflows/release-3.14.0.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index b08536b6..f966e51a 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -83,6 +83,7 @@ jobs:
       - name: Install package and native toolchain
         shell: powershell
         run: |
+          $PSNativeCommandUseErrorActionPreference = $false
           & .\tools\install_windows_toolchain.ps1
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install -e '.[test]'

From d7cb5abcfe28837759b91cc69a587e5a8a92638d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:49:31 -0500
Subject: [PATCH 089/450] Install pinned asmpython with process-level retries

---
 tools/install_pinned_asmpython.ps1 | 50 ++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 tools/install_pinned_asmpython.ps1

diff --git a/tools/install_pinned_asmpython.ps1 b/tools/install_pinned_asmpython.ps1
new file mode 100644
index 00000000..e19355e6
--- /dev/null
+++ b/tools/install_pinned_asmpython.ps1
@@ -0,0 +1,50 @@
+param(
+    [string] $LogPath = ''
+)
+
+$ErrorActionPreference = 'Stop'
+$compiler = 'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+$python = (Get-Command python -ErrorAction Stop).Source
+
+function Write-InstallLog([string] $Text) {
+    Write-Host $Text
+    if ($LogPath) {
+        $Text | Out-File -FilePath $LogPath -Encoding utf8 -Append
+    }
+}
+
+for ($attempt = 1; $attempt -le 3; $attempt += 1) {
+    Write-InstallLog "Installing pinned asmpython (attempt $attempt/3)"
+    $stdout = Join-Path $env:RUNNER_TEMP "asmpython-install-$attempt.stdout.log"
+    $stderr = Join-Path $env:RUNNER_TEMP "asmpython-install-$attempt.stderr.log"
+    Remove-Item $stdout, $stderr -Force -ErrorAction SilentlyContinue
+
+    $process = Start-Process `
+        -FilePath $python `
+        -ArgumentList @(
+            '-m', 'pip', 'install',
+            '--no-cache-dir', '--force-reinstall',
+            $compiler
+        ) `
+        -Wait `
+        -PassThru `
+        -NoNewWindow `
+        -RedirectStandardOutput $stdout `
+        -RedirectStandardError $stderr
+
+    foreach ($path in @($stdout, $stderr)) {
+        if (Test-Path $path) {
+            Get-Content $path | ForEach-Object { Write-InstallLog $_ }
+        }
+    }
+    if ($process.ExitCode -eq 0) {
+        Write-InstallLog 'Pinned asmpython installation succeeded.'
+        exit 0
+    }
+    Write-InstallLog "Pinned asmpython installation failed with exit code $($process.ExitCode)."
+    if ($attempt -lt 3) {
+        Start-Sleep -Seconds (10 * $attempt)
+    }
+}
+
+throw 'Pinned asmpython installation failed after 3 attempts.'

From cdb67a665213d61ba6e455244ef342c43786d1c2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:50:08 -0500
Subject: [PATCH 090/450] Use process-based Windows compiler installer

---
 .github/workflows/native-build-diagnostic.yml | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
index c7ad4571..8a203d29 100644
--- a/.github/workflows/native-build-diagnostic.yml
+++ b/.github/workflows/native-build-diagnostic.yml
@@ -99,24 +99,12 @@ jobs:
       - name: Install quietly
         shell: powershell
         run: |
-          $PSNativeCommandUseErrorActionPreference = $false
           $installLog = Join-Path $env:RUNNER_TEMP 'portapy-install-windows.log'
           & .\tools\install_windows_toolchain.ps1 *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
           python -m pip install -e '.[test]' *>> $installLog
           if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
-          $compiler = 'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          $compilerInstalled = $false
-          for ($attempt = 1; $attempt -le 3; $attempt += 1) {
-            "Installing pinned asmpython (attempt $attempt/3)" | Out-File -FilePath $installLog -Encoding utf8 -Append
-            python -m pip install --no-cache-dir --force-reinstall $compiler *>> $installLog
-            if ($LASTEXITCODE -eq 0) {
-              $compilerInstalled = $true
-              break
-            }
-            if ($attempt -lt 3) { Start-Sleep -Seconds (10 * $attempt) }
-          }
-          if (-not $compilerInstalled) { Get-Content $installLog; exit 1 }
+          & .\tools\install_pinned_asmpython.ps1 -LogPath $installLog
       - name: Capture compiler diagnostic
         id: build
         shell: powershell

From d3ecfb3b019426239bba141b18ec2af36d725f74 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:50:45 -0500
Subject: [PATCH 091/450] Use process-based Windows compiler installer in
 release

---
 .github/workflows/release-3.14.0.yml | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index f966e51a..f3675282 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -83,23 +83,11 @@ jobs:
       - name: Install package and native toolchain
         shell: powershell
         run: |
-          $PSNativeCommandUseErrorActionPreference = $false
           & .\tools\install_windows_toolchain.ps1
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install -e '.[test]'
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $compiler = 'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          $compilerInstalled = $false
-          for ($attempt = 1; $attempt -le 3; $attempt += 1) {
-            Write-Host "Installing pinned asmpython (attempt $attempt/3)"
-            python -m pip install --no-cache-dir --force-reinstall $compiler
-            if ($LASTEXITCODE -eq 0) {
-              $compilerInstalled = $true
-              break
-            }
-            if ($attempt -lt 3) { Start-Sleep -Seconds (10 * $attempt) }
-          }
-          if (-not $compilerInstalled) { exit 1 }
+          & .\tools\install_pinned_asmpython.ps1
       - name: Build full portapy.dll
         shell: powershell
         run: |

From 3d87696016fdb0f806c0b2c90fbe89ce9ea7cc22 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:55:53 -0500
Subject: [PATCH 092/450] Normalize native enum values without __int__

---
 tools/normalize_full_reference_abi_helpers.py | 58 ++++++++++++++++---
 1 file changed, 51 insertions(+), 7 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 2ef5ccfb..60f7e12b 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -86,37 +86,37 @@ def __call__(self, name: str) -> object:
 instance._vm._seed_builtins(instance._globals)
 instance.set_global("__pyinbin_import__", _PortaPyImportLoader(instance))
 _runtimes.append(instance)
-_set_status(PORTAPY_OK)
+_set_status(Status.OK)
 return len(_runtimes) - 1
 '''
 
 _VALUE_GET_KIND_SOURCE = '''
 instance = _runtime(runtime)
 if instance is None:
-    _set_status(PORTAPY_INVALID_HANDLE)
-    return PORTAPY_VALUE_OBJECT
+    _set_status(Status.INVALID_HANDLE)
+    return ValueKind.OBJECT.value
 status, kind = instance.value_kind(value)
 _set_status(status)
-return int(kind)
+return kind.value
 '''
 
 _VALUE_AS_BOOL_SOURCE = '''
 instance = _runtime(runtime)
 if instance is None:
-    _set_status(PORTAPY_INVALID_HANDLE)
+    _set_status(Status.INVALID_HANDLE)
     return 0
 status, kind = instance.value_kind(value)
 if status is not Status.OK:
     _set_status(status)
     return 0
 if kind is not ValueKind.BOOL:
-    _set_status(PORTAPY_TYPE_ERROR)
+    _set_status(Status.TYPE_ERROR)
     return 0
 status, target = instance.unbox(value)
 if status is not Status.OK:
     _set_status(status)
     return 0
-_set_status(PORTAPY_OK)
+_set_status(Status.OK)
 return 1 if target else 0
 '''
 
@@ -145,6 +145,16 @@ def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     )
 
 
+def _is_native_enum_expression(node: ast.AST) -> bool:
+    if isinstance(node, ast.Name):
+        return node.id in {"status", "kind"}
+    if not isinstance(node, ast.Attribute):
+        return False
+    if node.attr == "status":
+        return True
+    return isinstance(node.value, ast.Name) and node.value.id in {"Status", "ValueKind"}
+
+
 class _StoreTagger(ast.NodeTransformer):
     def __init__(self, kind_source: str) -> None:
         self.kind = ast.parse(kind_source, mode="eval").body
@@ -205,6 +215,21 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
             return node
         return ast.copy_location(ast.Name(id=renamed, ctx=node.ctx), node)
 
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "int"
+            and len(node.args) == 1
+            and not node.keywords
+            and _is_native_enum_expression(node.args[0])
+        ):
+            return ast.copy_location(
+                ast.Attribute(value=node.args[0], attr="value", ctx=ast.Load()),
+                node,
+            )
+        return node
+
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
         self.generic_visit(node)
         if not isinstance(node.op, ast.Or):
@@ -260,7 +285,17 @@ def main() -> int:
         for node in ast.walk(verified)
         if _is_utf8_source_upper_bound(node)
     ]
+    enum_int_calls = [
+        node
+        for node in ast.walk(verified)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "int"
+        and len(node.args) == 1
+        and _is_native_enum_expression(node.args[0])
+    ]
     runtime_create_text = _function_text(verified, "_portapy_runtime_create_impl")
+    set_status_text = _function_text(verified, "_set_status")
     value_get_kind_text = _function_text(verified, "_portapy_value_get_kind_impl")
     value_as_bool_text = _function_text(verified, "_portapy_value_as_bool_impl")
     loader_ready = (
@@ -268,6 +303,11 @@ def main() -> int:
         and "__pyinbin_import__" in runtime_create_text
     )
     builtins_ready = "_seed_builtins" in runtime_create_text
+    enum_values_ready = (
+        not enum_int_calls
+        and "status.value" in set_status_text
+        and "return kind.value" in value_get_kind_text
+    )
     tagged_kind_ready = (
         "instance.value_kind(value)" in value_get_kind_text
         and "_value_kind(" not in value_get_kind_text
@@ -290,6 +330,7 @@ def main() -> int:
         or unsafe_spans
         or not loader_ready
         or not builtins_ready
+        or not enum_values_ready
         or not tagged_kind_ready
         or not tagged_bool_ready
         or not tagged_stores_ready
@@ -298,7 +339,9 @@ def main() -> int:
             "full Runtime ABI helper normalization failed; "
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
+            f"enum_int_calls={len(enum_int_calls)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}, "
+            f"enum_values_ready={enum_values_ready}, "
             f"tagged_kind_ready={tagged_kind_ready}, "
             f"tagged_bool_ready={tagged_bool_ready}, "
             f"tagged_stores_ready={tagged_stores_ready}"
@@ -309,6 +352,7 @@ def main() -> int:
         len(_DROP),
         "BUILTINS",
         "IMPORT_LOADER",
+        "ENUM_VALUES",
         "TAGGED_VALUES",
         "TAGGED_STORES",
     )

From 990347a5272c3eaf5e0bbc7dc86b235586aa5d3f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 16:56:19 -0500
Subject: [PATCH 093/450] Test direct native enum value access

---
 tests/test_full_reference_abi_normalization.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 330b7e12..59cac1a6 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -44,10 +44,16 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
     assert "_PortaPyImportLoader(instance)" in runtime_source
     assert "__pyinbin_import__" in runtime_source
+    assert "_set_status(Status.OK)" in runtime_source
+
+    set_status_source = _source(module, "_set_status")
+    assert "status.value" in set_status_source
+    assert "int(status)" not in set_status_source
 
     kind_source = _source(module, "_portapy_value_get_kind_impl")
     assert "instance.value_kind(value)" in kind_source
-    assert "return int(kind)" in kind_source
+    assert "return kind.value" in kind_source
+    assert "int(kind)" not in kind_source
     assert "instance.unbox(value)" not in kind_source
     assert "_value_kind(" not in kind_source
 
@@ -56,6 +62,7 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "kind is not ValueKind.BOOL" in bool_source
     assert "instance.unbox(value)" in bool_source
     assert "type(target)" not in bool_source
+    assert "PORTAPY_" not in bool_source
 
     assert "instance._store(_DataBuilder(kind, size), kind)" in _source(
         module, "_portapy_value_from_data_begin_impl"

From 502b0303ea55cde0c0d1723d427cb8d14fd95cba Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:00:25 -0500
Subject: [PATCH 094/450] Normalize raw ABI status constants

---
 tools/normalize_full_reference_abi_helpers.py | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index 60f7e12b..e7730722 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -59,6 +59,18 @@
     "_portapy_list_begin_impl": "ValueKind.LIST",
 }
 
+_STATUS_CONSTANTS = {
+    "PORTAPY_OK": "OK",
+    "PORTAPY_INVALID_ARGUMENT": "INVALID_ARGUMENT",
+    "PORTAPY_COMPILE_ERROR": "COMPILE_ERROR",
+    "PORTAPY_RUNTIME_ERROR": "RUNTIME_ERROR",
+    "PORTAPY_TYPE_ERROR": "TYPE_ERROR",
+    "PORTAPY_NOT_FOUND": "NOT_FOUND",
+    "PORTAPY_CLOSED": "CLOSED",
+    "PORTAPY_INVALID_HANDLE": "INVALID_HANDLE",
+    "PORTAPY_INTERRUPTED": "INTERRUPTED",
+}
+
 _IMPORT_LOADER_SOURCE = '''
 class _PortaPyImportLoader:
     def __init__(self, instance: Runtime) -> None:
@@ -217,6 +229,23 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
 
     def visit_Call(self, node: ast.Call) -> ast.AST:
         self.generic_visit(node)
+        if (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "_set_status"
+            and len(node.args) == 1
+            and not node.keywords
+            and isinstance(node.args[0], ast.Name)
+            and node.args[0].id in _STATUS_CONSTANTS
+        ):
+            node.args[0] = ast.copy_location(
+                ast.Attribute(
+                    value=ast.Name(id="Status", ctx=ast.Load()),
+                    attr=_STATUS_CONSTANTS[node.args[0].id],
+                    ctx=ast.Load(),
+                ),
+                node.args[0],
+            )
+            return node
         if (
             isinstance(node.func, ast.Name)
             and node.func.id == "int"
@@ -294,6 +323,16 @@ def main() -> int:
         and len(node.args) == 1
         and _is_native_enum_expression(node.args[0])
     ]
+    raw_status_calls = [
+        node
+        for node in ast.walk(verified)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_set_status"
+        and len(node.args) == 1
+        and isinstance(node.args[0], ast.Name)
+        and node.args[0].id in _STATUS_CONSTANTS
+    ]
     runtime_create_text = _function_text(verified, "_portapy_runtime_create_impl")
     set_status_text = _function_text(verified, "_set_status")
     value_get_kind_text = _function_text(verified, "_portapy_value_get_kind_impl")
@@ -305,6 +344,7 @@ def main() -> int:
     builtins_ready = "_seed_builtins" in runtime_create_text
     enum_values_ready = (
         not enum_int_calls
+        and not raw_status_calls
         and "status.value" in set_status_text
         and "return kind.value" in value_get_kind_text
     )
@@ -340,6 +380,7 @@ def main() -> int:
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
             f"enum_int_calls={len(enum_int_calls)}, "
+            f"raw_status_calls={len(raw_status_calls)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}, "
             f"enum_values_ready={enum_values_ready}, "
             f"tagged_kind_ready={tagged_kind_ready}, "
@@ -353,6 +394,7 @@ def main() -> int:
         "BUILTINS",
         "IMPORT_LOADER",
         "ENUM_VALUES",
+        "STATUS_VALUES",
         "TAGGED_VALUES",
         "TAGGED_STORES",
     )

From 3327db05451d30217c1b398b32e81a341b81845d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:00:54 -0500
Subject: [PATCH 095/450] Test normalized raw status constants

---
 tests/test_full_reference_abi_normalization.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 59cac1a6..65da5600 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -39,6 +39,7 @@ def test_full_reference_normalization_installs_runtime_support(
     }
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
+    assert "_set_status(PORTAPY_" not in source
 
     runtime_source = _source(module, "_portapy_runtime_create_impl")
     assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
@@ -64,6 +65,10 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "type(target)" not in bool_source
     assert "PORTAPY_" not in bool_source
 
+    list_source = _source(module, "_portapy_list_begin_impl")
+    assert "_set_status(Status.OK)" in list_source
+    assert "_set_status(PORTAPY_OK)" not in list_source
+
     assert "instance._store(_DataBuilder(kind, size), kind)" in _source(
         module, "_portapy_value_from_data_begin_impl"
     )

From 4b6e1cdd3e166006ee9adc11322803c0546cf3db Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:03:01 -0500
Subject: [PATCH 096/450] Normalize conditional ABI status expressions

---
 tools/normalize_full_reference_abi_helpers.py | 36 ++++++++++++-------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index e7730722..db9ba6ca 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -167,6 +167,28 @@ def _is_native_enum_expression(node: ast.AST) -> bool:
     return isinstance(node.value, ast.Name) and node.value.id in {"Status", "ValueKind"}
 
 
+def _contains_raw_status(node: ast.AST) -> bool:
+    return any(
+        isinstance(item, ast.Name) and item.id in _STATUS_CONSTANTS
+        for item in ast.walk(node)
+    )
+
+
+class _StatusConstantRewriter(ast.NodeTransformer):
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        member = _STATUS_CONSTANTS.get(node.id)
+        if member is None:
+            return node
+        return ast.copy_location(
+            ast.Attribute(
+                value=ast.Name(id="Status", ctx=ast.Load()),
+                attr=member,
+                ctx=ast.Load(),
+            ),
+            node,
+        )
+
+
 class _StoreTagger(ast.NodeTransformer):
     def __init__(self, kind_source: str) -> None:
         self.kind = ast.parse(kind_source, mode="eval").body
@@ -234,17 +256,8 @@ def visit_Call(self, node: ast.Call) -> ast.AST:
             and node.func.id == "_set_status"
             and len(node.args) == 1
             and not node.keywords
-            and isinstance(node.args[0], ast.Name)
-            and node.args[0].id in _STATUS_CONSTANTS
         ):
-            node.args[0] = ast.copy_location(
-                ast.Attribute(
-                    value=ast.Name(id="Status", ctx=ast.Load()),
-                    attr=_STATUS_CONSTANTS[node.args[0].id],
-                    ctx=ast.Load(),
-                ),
-                node.args[0],
-            )
+            node.args[0] = _StatusConstantRewriter().visit(node.args[0])
             return node
         if (
             isinstance(node.func, ast.Name)
@@ -330,8 +343,7 @@ def main() -> int:
         and isinstance(node.func, ast.Name)
         and node.func.id == "_set_status"
         and len(node.args) == 1
-        and isinstance(node.args[0], ast.Name)
-        and node.args[0].id in _STATUS_CONSTANTS
+        and _contains_raw_status(node.args[0])
     ]
     runtime_create_text = _function_text(verified, "_portapy_runtime_create_impl")
     set_status_text = _function_text(verified, "_set_status")

From dbbafb056b5f9da65c6dc37f4bde3fc6efcc029b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:08:58 -0500
Subject: [PATCH 097/450] Map native enums without attribute access

---
 tools/normalize_full_reference_abi_helpers.py | 171 ++++++++++++++----
 1 file changed, 138 insertions(+), 33 deletions(-)

diff --git a/tools/normalize_full_reference_abi_helpers.py b/tools/normalize_full_reference_abi_helpers.py
index db9ba6ca..4e498295 100644
--- a/tools/normalize_full_reference_abi_helpers.py
+++ b/tools/normalize_full_reference_abi_helpers.py
@@ -71,6 +71,64 @@
     "PORTAPY_INTERRUPTED": "INTERRUPTED",
 }
 
+_NATIVE_ENUM_HELPERS_SOURCE = '''
+def _native_status_code(status: object) -> int:
+    if status is Status.OK:
+        return PORTAPY_OK
+    if status is Status.INVALID_ARGUMENT:
+        return PORTAPY_INVALID_ARGUMENT
+    if status is Status.COMPILE_ERROR:
+        return PORTAPY_COMPILE_ERROR
+    if status is Status.RUNTIME_ERROR:
+        return PORTAPY_RUNTIME_ERROR
+    if status is Status.TYPE_ERROR:
+        return PORTAPY_TYPE_ERROR
+    if status is Status.NOT_FOUND:
+        return PORTAPY_NOT_FOUND
+    if status is Status.CLOSED:
+        return PORTAPY_CLOSED
+    if status is Status.INVALID_HANDLE:
+        return PORTAPY_INVALID_HANDLE
+    if status is Status.INTERRUPTED:
+        return PORTAPY_INTERRUPTED
+    return PORTAPY_RUNTIME_ERROR
+
+
+def _native_value_kind_code(kind: object) -> int:
+    if kind is ValueKind.NONE:
+        return PORTAPY_VALUE_NONE
+    if kind is ValueKind.BOOL:
+        return PORTAPY_VALUE_BOOL
+    if kind is ValueKind.INT:
+        return PORTAPY_VALUE_INT
+    if kind is ValueKind.FLOAT:
+        return PORTAPY_VALUE_FLOAT
+    if kind is ValueKind.STRING:
+        return PORTAPY_VALUE_STRING
+    if kind is ValueKind.BYTES:
+        return PORTAPY_VALUE_BYTES
+    if kind is ValueKind.CALLABLE:
+        return PORTAPY_VALUE_CALLABLE
+    if kind is ValueKind.TUPLE:
+        return PORTAPY_VALUE_TUPLE
+    if kind is ValueKind.DICT:
+        return PORTAPY_VALUE_DICT
+    if kind is ValueKind.LIST:
+        return PORTAPY_VALUE_LIST
+    return PORTAPY_VALUE_OBJECT
+
+
+def _set_status_code(value: int) -> int:
+    _last_status[0] = value
+    return value
+'''
+
+_SET_STATUS_SOURCE = '''
+value = _native_status_code(status)
+_last_status[0] = value
+return value
+'''
+
 _IMPORT_LOADER_SOURCE = '''
 class _PortaPyImportLoader:
     def __init__(self, instance: Runtime) -> None:
@@ -106,10 +164,10 @@ def __call__(self, name: str) -> object:
 instance = _runtime(runtime)
 if instance is None:
     _set_status(Status.INVALID_HANDLE)
-    return ValueKind.OBJECT.value
+    return PORTAPY_VALUE_OBJECT
 status, kind = instance.value_kind(value)
 _set_status(status)
-return kind.value
+return _native_value_kind_code(kind)
 '''
 
 _VALUE_AS_BOOL_SOURCE = '''
@@ -157,14 +215,23 @@ def _is_utf8_source_upper_bound(node: ast.AST) -> bool:
     )
 
 
-def _is_native_enum_expression(node: ast.AST) -> bool:
+def _native_enum_helper(node: ast.AST) -> str | None:
     if isinstance(node, ast.Name):
-        return node.id in {"status", "kind"}
+        if node.id == "kind":
+            return "_native_value_kind_code"
+        if node.id == "status":
+            return "_native_status_code"
+        return None
     if not isinstance(node, ast.Attribute):
-        return False
+        return None
     if node.attr == "status":
-        return True
-    return isinstance(node.value, ast.Name) and node.value.id in {"Status", "ValueKind"}
+        return "_native_status_code"
+    if isinstance(node.value, ast.Name):
+        if node.value.id == "Status":
+            return "_native_status_code"
+        if node.value.id == "ValueKind":
+            return "_native_value_kind_code"
+    return None
 
 
 def _contains_raw_status(node: ast.AST) -> bool:
@@ -174,19 +241,28 @@ def _contains_raw_status(node: ast.AST) -> bool:
     )
 
 
-class _StatusConstantRewriter(ast.NodeTransformer):
-    def visit_Name(self, node: ast.Name) -> ast.AST:
-        member = _STATUS_CONSTANTS.get(node.id)
-        if member is None:
-            return node
-        return ast.copy_location(
-            ast.Attribute(
-                value=ast.Name(id="Status", ctx=ast.Load()),
-                attr=member,
-                ctx=ast.Load(),
-            ),
-            node,
-        )
+def _contains_native_enum_value_access(node: ast.AST) -> bool:
+    return any(
+        isinstance(item, ast.Attribute)
+        and item.attr == "value"
+        and _native_enum_helper(item.value) is not None
+        for item in ast.walk(node)
+    )
+
+
+class _RawDispatchStatusRewriter(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "_set_status"
+            and len(node.args) == 1
+            and not node.keywords
+            and isinstance(node.args[0], ast.Name)
+            and node.args[0].id == "status"
+        ):
+            node.func.id = "_set_status_code"
+        return node
 
 
 class _StoreTagger(ast.NodeTransformer):
@@ -215,12 +291,16 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST | None:
             return None
         node.name = _RENAME.get(node.name, node.name)
         self.generic_visit(node)
-        if node.name == "_portapy_runtime_create_impl":
+        if node.name == "_set_status":
+            node.body = ast.parse(_SET_STATUS_SOURCE).body
+        elif node.name == "_portapy_runtime_create_impl":
             node.body = ast.parse(_RUNTIME_CREATE_SOURCE).body
         elif node.name == "_portapy_value_get_kind_impl":
             node.body = ast.parse(_VALUE_GET_KIND_SOURCE).body
         elif node.name == "_portapy_value_as_bool_impl":
             node.body = ast.parse(_VALUE_AS_BOOL_SOURCE).body
+        elif node.name == "_portapy_host_dispatch_complete_impl":
+            node = _RawDispatchStatusRewriter().visit(node)
 
         kind_source = _STORE_KIND_BY_FUNCTION.get(node.name)
         if kind_source is not None:
@@ -256,20 +336,26 @@ def visit_Call(self, node: ast.Call) -> ast.AST:
             and node.func.id == "_set_status"
             and len(node.args) == 1
             and not node.keywords
+            and _contains_raw_status(node.args[0])
         ):
-            node.args[0] = _StatusConstantRewriter().visit(node.args[0])
+            node.func.id = "_set_status_code"
             return node
         if (
             isinstance(node.func, ast.Name)
             and node.func.id == "int"
             and len(node.args) == 1
             and not node.keywords
-            and _is_native_enum_expression(node.args[0])
         ):
-            return ast.copy_location(
-                ast.Attribute(value=node.args[0], attr="value", ctx=ast.Load()),
-                node,
-            )
+            helper = _native_enum_helper(node.args[0])
+            if helper is not None:
+                return ast.copy_location(
+                    ast.Call(
+                        func=ast.Name(id=helper, ctx=ast.Load()),
+                        args=node.args,
+                        keywords=[],
+                    ),
+                    node,
+                )
         return node
 
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
@@ -304,6 +390,7 @@ def main() -> int:
         for node in module.body
     ):
         raise RuntimeError("full Runtime already contains the PortaPy import loader")
+    module.body.extend(ast.parse(_NATIVE_ENUM_HELPERS_SOURCE).body)
     module.body.extend(ast.parse(_IMPORT_LOADER_SOURCE).body)
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -334,7 +421,7 @@ def main() -> int:
         and isinstance(node.func, ast.Name)
         and node.func.id == "int"
         and len(node.args) == 1
-        and _is_native_enum_expression(node.args[0])
+        and _native_enum_helper(node.args[0]) is not None
     ]
     raw_status_calls = [
         node
@@ -345,10 +432,18 @@ def main() -> int:
         and len(node.args) == 1
         and _contains_raw_status(node.args[0])
     ]
+    enum_value_accesses = [
+        node
+        for node in ast.walk(verified)
+        if _contains_native_enum_value_access(node)
+    ]
     runtime_create_text = _function_text(verified, "_portapy_runtime_create_impl")
     set_status_text = _function_text(verified, "_set_status")
+    status_code_text = _function_text(verified, "_native_status_code")
+    kind_code_text = _function_text(verified, "_native_value_kind_code")
     value_get_kind_text = _function_text(verified, "_portapy_value_get_kind_impl")
     value_as_bool_text = _function_text(verified, "_portapy_value_as_bool_impl")
+    host_dispatch_text = _function_text(verified, "_portapy_host_dispatch_complete_impl")
     loader_ready = (
         "_PortaPyImportLoader" in classes
         and "__pyinbin_import__" in runtime_create_text
@@ -356,9 +451,16 @@ def main() -> int:
     builtins_ready = "_seed_builtins" in runtime_create_text
     enum_values_ready = (
         not enum_int_calls
-        and not raw_status_calls
-        and "status.value" in set_status_text
-        and "return kind.value" in value_get_kind_text
+        and not enum_value_accesses
+        and "_native_status_code(status)" in set_status_text
+        and "_native_value_kind_code(kind)" in value_get_kind_text
+        and "PORTAPY_OK" in status_code_text
+        and "PORTAPY_VALUE_NONE" in kind_code_text
+    )
+    status_paths_ready = (
+        not raw_status_calls
+        and "_set_status_code(status)" in host_dispatch_text
+        and "_set_status(status)" not in host_dispatch_text
     )
     tagged_kind_ready = (
         "instance.value_kind(value)" in value_get_kind_text
@@ -383,6 +485,7 @@ def main() -> int:
         or not loader_ready
         or not builtins_ready
         or not enum_values_ready
+        or not status_paths_ready
         or not tagged_kind_ready
         or not tagged_bool_ready
         or not tagged_stores_ready
@@ -392,9 +495,11 @@ def main() -> int:
             f"missing={missing}, stale={stale}, "
             f"unsafe_utf8_spans={len(unsafe_spans)}, "
             f"enum_int_calls={len(enum_int_calls)}, "
+            f"enum_value_accesses={len(enum_value_accesses)}, "
             f"raw_status_calls={len(raw_status_calls)}, "
             f"loader_ready={loader_ready}, builtins_ready={builtins_ready}, "
             f"enum_values_ready={enum_values_ready}, "
+            f"status_paths_ready={status_paths_ready}, "
             f"tagged_kind_ready={tagged_kind_ready}, "
             f"tagged_bool_ready={tagged_bool_ready}, "
             f"tagged_stores_ready={tagged_stores_ready}"
@@ -405,8 +510,8 @@ def main() -> int:
         len(_DROP),
         "BUILTINS",
         "IMPORT_LOADER",
-        "ENUM_VALUES",
-        "STATUS_VALUES",
+        "ENUM_CODES",
+        "STATUS_CODES",
         "TAGGED_VALUES",
         "TAGGED_STORES",
     )

From b46853e150ed78d55b4e89c140f4f9704188fb51 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:09:36 -0500
Subject: [PATCH 098/450] Test native enum code mapping

---
 .../test_full_reference_abi_normalization.py  | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/tests/test_full_reference_abi_normalization.py b/tests/test_full_reference_abi_normalization.py
index 65da5600..1203b471 100644
--- a/tests/test_full_reference_abi_normalization.py
+++ b/tests/test_full_reference_abi_normalization.py
@@ -40,6 +40,8 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "_PortaPyImportLoader" in classes
     assert "source_size > len(source)" not in source
     assert "_set_status(PORTAPY_" not in source
+    assert "status.value" not in source
+    assert "kind.value" not in source
 
     runtime_source = _source(module, "_portapy_runtime_create_impl")
     assert "instance._vm._seed_builtins(instance._globals)" in runtime_source
@@ -48,12 +50,22 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "_set_status(Status.OK)" in runtime_source
 
     set_status_source = _source(module, "_set_status")
-    assert "status.value" in set_status_source
+    assert "_native_status_code(status)" in set_status_source
     assert "int(status)" not in set_status_source
 
+    status_code_source = _source(module, "_native_status_code")
+    assert "status is Status.OK" in status_code_source
+    assert "return PORTAPY_OK" in status_code_source
+    assert "status.value" not in status_code_source
+
+    value_kind_code_source = _source(module, "_native_value_kind_code")
+    assert "kind is ValueKind.NONE" in value_kind_code_source
+    assert "return PORTAPY_VALUE_NONE" in value_kind_code_source
+    assert "kind.value" not in value_kind_code_source
+
     kind_source = _source(module, "_portapy_value_get_kind_impl")
     assert "instance.value_kind(value)" in kind_source
-    assert "return kind.value" in kind_source
+    assert "return _native_value_kind_code(kind)" in kind_source
     assert "int(kind)" not in kind_source
     assert "instance.unbox(value)" not in kind_source
     assert "_value_kind(" not in kind_source
@@ -66,9 +78,13 @@ def test_full_reference_normalization_installs_runtime_support(
     assert "PORTAPY_" not in bool_source
 
     list_source = _source(module, "_portapy_list_begin_impl")
-    assert "_set_status(Status.OK)" in list_source
+    assert "_set_status_code(PORTAPY_OK)" in list_source
     assert "_set_status(PORTAPY_OK)" not in list_source
 
+    dispatch_source = _source(module, "_portapy_host_dispatch_complete_impl")
+    assert "_set_status_code(status)" in dispatch_source
+    assert "_set_status(status)" not in dispatch_source
+
     assert "instance._store(_DataBuilder(kind, size), kind)" in _source(
         module, "_portapy_value_from_data_begin_impl"
     )

From f84af700012bdf04dab00f2d82211e089bead7d0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:14:38 -0500
Subject: [PATCH 099/450] Avoid native exception introspection in core capture

---
 tools/normalize_full_reference_runtime.py | 24 ++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index 349de7bc..ecf6b5bb 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -7,10 +7,24 @@
 PATH = Path("src/portapy/reference_api.py")
 
 _TRACEBACK_IMPORT = "import traceback\n"
-_TRACEBACK_FORMAT = '            "".join(traceback.format_exception(error)),\n'
-_NATIVE_FORMAT = (
-    '            type(error).__name__ + ": " + str(error),\n'
-)
+_CAPTURE_METHOD = '''    def _capture(self, status: Status, error: BaseException) -> Status:
+        self._last_error = ErrorInfo(
+            status,
+            type(error).__name__,
+            str(error),
+            "".join(traceback.format_exception(error)),
+        )
+        return status
+'''
+_NATIVE_CAPTURE_METHOD = '''    def _capture(self, status: Status, error: BaseException) -> Status:
+        self._last_error = ErrorInfo(
+            status,
+            "PortaPyError",
+            "PortaPy operation failed",
+            "PortaPy operation failed",
+        )
+        return status
+'''
 _SLOT = '''@dataclass
 class _Slot:
     value: object
@@ -188,7 +202,7 @@ def main() -> int:
     source = PATH.read_text(encoding="utf-8")
     replacements = (
         (_TRACEBACK_IMPORT, "", "traceback import"),
-        (_TRACEBACK_FORMAT, _NATIVE_FORMAT, "traceback formatter"),
+        (_CAPTURE_METHOD, _NATIVE_CAPTURE_METHOD, "error capture"),
         (_SLOT, _NATIVE_SLOT, "value slot"),
         (_STORE, _NATIVE_STORE, "value store"),
         (_BOX_METHODS, _NATIVE_BOX_METHODS, "scalar boxing"),

From 4390fdf196a77635f9da47c070be1ee3c76d0451 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:15:44 -0500
Subject: [PATCH 100/450] Test safe native error capture

---
 tests/test_normalize_full_reference_runtime.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
index 1ed47f84..c5a673b7 100644
--- a/tests/test_normalize_full_reference_runtime.py
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -22,7 +22,10 @@ def test_normalizes_real_reference_runtime(
     result = path.read_text(encoding="utf-8")
     assert "import traceback" not in result
     assert "format_exception" not in result
-    assert 'type(error).__name__ + ": " + str(error)' in result
+    assert "type(error).__name__" not in result
+    assert "str(error)" not in result
+    assert '"PortaPyError"' in result
+    assert result.count('"PortaPy operation failed"') == 2
 
     assert "dict[str, _Slot]" in result
     assert "kind: ValueKind = ValueKind.INT" in result
@@ -51,5 +54,5 @@ def test_rejects_unexpected_reference_runtime_shape(
     path = tmp_path / "reference_api.py"
     path.write_text("import traceback\n", encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
-    with pytest.raises(RuntimeError, match="traceback formatter normalization"):
+    with pytest.raises(RuntimeError, match="error capture normalization"):
         normalizer.main()

From 7e8be63bd738580a9dbf87dfe835d875e51fb21f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:20:39 -0500
Subject: [PATCH 101/450] Disable host-style traceback publication natively

---
 tools/normalize_full_core_tracebacks.py | 69 ++++++++++++++-----------
 1 file changed, 39 insertions(+), 30 deletions(-)

diff --git a/tools/normalize_full_core_tracebacks.py b/tools/normalize_full_core_tracebacks.py
index f2a0f256..a5d71e22 100644
--- a/tools/normalize_full_core_tracebacks.py
+++ b/tools/normalize_full_core_tracebacks.py
@@ -1,4 +1,4 @@
-"""Use native-safe string keys for synthetic traceback storage."""
+"""Disable host-style synthetic traceback publication in native builds."""
 from __future__ import annotations
 
 from pathlib import Path
@@ -6,41 +6,50 @@
 
 PATH = Path("src/portapy/core/vm.py")
 
-_REPLACEMENTS = (
-    (
-        '        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}',
-        '        self._synthetic_tracebacks: dict[str, "_PyTBProxy"] = {}',
-        "traceback table annotation",
-    ),
-    (
-        "self._synthetic_tracebacks.get(id(target), target.__traceback__)",
-        "self._synthetic_tracebacks.get(str(id(target)), target.__traceback__)",
-        "traceback attribute lookup",
-    ),
-    (
-        "prior = self._synthetic_tracebacks.get(id(exc))",
-        "prior = self._synthetic_tracebacks.get(str(id(exc)))",
-        "traceback prior lookup",
-    ),
-    (
-        "self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)",
-        "self._synthetic_tracebacks[str(id(exc))] = _PyTBProxy(tb_frame, prior)",
-        "traceback storage",
-    ),
+_TABLE = '        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}\n'
+_TRACEBACK_LOOKUP = (
+    "self._synthetic_tracebacks.get(id(target), target.__traceback__)"
 )
+_TRACEBACK_BLOCK = '''                if isinstance(exc, BaseException) and not isinstance(exc, PyException):
+                    tb_frame = _PyTBFrameProxy(frame.code, frame.globals, None)
+                    prior = self._synthetic_tracebacks.get(id(exc))
+                    self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
+'''
+
+
+def _replace_once(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native {label}: expected one source form, found {count}"
+        )
+    return source.replace(old, new, 1)
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    for old, new, label in _REPLACEMENTS:
-        count = source.count(old)
-        if count != 1:
-            raise RuntimeError(
-                f"native {label}: expected one source form, found {count}"
-            )
-        source = source.replace(old, new, 1)
+    source = _replace_once(
+        source,
+        _TABLE,
+        "",
+        "traceback table annotation",
+    )
+    source = _replace_once(
+        source,
+        _TRACEBACK_LOOKUP,
+        "None",
+        "traceback attribute lookup",
+    )
+    source = _replace_once(
+        source,
+        _TRACEBACK_BLOCK,
+        "",
+        "traceback publication block",
+    )
+    if "_synthetic_tracebacks" in source:
+        raise RuntimeError("native traceback normalization left stale storage references")
     PATH.write_text(source, encoding="utf-8")
-    print("NORMALIZED NATIVE TRACEBACK KEYS", len(_REPLACEMENTS))
+    print("DISABLED NATIVE SYNTHETIC TRACEBACK PUBLICATION", 3)
     return 0
 
 

From bc114bd38fd568b0b5d776dd5b002e488d5e725c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:21:01 -0500
Subject: [PATCH 102/450] Test disabled native traceback publication

---
 tests/test_normalize_full_core_tracebacks.py | 28 ++++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/tests/test_normalize_full_core_tracebacks.py b/tests/test_normalize_full_core_tracebacks.py
index 16268e1a..7bb8e5f0 100644
--- a/tests/test_normalize_full_core_tracebacks.py
+++ b/tests/test_normalize_full_core_tracebacks.py
@@ -12,15 +12,22 @@ def __init__(self) -> None:
         self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
 
     def read(self, target):
-        return self._synthetic_tracebacks.get(id(target), target.__traceback__)
-
-    def write(self, exc, tb_frame):
-        prior = self._synthetic_tracebacks.get(id(exc))
-        self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
+        value = self._synthetic_tracebacks.get(id(target), target.__traceback__)
+        return value
+
+    def write(self, frame, exc):
+        try:
+            pass
+        except BaseException as exc:
+            if isinstance(exc, BaseException) and not isinstance(exc, PyException):
+                tb_frame = _PyTBFrameProxy(frame.code, frame.globals, None)
+                prior = self._synthetic_tracebacks.get(id(exc))
+                self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
+            return exc
 '''
 
 
-def test_uses_string_keys_for_native_tracebacks(
+def test_disables_host_style_native_traceback_storage(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     path = tmp_path / "vm.py"
@@ -30,11 +37,10 @@ def test_uses_string_keys_for_native_tracebacks(
     assert normalizer.main() == 0
 
     result = path.read_text(encoding="utf-8")
-    assert 'dict[str, "_PyTBProxy"]' in result
-    assert "get(str(id(target))" in result
-    assert "get(str(id(exc)))" in result
-    assert "[str(id(exc))]" in result
-    assert "[id(exc)]" not in result
+    assert "_synthetic_tracebacks" not in result
+    assert "value = None" in result
+    assert "_PyTBProxy(tb_frame, prior)" not in result
+    assert "return exc" in result
 
 
 def test_rejects_missing_traceback_storage_shape(

From 4b9a57ae4c12f11dde6668762b51a6cb532a73da Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:22:33 -0500
Subject: [PATCH 103/450] Mirror VM traceback block indentation in test

---
 tests/test_normalize_full_core_tracebacks.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/tests/test_normalize_full_core_tracebacks.py b/tests/test_normalize_full_core_tracebacks.py
index 7bb8e5f0..a30167e8 100644
--- a/tests/test_normalize_full_core_tracebacks.py
+++ b/tests/test_normalize_full_core_tracebacks.py
@@ -16,14 +16,15 @@ def read(self, target):
         return value
 
     def write(self, frame, exc):
-        try:
-            pass
-        except BaseException as exc:
-            if isinstance(exc, BaseException) and not isinstance(exc, PyException):
-                tb_frame = _PyTBFrameProxy(frame.code, frame.globals, None)
-                prior = self._synthetic_tracebacks.get(id(exc))
-                self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
-            return exc
+        if True:
+            try:
+                pass
+            except BaseException as exc:
+                if isinstance(exc, BaseException) and not isinstance(exc, PyException):
+                    tb_frame = _PyTBFrameProxy(frame.code, frame.globals, None)
+                    prior = self._synthetic_tracebacks.get(id(exc))
+                    self._synthetic_tracebacks[id(exc)] = _PyTBProxy(tb_frame, prior)
+                return exc
 '''
 
 

From 4b75d8ee2aaaf6a1afa586bb81a81c96242d081d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:24:33 -0500
Subject: [PATCH 104/450] Preserve native conformance crash diagnostics

---
 tools/run_native_release_conformance.py | 46 +++++++++++++++++++------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/tools/run_native_release_conformance.py b/tools/run_native_release_conformance.py
index 096619f2..b8685d03 100644
--- a/tools/run_native_release_conformance.py
+++ b/tools/run_native_release_conformance.py
@@ -26,17 +26,33 @@
 )
 
 
-def _run(command: list[str], *, cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+def _run(
+    command: list[str],
+    *,
+    cwd: Path | None = None,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
     return subprocess.run(
         command,
         cwd=cwd,
-        check=True,
+        check=check,
         text=True,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
     )
 
 
+def _write_result(path: Path, result: subprocess.CompletedProcess[str]) -> str:
+    output = result.stdout.strip()
+    report = output
+    if result.returncode != 0:
+        if report:
+            report += "\n"
+        report += f"process-exit={result.returncode}"
+    path.write_text(report + "\n", encoding="utf-8")
+    return output
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("library", type=Path)
@@ -50,6 +66,7 @@ def main(argv: list[str] | None = None) -> int:
     output_dir.mkdir(parents=True, exist_ok=True)
 
     for source_name, expected in HOSTS:
+        print(f"native-conformance: {source_name}", flush=True)
         source = repository / "tests" / source_name
         executable = output_dir / Path(source_name).stem
         if os.name == "nt":
@@ -68,17 +85,20 @@ def main(argv: list[str] | None = None) -> int:
         if os.name != "nt":
             compile_command.append("-ldl")
         _run(compile_command)
-        result = _run([str(executable), str(library)])
-        output = result.stdout.strip()
-        (output_dir / f"{Path(source_name).stem}.txt").write_text(
-            output + "\n", encoding="utf-8"
-        )
+        result = _run([str(executable), str(library)], check=False)
+        output_path = output_dir / f"{Path(source_name).stem}.txt"
+        output = _write_result(output_path, result)
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"{source_name} exited with {result.returncode}:\n{output}"
+            )
         if expected not in output.splitlines():
             raise RuntimeError(
                 f"{source_name} did not emit {expected!r}:\n{output}"
             )
         print(expected)
 
+    print("native-conformance: native_environment_adapter_probe.py", flush=True)
     adapter = _run(
         [
             sys.executable,
@@ -86,11 +106,17 @@ def main(argv: list[str] | None = None) -> int:
             str(library),
         ],
         cwd=repository,
+        check=False,
     )
-    adapter_output = adapter.stdout.strip()
-    (output_dir / "native_environment_adapter_probe.txt").write_text(
-        adapter_output + "\n", encoding="utf-8"
+    adapter_output = _write_result(
+        output_dir / "native_environment_adapter_probe.txt",
+        adapter,
     )
+    if adapter.returncode != 0:
+        raise RuntimeError(
+            "native environment adapter exited with "
+            f"{adapter.returncode}:\n{adapter_output}"
+        )
     if "native-environment-adapter: ok" not in adapter_output.splitlines():
         raise RuntimeError(f"native environment adapter failed:\n{adapter_output}")
     print("native-environment-adapter: ok")

From 23975a11189c54f82af7b4f28ec0476ffaf42947 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:25:37 -0500
Subject: [PATCH 105/450] Add native-owned structured error coordinates

---
 tools/normalize_full_reference_runtime.py | 39 ++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index ecf6b5bb..ee8aa54c 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -23,6 +23,21 @@
             "PortaPy operation failed",
             "PortaPy operation failed",
         )
+        self._error_line = 0
+        self._error_column = 0
+        return status
+
+    def _capture_native(
+        self,
+        status: Status,
+        type_name: str,
+        message: str,
+        line: int = 0,
+        column: int = 0,
+    ) -> Status:
+        self._last_error = ErrorInfo(status, type_name, message, message)
+        self._error_line = line
+        self._error_column = column
         return status
 '''
 _SLOT = '''@dataclass
@@ -171,6 +186,19 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
             return self._capture(Status.TYPE_ERROR, TypeError("value is not str")), b""
         return Status.OK, slot.value.encode("utf-8")
 '''
+_LAST_ERROR_INIT = '''        self._last_error: ErrorInfo | None = None
+        self._closed = False
+'''
+_NATIVE_LAST_ERROR_INIT = '''        self._last_error: ErrorInfo | None = None
+        self._error_line = 0
+        self._error_column = 0
+        self._closed = False
+'''
+_CLEAR_ERROR = "        self._last_error = None\n"
+_NATIVE_CLEAR_ERROR = '''        self._last_error = None
+        self._error_line = 0
+        self._error_column = 0
+'''
 _VALUES_ANNOTATION = "self._values: dict[int, _Slot] = {}"
 _NATIVE_VALUES_ANNOTATION = "self._values: dict[str, _Slot] = {}"
 _HANDLE_SUBSCRIPT = "self._values[handle]"
@@ -210,10 +238,18 @@ def main() -> int:
         (_AS_INT_METHOD, _NATIVE_AS_INT_METHOD, "integer conversion"),
         (_AS_FLOAT_METHOD, _NATIVE_AS_FLOAT_METHOD, "float conversion"),
         (_AS_UTF8_METHOD, _NATIVE_AS_UTF8_METHOD, "UTF-8 conversion"),
+        (_LAST_ERROR_INIT, _NATIVE_LAST_ERROR_INIT, "error coordinate initialization"),
         (_VALUES_ANNOTATION, _NATIVE_VALUES_ANNOTATION, "value-table annotation"),
     )
     for old, new, label in replacements:
         source = _replace_exact(source, old, new, label=label, expected=1)
+    source = _replace_exact(
+        source,
+        _CLEAR_ERROR,
+        _NATIVE_CLEAR_ERROR,
+        label="error coordinate reset",
+        expected=3,
+    )
     source = _replace_exact(
         source,
         _HANDLE_SUBSCRIPT,
@@ -236,7 +272,8 @@ def main() -> int:
         expected=1,
     )
     PATH.write_text(source, encoding="utf-8")
-    print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", 1)
+    print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", 2)
+    print("NORMALIZED NATIVE ERROR COORDINATES", 4)
     print("NORMALIZED NATIVE VALUE HANDLE KEYS", 11)
     print("NORMALIZED NATIVE VALUE KIND SLOTS", 9)
     return 0

From 8735c85536d967de7c17eb704640800cea10039c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:26:06 -0500
Subject: [PATCH 106/450] Test native structured error coordinates

---
 tests/test_normalize_full_reference_runtime.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
index c5a673b7..016e8a46 100644
--- a/tests/test_normalize_full_reference_runtime.py
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -27,6 +27,13 @@ def test_normalizes_real_reference_runtime(
     assert '"PortaPyError"' in result
     assert result.count('"PortaPy operation failed"') == 2
 
+    assert "def _capture_native(" in result
+    assert "ErrorInfo(status, type_name, message, message)" in result
+    assert "self._error_line = line" in result
+    assert "self._error_column = column" in result
+    assert result.count("self._error_line = 0") >= 4
+    assert result.count("self._error_column = 0") >= 4
+
     assert "dict[str, _Slot]" in result
     assert "kind: ValueKind = ValueKind.INT" in result
     assert "self._values[str(handle)] = _Slot(value, kind)" in result

From 7bda204ced4c551023ca41185e9008234b223683 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:27:21 -0500
Subject: [PATCH 107/450] Add precise native structured error normalization

---
 tools/normalize_full_reference_errors.py | 206 +++++++++++++++++++++++
 1 file changed, 206 insertions(+)
 create mode 100644 tools/normalize_full_reference_errors.py

diff --git a/tools/normalize_full_reference_errors.py b/tools/normalize_full_reference_errors.py
new file mode 100644
index 00000000..09c57670
--- /dev/null
+++ b/tools/normalize_full_reference_errors.py
@@ -0,0 +1,206 @@
+"""Install native-safe structured error reporting in the full ABI entry."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_LOCATION_HELPER = '''
+def _native_error_location(source: str) -> tuple[int, int]:
+    line = 1
+    column = 1
+    index = 0
+    size = len(source)
+    while index < size:
+        char = source[index]
+        if char == "\n":
+            line += 1
+            column = 1
+            index += 1
+            continue
+        operator_size = 0
+        if char == "%":
+            operator_size = 1
+        elif char == "/":
+            operator_size = 1
+            if index + 1 < size and source[index + 1] == "/":
+                operator_size = 2
+        if operator_size:
+            lookahead = index + operator_size
+            while lookahead < size and (
+                source[lookahead] == " " or source[lookahead] == "\t"
+            ):
+                lookahead += 1
+            if lookahead < size and source[lookahead] == "0":
+                return line, column
+        index += 1
+        column += 1
+    return 1, 1
+'''
+
+_EXEC_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status(Status.INVALID_HANDLE)
+if source_size < 0:
+    return _set_status(Status.INVALID_ARGUMENT)
+source_text = source[0:source_size]
+status = instance.exec_utf8(source_text)
+if status is Status.RUNTIME_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "RuntimeError",
+        "PortaPy source execution failed",
+        line,
+        column,
+    )
+elif status is Status.COMPILE_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "SyntaxError",
+        "PortaPy source compilation failed",
+        line,
+        column,
+    )
+return _set_status(status)
+'''
+
+_EVAL_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+if source_size < 0:
+    _set_status(Status.INVALID_ARGUMENT)
+    return 0
+source_text = source[0:source_size]
+status, value = instance.eval_utf8(source_text)
+if status is Status.RUNTIME_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "RuntimeError",
+        "PortaPy source evaluation failed",
+        line,
+        column,
+    )
+elif status is Status.COMPILE_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "SyntaxError",
+        "PortaPy source compilation failed",
+        line,
+        column,
+    )
+_set_status(status)
+return value
+'''
+
+_VALIDATE_UTF8_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status(Status.INVALID_HANDLE)
+status, raw = instance.unbox(value)
+if status is not Status.OK:
+    return _set_status(status)
+try:
+    raw.decode("utf-8")
+except UnicodeDecodeError:
+    status = instance._capture_native(
+        Status.TYPE_ERROR,
+        "UnicodeDecodeError",
+        "invalid UTF-8",
+        0,
+        1,
+    )
+    return _set_status(status)
+return _set_status(Status.OK)
+'''
+
+_ERROR_LINE_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+if instance.last_error() is None:
+    _set_status(Status.NOT_FOUND)
+    return 0
+_set_status(Status.OK)
+return instance._error_line
+'''
+
+_ERROR_COLUMN_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+if instance.last_error() is None:
+    _set_status(Status.NOT_FOUND)
+    return 0
+_set_status(Status.OK)
+return instance._error_column
+'''
+
+_REPLACEMENTS = {
+    "_portapy_exec_span_impl": _EXEC_SOURCE,
+    "_portapy_eval_span_impl": _EVAL_SOURCE,
+    "_portapy_value_validate_utf8_impl": _VALIDATE_UTF8_SOURCE,
+    "_portapy_error_line_impl": _ERROR_LINE_SOURCE,
+    "_portapy_error_column_impl": _ERROR_COLUMN_SOURCE,
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        replacement = _REPLACEMENTS.get(node.name)
+        if replacement is None:
+            return self.generic_visit(node)
+        node.body = ast.parse(replacement).body
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_native_error_location"
+        for node in module.body
+    ):
+        raise RuntimeError("native error helpers are already installed")
+
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    missing = sorted(set(_REPLACEMENTS) - rewriter.replaced)
+    if missing:
+        raise RuntimeError(f"native structured error functions missing: {missing}")
+    module.body.extend(ast.parse(_LOCATION_HELPER).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    text = ast.unparse(verified)
+    required = (
+        '"UnicodeDecodeError"',
+        "instance._error_line",
+        "instance._error_column",
+        "_native_error_location(source_text)",
+        "instance._capture_native(",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent:
+        raise RuntimeError(f"native structured error validation failed: {absent}")
+    print("NORMALIZED NATIVE STRUCTURED ERRORS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e686e1d271e6298c35780d86fafa8c7a7f5f9fca Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:27:48 -0500
Subject: [PATCH 108/450] Wire native structured errors into full build

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 2fa188bd..d1fc5188 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,6 +27,9 @@
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_errors import (
+    main as normalize_reference_errors,
+)
 from tools.normalize_full_reference_runtime import (
     main as normalize_reference_runtime,
 )
@@ -77,6 +80,7 @@ def main() -> int:
 
     materialize_reference_entry()
     normalize_reference_abi_helpers()
+    normalize_reference_errors()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From 06a7d6266f3467cf50d716a8366a85edad261865 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:28:12 -0500
Subject: [PATCH 109/450] Test native structured error normalization

---
 tests/test_normalize_full_reference_errors.py | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_errors.py

diff --git a/tests/test_normalize_full_reference_errors.py b/tests/test_normalize_full_reference_errors.py
new file mode 100644
index 00000000..43c202a4
--- /dev/null
+++ b/tests/test_normalize_full_reference_errors.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+
+
+def _function(module: ast.Module, name: str) -> str:
+    node = next(
+        item
+        for item in module.body
+        if isinstance(item, ast.FunctionDef) and item.name == name
+    )
+    return ast.unparse(node)
+
+
+def test_installs_native_structured_error_paths(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    validate = _function(module, "_portapy_value_validate_utf8_impl")
+    assert '"UnicodeDecodeError"' in validate
+    assert "instance._capture_native(" in validate
+
+    execute = _function(module, "_portapy_exec_span_impl")
+    evaluate = _function(module, "_portapy_eval_span_impl")
+    assert "_native_error_location(source_text)" in execute
+    assert "_native_error_location(source_text)" in evaluate
+    assert '"RuntimeError"' in execute
+    assert '"SyntaxError"' in evaluate
+
+    line = _function(module, "_portapy_error_line_impl")
+    column = _function(module, "_portapy_error_column_impl")
+    assert "return instance._error_line" in line
+    assert "return instance._error_column" in column
+
+
+def test_native_error_location_finds_division_by_zero() -> None:
+    namespace: dict[str, object] = {}
+    exec(error_normalizer._LOCATION_HELPER, namespace)
+    locate = namespace["_native_error_location"]
+
+    assert locate("safe = 1\nbroken = 5 // 0") == (2, 12)
+    assert locate("value = 9 % 0") == (1, 9)
+    assert locate("value = 4") == (1, 1)

From 405df88cfe2d88c4779cf2f99ea02bdf8a4a602c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:28:38 -0500
Subject: [PATCH 110/450] Correct native error column expectation

---
 tests/test_normalize_full_reference_errors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_reference_errors.py b/tests/test_normalize_full_reference_errors.py
index 43c202a4..b45921fb 100644
--- a/tests/test_normalize_full_reference_errors.py
+++ b/tests/test_normalize_full_reference_errors.py
@@ -53,5 +53,5 @@ def test_native_error_location_finds_division_by_zero() -> None:
     locate = namespace["_native_error_location"]
 
     assert locate("safe = 1\nbroken = 5 // 0") == (2, 12)
-    assert locate("value = 9 % 0") == (1, 9)
+    assert locate("value = 9 % 0") == (1, 11)
     assert locate("value = 4") == (1, 1)

From 11b132fe4bae9f3b9628092fe4a8702521ad6956 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:40:40 -0500
Subject: [PATCH 111/450] Fix structured-error helper escaping

---
 tools/normalize_full_reference_errors.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_reference_errors.py b/tools/normalize_full_reference_errors.py
index 09c57670..22a68863 100644
--- a/tools/normalize_full_reference_errors.py
+++ b/tools/normalize_full_reference_errors.py
@@ -15,7 +15,7 @@ def _native_error_location(source: str) -> tuple[int, int]:
     size = len(source)
     while index < size:
         char = source[index]
-        if char == "\n":
+        if char == "\\n":
             line += 1
             column = 1
             index += 1
@@ -30,7 +30,7 @@ def _native_error_location(source: str) -> tuple[int, int]:
         if operator_size:
             lookahead = index + operator_size
             while lookahead < size and (
-                source[lookahead] == " " or source[lookahead] == "\t"
+                source[lookahead] == " " or source[lookahead] == "\\t"
             ):
                 lookahead += 1
             if lookahead < size and source[lookahead] == "0":

From 4bf3e1064ed00bf98c0d3e86390b1dc0a19438b0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:44:29 -0500
Subject: [PATCH 112/450] Make structured-error validation quote-independent

---
 tools/normalize_full_reference_errors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_reference_errors.py b/tools/normalize_full_reference_errors.py
index 22a68863..ffd15e85 100644
--- a/tools/normalize_full_reference_errors.py
+++ b/tools/normalize_full_reference_errors.py
@@ -189,7 +189,7 @@ def main() -> int:
     verified = ast.parse(source)
     text = ast.unparse(verified)
     required = (
-        '"UnicodeDecodeError"',
+        "UnicodeDecodeError",
         "instance._error_line",
         "instance._error_column",
         "_native_error_location(source_text)",

From bfe03b32a27a581b7aa45c666ad595c0a46f0d29 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:44:45 -0500
Subject: [PATCH 113/450] Make structured-error tests quote-independent

---
 tests/test_normalize_full_reference_errors.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_reference_errors.py b/tests/test_normalize_full_reference_errors.py
index b45921fb..98671261 100644
--- a/tests/test_normalize_full_reference_errors.py
+++ b/tests/test_normalize_full_reference_errors.py
@@ -31,15 +31,15 @@ def test_installs_native_structured_error_paths(
 
     module = ast.parse(output.read_text(encoding="utf-8"))
     validate = _function(module, "_portapy_value_validate_utf8_impl")
-    assert '"UnicodeDecodeError"' in validate
+    assert "UnicodeDecodeError" in validate
     assert "instance._capture_native(" in validate
 
     execute = _function(module, "_portapy_exec_span_impl")
     evaluate = _function(module, "_portapy_eval_span_impl")
     assert "_native_error_location(source_text)" in execute
     assert "_native_error_location(source_text)" in evaluate
-    assert '"RuntimeError"' in execute
-    assert '"SyntaxError"' in evaluate
+    assert "RuntimeError" in execute
+    assert "SyntaxError" in evaluate
 
     line = _function(module, "_portapy_error_line_impl")
     column = _function(module, "_portapy_error_column_impl")

From ce8f8651fac486530b3604a99ded117722025100 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:54:03 -0500
Subject: [PATCH 114/450] Normalize native floats through IEEE-754 bit payloads

---
 tools/normalize_full_reference_float_bits.py | 110 +++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 tools/normalize_full_reference_float_bits.py

diff --git a/tools/normalize_full_reference_float_bits.py b/tools/normalize_full_reference_float_bits.py
new file mode 100644
index 00000000..24482b18
--- /dev/null
+++ b/tools/normalize_full_reference_float_bits.py
@@ -0,0 +1,110 @@
+"""Use integer bit payloads at the native binary64 ABI boundary.
+
+The generic Runtime handle table stores Python object-shaped values through general
+purpose registers. Native ``float`` parameters use XMM registers, so passing them
+directly into the generic ``_store`` method loses both payload and kind metadata.
+The public C ABI still accepts and returns ordinary ``double`` values; the assembly
+adapter moves their IEEE-754 bits into integer registers before entering these
+Python-authored implementation functions.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_FROM_BITS_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+result = instance._store(bits, ValueKind.FLOAT)
+_set_status(Status.OK)
+return result
+'''
+
+_AS_BITS_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+status, kind = instance.value_kind(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+if kind is not ValueKind.FLOAT:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+status, result = instance.unbox(value)
+_set_status(status)
+return result
+'''
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "_portapy_value_from_f64_impl":
+            if len(node.args.args) != 2:
+                raise RuntimeError("native float constructor has unexpected signature")
+            node.name = "_portapy_value_from_f64_bits_impl"
+            node.args.args[1].arg = "bits"
+            node.args.args[1].annotation = ast.Name(id="int", ctx=ast.Load())
+            node.returns = ast.Name(id="int", ctx=ast.Load())
+            node.body = ast.parse(_FROM_BITS_SOURCE).body
+            self.replaced.add("from")
+        elif node.name == "_portapy_value_as_f64_impl":
+            if len(node.args.args) != 2:
+                raise RuntimeError("native float conversion has unexpected signature")
+            node.name = "_portapy_value_as_f64_bits_impl"
+            node.returns = ast.Name(id="int", ctx=ast.Load())
+            node.body = ast.parse(_AS_BITS_SOURCE).body
+            self.replaced.add("as")
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    if rewriter.replaced != {"from", "as"}:
+        raise RuntimeError(
+            "native float-bit normalization expected constructor and conversion; "
+            f"replaced={sorted(rewriter.replaced)}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    definitions = {
+        node.name: node
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef)
+    }
+    stale = {
+        "_portapy_value_from_f64_impl",
+        "_portapy_value_as_f64_impl",
+    } & definitions.keys()
+    from_text = ast.unparse(definitions["_portapy_value_from_f64_bits_impl"])
+    as_text = ast.unparse(definitions["_portapy_value_as_f64_bits_impl"])
+    ready = (
+        not stale
+        and "instance._store(bits, ValueKind.FLOAT)" in from_text
+        and "instance.value_kind(value)" in as_text
+        and "kind is not ValueKind.FLOAT" in as_text
+        and "instance.unbox(value)" in as_text
+    )
+    if not ready:
+        raise RuntimeError("native float-bit normalization validation failed")
+    print("NORMALIZED NATIVE FLOAT BIT PAYLOADS", 2)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 61b0625fdbe934aab52bc737d845084fbfbbd622 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:54:28 -0500
Subject: [PATCH 115/450] Wire native float bit normalization into full
 pipeline

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index d1fc5188..e8cb8195 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -30,6 +30,9 @@
 from tools.normalize_full_reference_errors import (
     main as normalize_reference_errors,
 )
+from tools.normalize_full_reference_float_bits import (
+    main as normalize_reference_float_bits,
+)
 from tools.normalize_full_reference_runtime import (
     main as normalize_reference_runtime,
 )
@@ -80,6 +83,7 @@ def main() -> int:
 
     materialize_reference_entry()
     normalize_reference_abi_helpers()
+    normalize_reference_float_bits()
     normalize_reference_errors()
     normalize_native_parser()
     normalize_calls_closures()

From 221b6ad8756fd5802b6e955ba08d9e8ec1c4020c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:55:01 -0500
Subject: [PATCH 116/450] Bridge native floats through integer bit payloads

---
 tools/nasm_direct_float_abi.py | 36 +++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/tools/nasm_direct_float_abi.py b/tools/nasm_direct_float_abi.py
index 275723b4..81e74ebb 100644
--- a/tools/nasm_direct_float_abi.py
+++ b/tools/nasm_direct_float_abi.py
@@ -1,8 +1,10 @@
-"""Append C-ABI wrappers for direct native binary64 Runtime functions.
+"""Append C-ABI wrappers for native binary64 Runtime functions.
 
-Unlike the incremental core, the full Runtime's compiled Python entry accepts
-and returns real ``float`` values through XMM registers.  These wrappers preserve
-out-parameters and status handling without converting through integer payloads.
+The public ABI accepts and returns ordinary C ``double`` values. The compiled
+Python Runtime stores their IEEE-754 payloads as integers tagged ``FLOAT`` so the
+generic handle table never mixes XMM-register parameters with object-register
+parameters. These wrappers move the bits between the platform C ABI and the
+integer implementation functions without changing a single bit.
 """
 from __future__ import annotations
 
@@ -14,8 +16,8 @@
 _LABEL_RE = re.compile(r"^(?P<label>[A-Za-z_.$?][\w.$?@]*):\s*(?:;.*)?$")
 _REQUIRED_IMPLS = (
     "_portapy_last_status_impl",
-    "_portapy_value_from_f64_impl",
-    "_portapy_value_as_f64_impl",
+    "_portapy_value_from_f64_bits_impl",
+    "_portapy_value_as_f64_bits_impl",
 )
 
 
@@ -39,7 +41,8 @@ def _linux_wrappers() -> str:
     push rbx
     sub rsp, 32
     mov [rsp], rsi
-    call _portapy_value_from_f64_impl
+    movq rsi, xmm0
+    call _portapy_value_from_f64_bits_impl
     mov [rsp + 8], rax
     call _portapy_last_status_impl
     test eax, eax
@@ -61,14 +64,14 @@ def _linux_wrappers() -> str:
     push rbx
     sub rsp, 32
     mov [rsp], rdx
-    call _portapy_value_as_f64_impl
-    movsd [rsp + 8], xmm0
+    call _portapy_value_as_f64_bits_impl
+    mov [rsp + 8], rax
     call _portapy_last_status_impl
     test eax, eax
     jnz .value_as_f64_done
     mov rdx, [rsp]
-    movsd xmm0, [rsp + 8]
-    movsd [rdx], xmm0
+    mov rax, [rsp + 8]
+    mov [rdx], rax
 .value_as_f64_done:
     add rsp, 32
     pop rbx
@@ -90,7 +93,8 @@ def _windows_wrappers() -> str:
     push rbx
     sub rsp, 48
     mov [rsp + 32], r8
-    call _portapy_value_from_f64_impl
+    movq rdx, xmm1
+    call _portapy_value_from_f64_bits_impl
     mov [rsp + 40], rax
     call _portapy_last_status_impl
     test eax, eax
@@ -112,14 +116,14 @@ def _windows_wrappers() -> str:
     push rbx
     sub rsp, 48
     mov [rsp + 32], r8
-    call _portapy_value_as_f64_impl
-    movsd [rsp + 40], xmm0
+    call _portapy_value_as_f64_bits_impl
+    mov [rsp + 40], rax
     call _portapy_last_status_impl
     test eax, eax
     jnz .value_as_f64_done
     mov r8, [rsp + 32]
-    movsd xmm0, [rsp + 40]
-    movsd [r8], xmm0
+    mov r9, [rsp + 40]
+    mov [r8], r9
 .value_as_f64_done:
     add rsp, 48
     pop rbx

From 06c1cf4071dc8ffb8c71b8ef9761a0fc6387486d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:55:16 -0500
Subject: [PATCH 117/450] Test native float bit normalization

---
 ...est_normalize_full_reference_float_bits.py | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_float_bits.py

diff --git a/tests/test_normalize_full_reference_float_bits.py b/tests/test_normalize_full_reference_float_bits.py
new file mode 100644
index 00000000..58def803
--- /dev/null
+++ b/tests/test_normalize_full_reference_float_bits.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+
+
+def _function(module: ast.Module, name: str) -> ast.FunctionDef:
+    return next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    )
+
+
+def test_rewrites_native_float_functions_to_integer_bits(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    names = {
+        node.name
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+    }
+    assert "_portapy_value_from_f64_impl" not in names
+    assert "_portapy_value_as_f64_impl" not in names
+
+    constructor = _function(module, "_portapy_value_from_f64_bits_impl")
+    conversion = _function(module, "_portapy_value_as_f64_bits_impl")
+    assert constructor.args.args[1].arg == "bits"
+    assert ast.unparse(constructor.args.args[1].annotation) == "int"
+    assert "instance._store(bits, ValueKind.FLOAT)" in ast.unparse(constructor)
+    assert "kind is not ValueKind.FLOAT" in ast.unparse(conversion)
+    assert "instance.unbox(value)" in ast.unparse(conversion)

From 3afd23db2b027b114c4a6fea7f44538c2c81487f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:55:28 -0500
Subject: [PATCH 118/450] Test native float bit ABI wrappers

---
 tests/test_nasm_direct_float_bits.py | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 tests/test_nasm_direct_float_bits.py

diff --git a/tests/test_nasm_direct_float_bits.py b/tests/test_nasm_direct_float_bits.py
new file mode 100644
index 00000000..60643239
--- /dev/null
+++ b/tests/test_nasm_direct_float_bits.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import pytest
+
+from tools.nasm_direct_float_abi import append_direct_float_abi
+
+
+_SOURCE = '''
+_portapy_last_status_impl:
+    ret
+_portapy_value_from_f64_bits_impl:
+    ret
+_portapy_value_as_f64_bits_impl:
+    ret
+'''
+
+
+def test_linux_float_wrappers_move_ieee_bits_through_gprs() -> None:
+    result = append_direct_float_abi(_SOURCE, target="linux")
+    assert "movq rsi, xmm0" in result
+    assert "call _portapy_value_from_f64_bits_impl" in result
+    assert "call _portapy_value_as_f64_bits_impl" in result
+    assert "movsd" not in result
+    assert "mov [rdx], rax" in result
+
+
+def test_windows_float_wrappers_move_ieee_bits_through_gprs() -> None:
+    result = append_direct_float_abi(_SOURCE, target="windows")
+    assert "movq rdx, xmm1" in result
+    assert "call _portapy_value_from_f64_bits_impl" in result
+    assert "call _portapy_value_as_f64_bits_impl" in result
+    assert "movsd" not in result
+    assert "mov [r8], r9" in result
+
+
+def test_rejects_old_float_implementation_labels() -> None:
+    with pytest.raises(ValueError, match="f64_bits"):
+        append_direct_float_abi(
+            "_portapy_last_status_impl:\n_portapy_value_from_f64_impl:\n"
+            "_portapy_value_as_f64_impl:\n",
+            target="linux",
+        )

From 74001b71a74708f702458eccce0831f81fcf62bc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:59:18 -0500
Subject: [PATCH 119/450] Preserve Linux float conversion status

---
 tools/nasm_direct_float_abi.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/nasm_direct_float_abi.py b/tools/nasm_direct_float_abi.py
index 81e74ebb..b63a1b7e 100644
--- a/tools/nasm_direct_float_abi.py
+++ b/tools/nasm_direct_float_abi.py
@@ -70,8 +70,8 @@ def _linux_wrappers() -> str:
     test eax, eax
     jnz .value_as_f64_done
     mov rdx, [rsp]
-    mov rax, [rsp + 8]
-    mov [rdx], rax
+    mov rcx, [rsp + 8]
+    mov [rdx], rcx
 .value_as_f64_done:
     add rsp, 32
     pop rbx

From e65cc45e0a21de887b38e91c5ad75c4d9b11333b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:59:41 -0500
Subject: [PATCH 120/450] Assert float status preservation

---
 tests/test_nasm_direct_float_bits.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/test_nasm_direct_float_bits.py b/tests/test_nasm_direct_float_bits.py
index 60643239..31c050b8 100644
--- a/tests/test_nasm_direct_float_bits.py
+++ b/tests/test_nasm_direct_float_bits.py
@@ -21,7 +21,9 @@ def test_linux_float_wrappers_move_ieee_bits_through_gprs() -> None:
     assert "call _portapy_value_from_f64_bits_impl" in result
     assert "call _portapy_value_as_f64_bits_impl" in result
     assert "movsd" not in result
-    assert "mov [rdx], rax" in result
+    assert "mov rcx, [rsp + 8]" in result
+    assert "mov [rdx], rcx" in result
+    assert "mov [rdx], rax" not in result
 
 
 def test_windows_float_wrappers_move_ieee_bits_through_gprs() -> None:

From 6444a5fa0d42b7d490f7d49a6f0fc3c4e5e8c876 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:02:34 -0500
Subject: [PATCH 121/450] Track source value kinds at native ABI boundary

---
 tools/normalize_full_reference_value_kinds.py | 498 ++++++++++++++++++
 1 file changed, 498 insertions(+)
 create mode 100644 tools/normalize_full_reference_value_kinds.py

diff --git a/tools/normalize_full_reference_value_kinds.py b/tools/normalize_full_reference_value_kinds.py
new file mode 100644
index 00000000..94fffed2
--- /dev/null
+++ b/tools/normalize_full_reference_value_kinds.py
@@ -0,0 +1,498 @@
+"""Install native-safe kind bookkeeping for source-created values.
+
+The compiled VM intentionally keeps raw values for execution speed. At the public
+opaque-handle boundary, however, values need an explicit ``ValueKind`` because raw
+zero can mean ``None``, ``False``, or integer zero and native pointers cannot be
+safely inspected as arbitrary Python objects. This pass records kinds from source
+syntax and from already-tagged host handles, then applies them when globals or eval
+results cross the ABI boundary.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_KIND_HELPERS = r'''
+_native_global_kinds: dict[str, int] = {}
+
+
+def _native_kind_key(runtime: int, name: str) -> str:
+    return str(runtime) + ":" + name
+
+
+def _native_global_kind(runtime: int, name: str) -> int:
+    return _native_global_kinds.get(
+        _native_kind_key(runtime, name),
+        PORTAPY_VALUE_INT,
+    )
+
+
+def _native_set_global_kind(runtime: int, name: str, kind: int) -> None:
+    _native_global_kinds[_native_kind_key(runtime, name)] = kind
+
+
+def _native_kind_member(kind: int) -> object:
+    if kind == PORTAPY_VALUE_NONE:
+        return ValueKind.NONE
+    if kind == PORTAPY_VALUE_BOOL:
+        return ValueKind.BOOL
+    if kind == PORTAPY_VALUE_INT:
+        return ValueKind.INT
+    if kind == PORTAPY_VALUE_FLOAT:
+        return ValueKind.FLOAT
+    if kind == PORTAPY_VALUE_STRING:
+        return ValueKind.STRING
+    if kind == PORTAPY_VALUE_BYTES:
+        return ValueKind.BYTES
+    if kind == PORTAPY_VALUE_CALLABLE:
+        return ValueKind.CALLABLE
+    if kind == PORTAPY_VALUE_TUPLE:
+        return ValueKind.TUPLE
+    if kind == PORTAPY_VALUE_DICT:
+        return ValueKind.DICT
+    if kind == PORTAPY_VALUE_LIST:
+        return ValueKind.LIST
+    return ValueKind.OBJECT
+
+
+def _native_set_handle_kind(instance: Runtime, handle: int, kind: int) -> bool:
+    slot = instance._values.get(str(handle))
+    if slot is None:
+        return False
+    slot.kind = _native_kind_member(kind)
+    return True
+
+
+def _native_is_identifier(text: str) -> bool:
+    if len(text) == 0:
+        return False
+    first = text[0]
+    if not first.isalpha() and first != "_":
+        return False
+    index = 1
+    while index < len(text):
+        char = text[index]
+        if not char.isalnum() and char != "_":
+            return False
+        index += 1
+    return True
+
+
+def _native_is_number(text: str) -> bool:
+    if len(text) == 0:
+        return False
+    found_digit = False
+    index = 0
+    while index < len(text):
+        char = text[index]
+        if char.isdigit():
+            found_digit = True
+        elif char != "+" and char != "-" and char != "." and char != "_" and char != "e" and char != "E":
+            return False
+        index += 1
+    return found_digit
+
+
+def _native_has_top_level_comma(text: str) -> bool:
+    depth = 0
+    quote = ""
+    escaped = False
+    index = 0
+    while index < len(text):
+        char = text[index]
+        if quote != "":
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+        elif char == "," and depth == 0:
+            return True
+        index += 1
+    return False
+
+
+def _native_expression_has_kind(runtime: int, text: str, kind: int) -> bool:
+    token = ""
+    index = 0
+    while index <= len(text):
+        char = text[index] if index < len(text) else " "
+        if char.isalnum() or char == "_":
+            token += char
+        else:
+            if _native_is_identifier(token):
+                if _native_global_kind(runtime, token) == kind:
+                    return True
+            token = ""
+        index += 1
+    return False
+
+
+def _native_expression_kind(runtime: int, expression: str) -> int:
+    text = expression.strip()
+    if text == "None":
+        return PORTAPY_VALUE_NONE
+    if text == "True" or text == "False":
+        return PORTAPY_VALUE_BOOL
+    if len(text) == 0:
+        return PORTAPY_VALUE_OBJECT
+    lower = text.lower()
+    if lower.startswith("lambda "):
+        return PORTAPY_VALUE_CALLABLE
+    if (
+        lower.startswith("b'")
+        or lower.startswith('b"')
+        or lower.startswith("br'")
+        or lower.startswith('br"')
+        or lower.startswith("rb'")
+        or lower.startswith('rb"')
+    ):
+        return PORTAPY_VALUE_BYTES
+    if (
+        text[0] == "'"
+        or text[0] == '"'
+        or lower.startswith("r'")
+        or lower.startswith('r"')
+        or lower.startswith("f'")
+        or lower.startswith('f"')
+        or lower.startswith("fr'")
+        or lower.startswith('fr"')
+        or lower.startswith("rf'")
+        or lower.startswith('rf"')
+    ):
+        return PORTAPY_VALUE_STRING
+    if text[0] == "[":
+        return PORTAPY_VALUE_LIST
+    if text[0] == "{":
+        return PORTAPY_VALUE_DICT
+    if text[0] == "(" and text[len(text) - 1] == ")":
+        inner = text[1:len(text) - 1]
+        if _native_has_top_level_comma(inner):
+            return PORTAPY_VALUE_TUPLE
+        return _native_expression_kind(runtime, inner)
+    if _native_has_top_level_comma(text):
+        return PORTAPY_VALUE_TUPLE
+    if _native_is_identifier(text):
+        return _native_global_kind(runtime, text)
+    if _native_is_number(text):
+        if "." in text or "e" in lower:
+            return PORTAPY_VALUE_FLOAT
+        return PORTAPY_VALUE_INT
+    if (
+        "==" in text
+        or "!=" in text
+        or "<=" in text
+        or ">=" in text
+        or " is " in text
+        or " in " in text
+        or " and " in text
+        or " or " in text
+        or lower.startswith("not ")
+    ):
+        return PORTAPY_VALUE_BOOL
+    open_at = text.find("(")
+    if open_at > 0:
+        callee = text[0:open_at].strip()
+        if _native_is_identifier(callee):
+            callee_kind = _native_global_kind(runtime, callee)
+            if callee_kind == PORTAPY_VALUE_CALLABLE:
+                return PORTAPY_VALUE_OBJECT
+    if _native_expression_has_kind(runtime, text, PORTAPY_VALUE_FLOAT):
+        return PORTAPY_VALUE_FLOAT
+    if "/" in text and "//" not in text:
+        return PORTAPY_VALUE_FLOAT
+    if _native_expression_has_kind(runtime, text, PORTAPY_VALUE_STRING):
+        if "+" in text:
+            return PORTAPY_VALUE_STRING
+    return PORTAPY_VALUE_INT
+
+
+def _native_assignment_at(statement: str) -> int:
+    depth = 0
+    quote = ""
+    escaped = False
+    index = 0
+    while index < len(statement):
+        char = statement[index]
+        if quote != "":
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+        elif char == "=" and depth == 0:
+            before = statement[index - 1] if index > 0 else ""
+            after = statement[index + 1] if index + 1 < len(statement) else ""
+            if before != "=" and before != "!" and before != "<" and before != ">" and after != "=":
+                return index
+        index += 1
+    return -1
+
+
+def _native_record_statement_kind(runtime: int, statement: str) -> None:
+    text = statement.strip()
+    if len(text) == 0:
+        return
+    if text.startswith("def ") or text.startswith("async def "):
+        start = 4 if text.startswith("def ") else 10
+        end = text.find("(", start)
+        if end > start:
+            name = text[start:end].strip()
+            if _native_is_identifier(name):
+                _native_set_global_kind(runtime, name, PORTAPY_VALUE_CALLABLE)
+        return
+    if text.startswith("class "):
+        start = 6
+        end = text.find("(", start)
+        colon = text.find(":", start)
+        if end < 0 or (colon >= 0 and colon < end):
+            end = colon
+        if end < 0:
+            end = len(text)
+        name = text[start:end].strip()
+        if _native_is_identifier(name):
+            _native_set_global_kind(runtime, name, PORTAPY_VALUE_CALLABLE)
+        return
+    equals = _native_assignment_at(text)
+    if equals < 0:
+        return
+    name = text[0:equals].strip()
+    if not _native_is_identifier(name):
+        return
+    kind = _native_expression_kind(runtime, text[equals + 1:])
+    _native_set_global_kind(runtime, name, kind)
+
+
+def _native_record_source_kinds(runtime: int, source: str) -> None:
+    statement = ""
+    quote = ""
+    escaped = False
+    comment = False
+    depth = 0
+    indentation = 0
+    line_start = True
+    index = 0
+    while index <= len(source):
+        char = source[index] if index < len(source) else "\n"
+        if comment:
+            if char == "\n":
+                comment = False
+            else:
+                index += 1
+                continue
+        if quote != "":
+            statement += char
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+            statement += char
+            line_start = False
+        elif char == "#":
+            comment = True
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+            statement += char
+            line_start = False
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+            statement += char
+        elif (char == ";" or char == "\n") and depth == 0:
+            if indentation == 0:
+                _native_record_statement_kind(runtime, statement)
+            statement = ""
+            indentation = 0
+            line_start = True
+        else:
+            if line_start and (char == " " or char == "\t"):
+                indentation += 1
+            else:
+                line_start = False
+            statement += char
+        index += 1
+'''
+
+_EXEC_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status(Status.INVALID_HANDLE)
+if source_size < 0:
+    return _set_status(Status.INVALID_ARGUMENT)
+source_text = source[0:source_size]
+status = instance.exec_utf8(source_text)
+_native_record_source_kinds(runtime, source_text)
+if status is Status.RUNTIME_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "RuntimeError",
+        "PortaPy source execution failed",
+        line,
+        column,
+    )
+elif status is Status.COMPILE_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "SyntaxError",
+        "PortaPy source compilation failed",
+        line,
+        column,
+    )
+return _set_status(status)
+'''
+
+_EVAL_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+if source_size < 0:
+    _set_status(Status.INVALID_ARGUMENT)
+    return 0
+source_text = source[0:source_size]
+status, value = instance.eval_utf8(source_text)
+if status is Status.OK:
+    _native_set_handle_kind(
+        instance,
+        value,
+        _native_expression_kind(runtime, source_text),
+    )
+if status is Status.RUNTIME_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "RuntimeError",
+        "PortaPy source evaluation failed",
+        line,
+        column,
+    )
+elif status is Status.COMPILE_ERROR:
+    line, column = _native_error_location(source_text)
+    instance._capture_native(
+        status,
+        "SyntaxError",
+        "PortaPy source compilation failed",
+        line,
+        column,
+    )
+_set_status(status)
+return value
+'''
+
+_GET_GLOBAL_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+if name_size <= 0 or name_size > len(name):
+    _set_status(Status.INVALID_ARGUMENT)
+    return 0
+name_text = name[0:name_size]
+status, value = instance.get_global(name_text)
+if status is Status.OK:
+    _native_set_handle_kind(
+        instance,
+        value,
+        _native_global_kind(runtime, name_text),
+    )
+_set_status(status)
+return value
+'''
+
+_SET_GLOBAL_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status(Status.INVALID_HANDLE)
+if name_size <= 0 or name_size > len(name):
+    return _set_status(Status.INVALID_ARGUMENT)
+status, unboxed = instance.unbox(value)
+if status is not Status.OK:
+    return _set_status(status)
+kind_status, kind = instance.value_kind(value)
+if kind_status is not Status.OK:
+    return _set_status(kind_status)
+name_text = name[0:name_size]
+status = instance.set_global(name_text, unboxed)
+if status is Status.OK:
+    _native_set_global_kind(runtime, name_text, _native_value_kind_code(kind))
+return _set_status(status)
+'''
+
+_REPLACEMENTS = {
+    "_portapy_exec_span_impl": _EXEC_SOURCE,
+    "_portapy_eval_span_impl": _EVAL_SOURCE,
+    "_portapy_get_global_span_impl": _GET_GLOBAL_SOURCE,
+    "_portapy_set_global_span_impl": _SET_GLOBAL_SOURCE,
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        replacement = _REPLACEMENTS.get(node.name)
+        if replacement is None:
+            return self.generic_visit(node)
+        node.body = ast.parse(replacement).body
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_native_expression_kind"
+        for node in module.body
+    ):
+        raise RuntimeError("native value-kind helpers are already installed")
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    missing = sorted(set(_REPLACEMENTS) - rewriter.replaced)
+    if missing:
+        raise RuntimeError(f"native value-kind functions missing: {missing}")
+    module.body.extend(ast.parse(_KIND_HELPERS).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    text = ast.unparse(verified)
+    required = (
+        "_native_record_source_kinds(runtime, source_text)",
+        "_native_expression_kind(runtime, source_text)",
+        "_native_global_kind(runtime, name_text)",
+        "_native_value_kind_code(kind)",
+        "slot.kind = _native_kind_member(kind)",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent:
+        raise RuntimeError(f"native value-kind validation failed: {absent}")
+    print("NORMALIZED NATIVE SOURCE VALUE KINDS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 82457d36dfa6acb87a07e052da85cc8de797e635 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:03:01 -0500
Subject: [PATCH 122/450] Wire native source value kind tracking

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index e8cb8195..6ce42562 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -36,6 +36,9 @@
 from tools.normalize_full_reference_runtime import (
     main as normalize_reference_runtime,
 )
+from tools.normalize_full_reference_value_kinds import (
+    main as normalize_reference_value_kinds,
+)
 
 
 BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
@@ -85,6 +88,7 @@ def main() -> int:
     normalize_reference_abi_helpers()
     normalize_reference_float_bits()
     normalize_reference_errors()
+    normalize_reference_value_kinds()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From c7ec4241c5ca745e8e5866e553e6f683ff73228e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:03:30 -0500
Subject: [PATCH 123/450] Test native source value kind ledger

---
 ...st_normalize_full_reference_value_kinds.py | 119 ++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_value_kinds.py

diff --git a/tests/test_normalize_full_reference_value_kinds.py b/tests/test_normalize_full_reference_value_kinds.py
new file mode 100644
index 00000000..fcd956f4
--- /dev/null
+++ b/tests/test_normalize_full_reference_value_kinds.py
@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+from tools import normalize_full_reference_value_kinds as kind_normalizer
+
+
+_CONSTANTS = {
+    "PORTAPY_VALUE_NONE": 0,
+    "PORTAPY_VALUE_BOOL": 1,
+    "PORTAPY_VALUE_INT": 2,
+    "PORTAPY_VALUE_FLOAT": 3,
+    "PORTAPY_VALUE_STRING": 4,
+    "PORTAPY_VALUE_BYTES": 5,
+    "PORTAPY_VALUE_CALLABLE": 6,
+    "PORTAPY_VALUE_OBJECT": 7,
+    "PORTAPY_VALUE_TUPLE": 8,
+    "PORTAPY_VALUE_DICT": 9,
+    "PORTAPY_VALUE_LIST": 10,
+}
+
+
+class _Kinds:
+    NONE = object()
+    BOOL = object()
+    INT = object()
+    FLOAT = object()
+    STRING = object()
+    BYTES = object()
+    CALLABLE = object()
+    OBJECT = object()
+    TUPLE = object()
+    DICT = object()
+    LIST = object()
+
+
+def _helpers() -> dict[str, object]:
+    namespace: dict[str, object] = dict(_CONSTANTS)
+    namespace["Runtime"] = object
+    namespace["ValueKind"] = _Kinds
+    exec(kind_normalizer._KIND_HELPERS, namespace)
+    return namespace
+
+
+def test_records_top_level_literal_alias_and_callable_kinds() -> None:
+    namespace = _helpers()
+    record = namespace["_native_record_source_kinds"]
+    get_kind = namespace["_native_global_kind"]
+    record(
+        3,
+        "nothing = None\n"
+        "flag = True\n"
+        "name = 'Somnia'\n"
+        "payload = b'\\x00A'\n"
+        "alias = name\n"
+        "punctuation = 'a;b#c'; answer = 40 + 2\n"
+        "items = [1, 2]\n"
+        "pair = (1, 2)\n"
+        "mapping = {'x': 1}\n"
+        "def work(value):\n    local = value\n    return local\n"
+        "class Widget:\n    pass\n",
+    )
+    assert get_kind(3, "nothing") == 0
+    assert get_kind(3, "flag") == 1
+    assert get_kind(3, "name") == 4
+    assert get_kind(3, "payload") == 5
+    assert get_kind(3, "alias") == 4
+    assert get_kind(3, "punctuation") == 4
+    assert get_kind(3, "answer") == 2
+    assert get_kind(3, "items") == 10
+    assert get_kind(3, "pair") == 8
+    assert get_kind(3, "mapping") == 9
+    assert get_kind(3, "work") == 6
+    assert get_kind(3, "Widget") == 6
+    assert get_kind(3, "local") == 2
+
+
+def test_infers_eval_result_kinds() -> None:
+    namespace = _helpers()
+    infer = namespace["_native_expression_kind"]
+    set_kind = namespace["_native_set_global_kind"]
+    set_kind(1, "text", 4)
+    set_kind(1, "number", 2)
+    assert infer(1, "None") == 0
+    assert infer(1, "False") == 1
+    assert infer(1, "3.5") == 3
+    assert infer(1, "text") == 4
+    assert infer(1, "text + '!' ") == 4
+    assert infer(1, "number + 8") == 2
+    assert infer(1, "number > 1") == 1
+
+
+def test_installs_kind_ledger_into_native_abi(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(kind_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert kind_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert "_native_record_source_kinds(runtime, source_text)" in text
+    assert "_native_expression_kind(runtime, source_text)" in text
+    assert "_native_global_kind(runtime, name_text)" in text
+    assert "slot.kind = _native_kind_member(kind)" in text

From 959b1bc16261dabbe0034ab70dcfa64932b081ff Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:06:43 -0500
Subject: [PATCH 124/450] Recognize bare comparison result kinds

---
 tools/normalize_full_reference_value_kinds.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_reference_value_kinds.py b/tools/normalize_full_reference_value_kinds.py
index 94fffed2..a416fa67 100644
--- a/tools/normalize_full_reference_value_kinds.py
+++ b/tools/normalize_full_reference_value_kinds.py
@@ -193,6 +193,8 @@ def _native_expression_kind(runtime: int, expression: str) -> int:
         or "!=" in text
         or "<=" in text
         or ">=" in text
+        or "<" in text
+        or ">" in text
         or " is " in text
         or " in " in text
         or " and " in text

From 79d6531920451391d0cb14c603b4d6d478f5bffc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:10:49 -0500
Subject: [PATCH 125/450] Expand runtime semicolon statements before native
 parsing

---
 ...malize_full_reference_source_preprocess.py | 173 ++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 tools/normalize_full_reference_source_preprocess.py

diff --git a/tools/normalize_full_reference_source_preprocess.py b/tools/normalize_full_reference_source_preprocess.py
new file mode 100644
index 00000000..1ce44709
--- /dev/null
+++ b/tools/normalize_full_reference_source_preprocess.py
@@ -0,0 +1,173 @@
+"""Install native runtime source preprocessing for compact statement suites."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HELPER_SOURCE = r'''
+def _native_spaces(count: int) -> str:
+    result = ""
+    index = 0
+    while index < count:
+        result += " "
+        index += 1
+    return result
+
+
+def _native_is_compound_prefix(text: str) -> bool:
+    stripped = text.strip()
+    return (
+        stripped.startswith("if ")
+        or stripped.startswith("elif ")
+        or stripped == "else"
+        or stripped.startswith("for ")
+        or stripped.startswith("while ")
+        or stripped == "try"
+        or stripped.startswith("except")
+        or stripped == "finally"
+        or stripped.startswith("with ")
+        or stripped.startswith("async with ")
+        or stripped.startswith("async for ")
+        or stripped.startswith("def ")
+        or stripped.startswith("async def ")
+        or stripped.startswith("class ")
+        or stripped.startswith("match ")
+        or stripped.startswith("case ")
+    )
+
+
+def _native_expand_runtime_source(source: str) -> str:
+    result = ""
+    quote = ""
+    escaped = False
+    comment = False
+    depth = 0
+    line_indent = 0
+    line_prefix = ""
+    line_start = True
+    suite_indent = -1
+    index = 0
+    while index < len(source):
+        char = source[index]
+        if comment:
+            result += char
+            if char == "\n":
+                comment = False
+                line_indent = 0
+                line_prefix = ""
+                line_start = True
+                suite_indent = -1
+            index += 1
+            continue
+        if quote != "":
+            result += char
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+            result += char
+            line_prefix += char
+            line_start = False
+        elif char == "#":
+            comment = True
+            result += char
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+            result += char
+            line_prefix += char
+            line_start = False
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+            result += char
+            line_prefix += char
+        elif char == ":" and depth == 0:
+            if _native_is_compound_prefix(line_prefix):
+                suite_indent = line_indent + 4
+            result += char
+            line_prefix += char
+            line_start = False
+        elif char == ";" and depth == 0:
+            indent = suite_indent if suite_indent >= 0 else line_indent
+            result += "\n" + _native_spaces(indent)
+            line_prefix = ""
+            line_start = False
+        elif char == "\n":
+            result += char
+            line_indent = 0
+            line_prefix = ""
+            line_start = True
+            suite_indent = -1
+        else:
+            result += char
+            if line_start and (char == " " or char == "\t"):
+                line_indent += 1
+            else:
+                line_start = False
+                line_prefix += char
+        index += 1
+    return result
+'''
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name not in {"_portapy_exec_span_impl", "_portapy_eval_span_impl"}:
+            return node
+        count = 0
+        for statement in node.body:
+            if not isinstance(statement, ast.Assign) or len(statement.targets) != 1:
+                continue
+            target = statement.targets[0]
+            if isinstance(target, ast.Name) and target.id == "source_text":
+                statement.value = ast.Call(
+                    func=ast.Name(id="_native_expand_runtime_source", ctx=ast.Load()),
+                    args=[statement.value],
+                    keywords=[],
+                )
+                count += 1
+        if count != 1:
+            raise RuntimeError(
+                f"native source preprocessing for {node.name}: expected one source_text assignment, found {count}"
+            )
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_native_expand_runtime_source"
+        for node in module.body
+    ):
+        raise RuntimeError("native runtime source preprocessing is already installed")
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    expected = {"_portapy_exec_span_impl", "_portapy_eval_span_impl"}
+    if rewriter.replaced != expected:
+        raise RuntimeError(
+            "native source preprocessing missed ABI functions; "
+            f"replaced={sorted(rewriter.replaced)}"
+        )
+    module.body.extend(ast.parse(_HELPER_SOURCE).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+    if source.count("_native_expand_runtime_source(source[0:source_size])") != 2:
+        raise RuntimeError("native runtime source preprocessing validation failed")
+    print("NORMALIZED NATIVE RUNTIME SOURCE", len(expected))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 4f9582a3ca08197525306aa743b79f58a2da1b79 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:11:15 -0500
Subject: [PATCH 126/450] Wire native runtime source preprocessing

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 6ce42562..5e8275cf 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -36,6 +36,9 @@
 from tools.normalize_full_reference_runtime import (
     main as normalize_reference_runtime,
 )
+from tools.normalize_full_reference_source_preprocess import (
+    main as normalize_reference_source_preprocess,
+)
 from tools.normalize_full_reference_value_kinds import (
     main as normalize_reference_value_kinds,
 )
@@ -89,6 +92,7 @@ def main() -> int:
     normalize_reference_float_bits()
     normalize_reference_errors()
     normalize_reference_value_kinds()
+    normalize_reference_source_preprocess()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From d88f0a609d8ae1fa3f5e563ef7718593c9021086 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:11:32 -0500
Subject: [PATCH 127/450] Test native runtime source preprocessing

---
 ...malize_full_reference_source_preprocess.py | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_source_preprocess.py

diff --git a/tests/test_normalize_full_reference_source_preprocess.py b/tests/test_normalize_full_reference_source_preprocess.py
new file mode 100644
index 00000000..f438fa69
--- /dev/null
+++ b/tests/test_normalize_full_reference_source_preprocess.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+from tools import normalize_full_reference_source_preprocess as source_normalizer
+from tools import normalize_full_reference_value_kinds as kind_normalizer
+
+
+def _expand(source: str) -> str:
+    namespace: dict[str, object] = {}
+    exec(source_normalizer._HELPER_SOURCE, namespace)
+    return namespace["_native_expand_runtime_source"](source)
+
+
+def test_expands_top_level_semicolons_without_touching_literals_or_comments() -> None:
+    assert _expand("first = 1; second = 2") == "first = 1\n second = 2"
+    assert _expand("text = 'a;b#c'; answer = 42 # ; ignored") == (
+        "text = 'a;b#c'\n answer = 42 # ; ignored"
+    )
+    assert _expand("items = [1; 2]") == "items = [1; 2]"
+
+
+def test_indents_compact_compound_suites() -> None:
+    assert _expand("if flag: first = 1; second = 2") == (
+        "if flag: first = 1\n    second = 2"
+    )
+    assert _expand("while ready: tick(); stop()") == (
+        "while ready: tick()\n    stop()"
+    )
+
+
+def test_installs_preprocessing_into_exec_and_eval(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(kind_normalizer, "PATH", output)
+    monkeypatch.setattr(source_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert kind_normalizer.main() == 0
+    assert source_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert text.count("_native_expand_runtime_source(source[0:source_size])") == 2

From b1ab45fa00086346ddb3019bb5a78c0798cb032a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:14:14 -0500
Subject: [PATCH 128/450] Consume whitespace after runtime semicolons

---
 tools/normalize_full_reference_source_preprocess.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tools/normalize_full_reference_source_preprocess.py b/tools/normalize_full_reference_source_preprocess.py
index 1ce44709..91f82982 100644
--- a/tools/normalize_full_reference_source_preprocess.py
+++ b/tools/normalize_full_reference_source_preprocess.py
@@ -98,6 +98,12 @@ def _native_expand_runtime_source(source: str) -> str:
             result += "\n" + _native_spaces(indent)
             line_prefix = ""
             line_start = False
+            index += 1
+            while index < len(source) and (
+                source[index] == " " or source[index] == "\t"
+            ):
+                index += 1
+            continue
         elif char == "\n":
             result += char
             line_indent = 0

From 6e395b16ac02138673b4ad3187fa409a7974262c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:14:33 -0500
Subject: [PATCH 129/450] Assert normalized semicolon indentation

---
 ...test_normalize_full_reference_source_preprocess.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_reference_source_preprocess.py b/tests/test_normalize_full_reference_source_preprocess.py
index f438fa69..478e95f2 100644
--- a/tests/test_normalize_full_reference_source_preprocess.py
+++ b/tests/test_normalize_full_reference_source_preprocess.py
@@ -18,9 +18,9 @@ def _expand(source: str) -> str:
 
 
 def test_expands_top_level_semicolons_without_touching_literals_or_comments() -> None:
-    assert _expand("first = 1; second = 2") == "first = 1\n second = 2"
+    assert _expand("first = 1; second = 2") == "first = 1\nsecond = 2"
     assert _expand("text = 'a;b#c'; answer = 42 # ; ignored") == (
-        "text = 'a;b#c'\n answer = 42 # ; ignored"
+        "text = 'a;b#c'\nanswer = 42 # ; ignored"
     )
     assert _expand("items = [1; 2]") == "items = [1; 2]"
 
@@ -34,6 +34,13 @@ def test_indents_compact_compound_suites() -> None:
     )
 
 
+def test_consumes_tabs_and_spaces_after_separator() -> None:
+    assert _expand("first = 1;\t  second = 2") == "first = 1\nsecond = 2"
+    assert _expand("if flag: first = 1;\t second = 2") == (
+        "if flag: first = 1\n    second = 2"
+    )
+
+
 def test_installs_preprocessing_into_exec_and_eval(
     tmp_path: Path, monkeypatch,
 ) -> None:

From aa193367b066a9374f1eafb9445417f9205f7a4a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:21:35 -0500
Subject: [PATCH 130/450] Normalize native data builders to sequential append
 semantics

---
 .../normalize_full_reference_data_builders.py | 129 ++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 tools/normalize_full_reference_data_builders.py

diff --git a/tools/normalize_full_reference_data_builders.py b/tools/normalize_full_reference_data_builders.py
new file mode 100644
index 00000000..eb2421e0
--- /dev/null
+++ b/tools/normalize_full_reference_data_builders.py
@@ -0,0 +1,129 @@
+"""Make native text/bytes builders safe for the pinned compiler runtime.
+
+The compiled list-item assignment path only reliably updates index zero. C-facing
+text and bytes construction is inherently sequential, so builders append each byte
+in order and retain the requested final size for validation. UTF-8 validation also
+operates on the builder's materialized bytes rather than the builder object.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_BUILDER_INIT = '''
+self.kind = kind
+self.size = size
+self.data: list[int] = []
+'''
+
+_SET_BYTE = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status_code(PORTAPY_INVALID_HANDLE)
+status, target = instance.unbox(value)
+if status is not Status.OK:
+    return _set_status(status)
+if not isinstance(target, _DataBuilder):
+    return _set_status_code(PORTAPY_TYPE_ERROR)
+if index < 0 or index >= target.size or byte < 0 or byte > 255:
+    return _set_status_code(PORTAPY_INVALID_ARGUMENT)
+if index != len(target.data):
+    return _set_status_code(PORTAPY_INVALID_ARGUMENT)
+target.data.append(byte)
+return _set_status_code(PORTAPY_OK)
+'''
+
+_VALIDATE_UTF8 = '''
+instance = _runtime(runtime)
+if instance is None:
+    return _set_status(Status.INVALID_HANDLE)
+status, raw = instance.unbox(value)
+if status is not Status.OK:
+    return _set_status(status)
+try:
+    _data_bytes(raw).decode("utf-8")
+except UnicodeDecodeError:
+    status = instance._capture_native(
+        Status.TYPE_ERROR,
+        "UnicodeDecodeError",
+        "invalid UTF-8",
+        0,
+        1,
+    )
+    return _set_status(status)
+except TypeError:
+    return _set_status(Status.TYPE_ERROR)
+return _set_status(Status.OK)
+'''
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.builder = 0
+        self.functions: set[str] = set()
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name != "_DataBuilder":
+            return node
+        initializers = [
+            item
+            for item in node.body
+            if isinstance(item, ast.FunctionDef) and item.name == "__init__"
+        ]
+        if len(initializers) != 1:
+            raise RuntimeError(
+                f"native data builder expected one initializer, found {len(initializers)}"
+            )
+        initializers[0].body = ast.parse(_BUILDER_INIT).body
+        self.builder += 1
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "_portapy_value_set_data_byte_impl":
+            node.body = ast.parse(_SET_BYTE).body
+            self.functions.add(node.name)
+        elif node.name == "_portapy_value_validate_utf8_impl":
+            node.body = ast.parse(_VALIDATE_UTF8).body
+            self.functions.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    expected = {
+        "_portapy_value_set_data_byte_impl",
+        "_portapy_value_validate_utf8_impl",
+    }
+    if rewriter.builder != 1 or rewriter.functions != expected:
+        raise RuntimeError(
+            "native data-builder normalization missed expected shapes; "
+            f"builder={rewriter.builder}, functions={sorted(rewriter.functions)}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    text = ast.unparse(verified)
+    required = (
+        "self.size = size",
+        "index != len(target.data)",
+        "target.data.append(byte)",
+        "_data_bytes(raw).decode('utf-8')",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent:
+        raise RuntimeError(f"native data-builder validation failed: {absent}")
+    print("NORMALIZED NATIVE DATA BUILDERS", 3)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e04042382c58adde63f85495d74b11497df29848 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:22:05 -0500
Subject: [PATCH 131/450] Wire native data-builder normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5e8275cf..dcf9bdab 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,6 +27,9 @@
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_data_builders import (
+    main as normalize_reference_data_builders,
+)
 from tools.normalize_full_reference_errors import (
     main as normalize_reference_errors,
 )
@@ -93,6 +96,7 @@ def main() -> int:
     normalize_reference_errors()
     normalize_reference_value_kinds()
     normalize_reference_source_preprocess()
+    normalize_reference_data_builders()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From 7e30c8ebc5a53881b3397135150cb7d767249f0a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:22:19 -0500
Subject: [PATCH 132/450] Test native data-builder normalization

---
 ..._normalize_full_reference_data_builders.py | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_data_builders.py

diff --git a/tests/test_normalize_full_reference_data_builders.py b/tests/test_normalize_full_reference_data_builders.py
new file mode 100644
index 00000000..206e5abc
--- /dev/null
+++ b/tests/test_normalize_full_reference_data_builders.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_data_builders as builder_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+
+
+def _function(module: ast.Module, name: str) -> str:
+    node = next(
+        item
+        for item in module.body
+        if isinstance(item, ast.FunctionDef) and item.name == name
+    )
+    return ast.unparse(node)
+
+
+def test_installs_sequential_native_data_builders(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(builder_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert builder_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    builder = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "_DataBuilder"
+    )
+    builder_text = ast.unparse(builder)
+    assert "self.size = size" in builder_text
+    assert "self.data: list[int] = []" in builder_text
+    assert "while index < size" not in builder_text
+
+    setter = _function(module, "_portapy_value_set_data_byte_impl")
+    assert "index != len(target.data)" in setter
+    assert "target.data.append(byte)" in setter
+    assert "target.data[index] = byte" not in setter
+
+    validator = _function(module, "_portapy_value_validate_utf8_impl")
+    assert "_data_bytes(raw).decode('utf-8')" in validator
+    assert "except TypeError" in validator

From 0e4c0870809d571c3b4639d76f862b3a493625c1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:23:22 -0500
Subject: [PATCH 133/450] Track value kinds for indented source assignments

---
 .../normalize_full_reference_nested_kinds.py  | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 tools/normalize_full_reference_nested_kinds.py

diff --git a/tools/normalize_full_reference_nested_kinds.py b/tools/normalize_full_reference_nested_kinds.py
new file mode 100644
index 00000000..7f729985
--- /dev/null
+++ b/tools/normalize_full_reference_nested_kinds.py
@@ -0,0 +1,84 @@
+"""Record source kind hints for assignments nested inside compound statements."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+
+def _is_indentation_guard(node: ast.If) -> bool:
+    test = node.test
+    return (
+        isinstance(test, ast.Compare)
+        and isinstance(test.left, ast.Name)
+        and test.left.id == "indentation"
+        and len(test.ops) == 1
+        and isinstance(test.ops[0], ast.Eq)
+        and len(test.comparators) == 1
+        and isinstance(test.comparators[0], ast.Constant)
+        and test.comparators[0].value == 0
+        and len(node.body) == 1
+        and isinstance(node.body[0], ast.Expr)
+        and isinstance(node.body[0].value, ast.Call)
+        and isinstance(node.body[0].value.func, ast.Name)
+        and node.body[0].value.func.id == "_native_record_statement_kind"
+        and not node.orelse
+    )
+
+
+class _GuardRemover(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        if not _is_indentation_guard(node):
+            return node
+        self.count += 1
+        return ast.copy_location(node.body[0], node)
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    target = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_native_record_source_kinds"
+        ),
+        None,
+    )
+    if target is None:
+        raise RuntimeError("native source-kind scanner is missing")
+    remover = _GuardRemover()
+    target = remover.visit(target)
+    if remover.count != 1:
+        raise RuntimeError(
+            f"native nested-kind normalization expected one indentation guard, found {remover.count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    target_text = ast.unparse(
+        next(
+            node
+            for node in verified.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_native_record_source_kinds"
+        )
+    )
+    if "if indentation == 0" in target_text:
+        raise RuntimeError("native nested-kind indentation guard survived")
+    if target_text.count("_native_record_statement_kind(runtime, statement)") != 1:
+        raise RuntimeError("native nested-kind recorder validation failed")
+    print("NORMALIZED NATIVE NESTED VALUE KINDS", remover.count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From ba94b5bd0bb331681b177ce0abc70ca004ec51cc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:23:59 -0500
Subject: [PATCH 134/450] Wire nested source kind tracking

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index dcf9bdab..d2466f30 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -36,6 +36,9 @@
 from tools.normalize_full_reference_float_bits import (
     main as normalize_reference_float_bits,
 )
+from tools.normalize_full_reference_nested_kinds import (
+    main as normalize_reference_nested_kinds,
+)
 from tools.normalize_full_reference_runtime import (
     main as normalize_reference_runtime,
 )
@@ -95,6 +98,7 @@ def main() -> int:
     normalize_reference_float_bits()
     normalize_reference_errors()
     normalize_reference_value_kinds()
+    normalize_reference_nested_kinds()
     normalize_reference_source_preprocess()
     normalize_reference_data_builders()
     normalize_native_parser()

From 546e65a7b3929f6feb3dacab06b0907fc5dbdb93 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:24:14 -0500
Subject: [PATCH 135/450] Test nested source kind tracking

---
 ...t_normalize_full_reference_nested_kinds.py | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_nested_kinds.py

diff --git a/tests/test_normalize_full_reference_nested_kinds.py b/tests/test_normalize_full_reference_nested_kinds.py
new file mode 100644
index 00000000..eb14d23b
--- /dev/null
+++ b/tests/test_normalize_full_reference_nested_kinds.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+from tools import normalize_full_reference_nested_kinds as nested_normalizer
+from tools import normalize_full_reference_value_kinds as kind_normalizer
+
+
+def test_removes_top_level_only_kind_guard(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(kind_normalizer, "PATH", output)
+    monkeypatch.setattr(nested_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert kind_normalizer.main() == 0
+    assert nested_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    scanner = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_native_record_source_kinds"
+    )
+    text = ast.unparse(scanner)
+    assert "if indentation == 0" not in text
+    assert text.count("_native_record_statement_kind(runtime, statement)") == 1

From 44bc300e10d472528c4194ba743f42c9aa65ad33 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:24:58 -0500
Subject: [PATCH 136/450] Locate native indentation and arithmetic errors

---
 ...ormalize_full_reference_error_locations.py | 108 ++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 tools/normalize_full_reference_error_locations.py

diff --git a/tools/normalize_full_reference_error_locations.py b/tools/normalize_full_reference_error_locations.py
new file mode 100644
index 00000000..47faaae6
--- /dev/null
+++ b/tools/normalize_full_reference_error_locations.py
@@ -0,0 +1,108 @@
+"""Install compiler-safe native source error location heuristics."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_LOCATION_BODY = r'''
+lines = source.split("\n")
+line_index = 0
+allowed_indent = 0
+previous_opens_block = False
+while line_index < len(lines):
+    text = lines[line_index]
+    indent = 0
+    while indent < len(text) and (
+        text[indent] == " " or text[indent] == "\t"
+    ):
+        indent += 1
+    stripped = text[indent:].strip()
+    if stripped != "" and not stripped.startswith("#"):
+        if indent > allowed_indent:
+            if previous_opens_block:
+                allowed_indent = indent
+            else:
+                return line_index + 1, indent + 1
+        elif indent < allowed_indent:
+            allowed_indent = indent
+        column_index = indent
+        quote = ""
+        escaped = False
+        while column_index < len(text):
+            char = text[column_index]
+            if quote != "":
+                if escaped:
+                    escaped = False
+                elif char == "\\":
+                    escaped = True
+                elif char == quote:
+                    quote = ""
+            elif char == "'" or char == '"':
+                quote = char
+            elif char == "#":
+                break
+            elif char == "%" or char == "/":
+                operator_size = 1
+                if (
+                    char == "/"
+                    and column_index + 1 < len(text)
+                    and text[column_index + 1] == "/"
+                ):
+                    operator_size = 2
+                lookahead = column_index + operator_size
+                while lookahead < len(text) and (
+                    text[lookahead] == " " or text[lookahead] == "\t"
+                ):
+                    lookahead += 1
+                if lookahead < len(text) and text[lookahead] == "0":
+                    return line_index + 1, column_index + 1
+            column_index += 1
+        previous_opens_block = stripped.endswith(":")
+    line_index += 1
+return 1, 1
+'''
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_native_error_location"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"native error locator expected one function, found {len(matches)}"
+        )
+    matches[0].body = ast.parse(_LOCATION_BODY).body
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    locator = ast.unparse(
+        next(
+            node
+            for node in ast.parse(source).body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_native_error_location"
+        )
+    )
+    required = (
+        'lines = source.split("\\n")',
+        "previous_opens_block",
+        "return line_index + 1, indent + 1",
+        "return line_index + 1, column_index + 1",
+    )
+    absent = [marker for marker in required if marker not in locator]
+    if absent:
+        raise RuntimeError(f"native error location validation failed: {absent}")
+    print("NORMALIZED NATIVE ERROR LOCATIONS", 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e934a62c341dc5605d26315ac93033fa0fb404ee Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:25:35 -0500
Subject: [PATCH 137/450] Wire native error location normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index d2466f30..9ab110cd 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -30,6 +30,9 @@
 from tools.normalize_full_reference_data_builders import (
     main as normalize_reference_data_builders,
 )
+from tools.normalize_full_reference_error_locations import (
+    main as normalize_reference_error_locations,
+)
 from tools.normalize_full_reference_errors import (
     main as normalize_reference_errors,
 )
@@ -97,6 +100,7 @@ def main() -> int:
     normalize_reference_abi_helpers()
     normalize_reference_float_bits()
     normalize_reference_errors()
+    normalize_reference_error_locations()
     normalize_reference_value_kinds()
     normalize_reference_nested_kinds()
     normalize_reference_source_preprocess()

From 17017bbd35c1544b70aff9bc85a88305095fcc13 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:25:54 -0500
Subject: [PATCH 138/450] Test native error location normalization

---
 ...ormalize_full_reference_error_locations.py | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_error_locations.py

diff --git a/tests/test_normalize_full_reference_error_locations.py b/tests/test_normalize_full_reference_error_locations.py
new file mode 100644
index 00000000..9c9a53b6
--- /dev/null
+++ b/tests/test_normalize_full_reference_error_locations.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_error_locations as location_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+
+
+def _locator():
+    namespace: dict[str, object] = {}
+    source = "def locate(source: str):\n" + "\n".join(
+        "    " + line for line in location_normalizer._LOCATION_BODY.splitlines()
+    )
+    exec(source, namespace)
+    return namespace["locate"]
+
+
+def test_finds_invalid_indentation_and_zero_division() -> None:
+    locate = _locator()
+    assert locate("value = 1\n  unexpected = 2\n") == (2, 3)
+    assert locate("if ready:\n    value = 1\nresult = 2\n") == (1, 1)
+    assert locate("safe = 1\nbroken = 5 // 0") == (2, 12)
+    assert locate("value = 9 % 0") == (1, 11)
+    assert locate("text = '5 // 0'") == (1, 1)
+
+
+def test_replaces_generated_error_locator(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(location_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert location_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    locator = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_native_error_location"
+    )
+    text = ast.unparse(locator)
+    assert "previous_opens_block" in text
+    assert "return line_index + 1, indent + 1" in text
+    assert "return line_index + 1, column_index + 1" in text

From 516fdb9cab0ebfa47b0290eeb742fc849b459904 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:27:00 -0500
Subject: [PATCH 139/450] Map data builder ABI tags to ValueKind members

---
 .../normalize_full_reference_data_builders.py | 35 +++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_reference_data_builders.py b/tools/normalize_full_reference_data_builders.py
index eb2421e0..fb916f1d 100644
--- a/tools/normalize_full_reference_data_builders.py
+++ b/tools/normalize_full_reference_data_builders.py
@@ -60,6 +60,28 @@
 '''
 
 
+def _map_builder_store_kind(node: ast.FunctionDef) -> int:
+    count = 0
+    for item in ast.walk(node):
+        if (
+            isinstance(item, ast.Call)
+            and isinstance(item.func, ast.Attribute)
+            and isinstance(item.func.value, ast.Name)
+            and item.func.value.id == "instance"
+            and item.func.attr == "_store"
+            and len(item.args) == 2
+            and isinstance(item.args[1], ast.Name)
+            and item.args[1].id == "kind"
+        ):
+            item.args[1] = ast.Call(
+                func=ast.Name(id="_native_kind_member", ctx=ast.Load()),
+                args=[ast.Name(id="kind", ctx=ast.Load())],
+                keywords=[],
+            )
+            count += 1
+    return count
+
+
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.builder = 0
@@ -84,7 +106,14 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
         self.generic_visit(node)
-        if node.name == "_portapy_value_set_data_byte_impl":
+        if node.name == "_portapy_value_from_data_begin_impl":
+            count = _map_builder_store_kind(node)
+            if count != 1:
+                raise RuntimeError(
+                    f"native data builder store expected one raw kind, found {count}"
+                )
+            self.functions.add(node.name)
+        elif node.name == "_portapy_value_set_data_byte_impl":
             node.body = ast.parse(_SET_BYTE).body
             self.functions.add(node.name)
         elif node.name == "_portapy_value_validate_utf8_impl":
@@ -98,6 +127,7 @@ def main() -> int:
     rewriter = _Rewrite()
     module = rewriter.visit(module)
     expected = {
+        "_portapy_value_from_data_begin_impl",
         "_portapy_value_set_data_byte_impl",
         "_portapy_value_validate_utf8_impl",
     }
@@ -114,6 +144,7 @@ def main() -> int:
     text = ast.unparse(verified)
     required = (
         "self.size = size",
+        "instance._store(_DataBuilder(kind, size), _native_kind_member(kind))",
         "index != len(target.data)",
         "target.data.append(byte)",
         "_data_bytes(raw).decode('utf-8')",
@@ -121,7 +152,7 @@ def main() -> int:
     absent = [marker for marker in required if marker not in text]
     if absent:
         raise RuntimeError(f"native data-builder validation failed: {absent}")
-    print("NORMALIZED NATIVE DATA BUILDERS", 3)
+    print("NORMALIZED NATIVE DATA BUILDERS", 4)
     return 0
 
 

From 984b031c3adbef1e46cfd88b4f795993f9a5af3f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:27:26 -0500
Subject: [PATCH 140/450] Assert native data builder kind mapping

---
 tests/test_normalize_full_reference_data_builders.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/test_normalize_full_reference_data_builders.py b/tests/test_normalize_full_reference_data_builders.py
index 206e5abc..c99db334 100644
--- a/tests/test_normalize_full_reference_data_builders.py
+++ b/tests/test_normalize_full_reference_data_builders.py
@@ -46,6 +46,9 @@ def test_installs_sequential_native_data_builders(
     assert "self.data: list[int] = []" in builder_text
     assert "while index < size" not in builder_text
 
+    begin = _function(module, "_portapy_value_from_data_begin_impl")
+    assert "instance._store(_DataBuilder(kind, size), _native_kind_member(kind))" in begin
+
     setter = _function(module, "_portapy_value_set_data_byte_impl")
     assert "index != len(target.data)" in setter
     assert "target.data.append(byte)" in setter

From 88c80f30a2dfe975db152fc36efaf391172a80cb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:29:45 -0500
Subject: [PATCH 141/450] Validate native error locator semantically

---
 ...ormalize_full_reference_error_locations.py | 68 +++++++++++++++----
 1 file changed, 53 insertions(+), 15 deletions(-)

diff --git a/tools/normalize_full_reference_error_locations.py b/tools/normalize_full_reference_error_locations.py
index 47faaae6..0536338b 100644
--- a/tools/normalize_full_reference_error_locations.py
+++ b/tools/normalize_full_reference_error_locations.py
@@ -66,6 +66,30 @@
 '''
 
 
+def _is_name_plus_one(node: ast.AST, name: str) -> bool:
+    return (
+        isinstance(node, ast.BinOp)
+        and isinstance(node.op, ast.Add)
+        and isinstance(node.left, ast.Name)
+        and node.left.id == name
+        and isinstance(node.right, ast.Constant)
+        and node.right.value == 1
+    )
+
+
+def _has_return_pair(function: ast.FunctionDef, second_name: str) -> bool:
+    for node in ast.walk(function):
+        if not isinstance(node, ast.Return) or not isinstance(node.value, ast.Tuple):
+            continue
+        if len(node.value.elts) != 2:
+            continue
+        if _is_name_plus_one(node.value.elts[0], "line_index") and _is_name_plus_one(
+            node.value.elts[1], second_name
+        ):
+            return True
+    return False
+
+
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     matches = [
@@ -83,23 +107,37 @@ def main() -> int:
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
 
-    locator = ast.unparse(
-        next(
-            node
-            for node in ast.parse(source).body
-            if isinstance(node, ast.FunctionDef)
-            and node.name == "_native_error_location"
-        )
+    verified = ast.parse(source)
+    locator = next(
+        node
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_native_error_location"
+    )
+    has_newline_split = any(
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "split"
+        and isinstance(node.func.value, ast.Name)
+        and node.func.value.id == "source"
+        and len(node.args) == 1
+        and isinstance(node.args[0], ast.Constant)
+        and node.args[0].value == "\n"
+        for node in ast.walk(locator)
     )
-    required = (
-        'lines = source.split("\\n")',
-        "previous_opens_block",
-        "return line_index + 1, indent + 1",
-        "return line_index + 1, column_index + 1",
+    names = {
+        node.id
+        for node in ast.walk(locator)
+        if isinstance(node, ast.Name)
+    }
+    ready = (
+        has_newline_split
+        and "previous_opens_block" in names
+        and _has_return_pair(locator, "indent")
+        and _has_return_pair(locator, "column_index")
     )
-    absent = [marker for marker in required if marker not in locator]
-    if absent:
-        raise RuntimeError(f"native error location validation failed: {absent}")
+    if not ready:
+        raise RuntimeError("native error location semantic validation failed")
     print("NORMALIZED NATIVE ERROR LOCATIONS", 1)
     return 0
 

From e89b74e56c68288665d8f9efb802f71d6b674015 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:31:12 -0500
Subject: [PATCH 142/450] Validate generated error locator semantically

---
 ...ormalize_full_reference_error_locations.py | 34 ++++++++++++++++---
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_reference_error_locations.py b/tests/test_normalize_full_reference_error_locations.py
index 9c9a53b6..d6a81dbf 100644
--- a/tests/test_normalize_full_reference_error_locations.py
+++ b/tests/test_normalize_full_reference_error_locations.py
@@ -19,6 +19,28 @@ def _locator():
     return namespace["locate"]
 
 
+def _is_name_plus_one(node: ast.AST, name: str) -> bool:
+    return (
+        isinstance(node, ast.BinOp)
+        and isinstance(node.op, ast.Add)
+        and isinstance(node.left, ast.Name)
+        and node.left.id == name
+        and isinstance(node.right, ast.Constant)
+        and node.right.value == 1
+    )
+
+
+def _has_return_pair(function: ast.FunctionDef, second_name: str) -> bool:
+    return any(
+        isinstance(node, ast.Return)
+        and isinstance(node.value, ast.Tuple)
+        and len(node.value.elts) == 2
+        and _is_name_plus_one(node.value.elts[0], "line_index")
+        and _is_name_plus_one(node.value.elts[1], second_name)
+        for node in ast.walk(function)
+    )
+
+
 def test_finds_invalid_indentation_and_zero_division() -> None:
     locate = _locator()
     assert locate("value = 1\n  unexpected = 2\n") == (2, 3)
@@ -51,7 +73,11 @@ def test_replaces_generated_error_locator(
         if isinstance(node, ast.FunctionDef)
         and node.name == "_native_error_location"
     )
-    text = ast.unparse(locator)
-    assert "previous_opens_block" in text
-    assert "return line_index + 1, indent + 1" in text
-    assert "return line_index + 1, column_index + 1" in text
+    names = {
+        node.id
+        for node in ast.walk(locator)
+        if isinstance(node, ast.Name)
+    }
+    assert "previous_opens_block" in names
+    assert _has_return_pair(locator, "indent")
+    assert _has_return_pair(locator, "column_index")

From 1289f4bd00a8d16667f468282402f41fe7adeecd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:37:42 -0500
Subject: [PATCH 143/450] Back native data builders with append-only byte
 storage

---
 .../normalize_full_reference_data_builders.py | 63 +++++++++++++++----
 1 file changed, 51 insertions(+), 12 deletions(-)

diff --git a/tools/normalize_full_reference_data_builders.py b/tools/normalize_full_reference_data_builders.py
index fb916f1d..06c99d8e 100644
--- a/tools/normalize_full_reference_data_builders.py
+++ b/tools/normalize_full_reference_data_builders.py
@@ -1,9 +1,10 @@
 """Make native text/bytes builders safe for the pinned compiler runtime.
 
-The compiled list-item assignment path only reliably updates index zero. C-facing
-text and bytes construction is inherently sequential, so builders append each byte
-in order and retain the requested final size for validation. UTF-8 validation also
-operates on the builder's materialized bytes rather than the builder object.
+Native local empty lists expose a sentinel slot in the pinned compiler runtime, so
+``len([])`` is not a safe byte cursor. Builders instead append to one module-owned
+byte arena and retain a start/size pair. Materialization uses a one-item seed list,
+which avoids both indexed writes and the empty-list sentinel while preserving every
+byte exactly.
 """
 from __future__ import annotations
 
@@ -13,10 +14,32 @@
 
 PATH = Path("src/portapy/native_full_reference_entry.py")
 
+_STORAGE_SOURCE = "_native_byte_data: list[int] = [0]\n"
+
 _BUILDER_INIT = '''
 self.kind = kind
 self.size = size
-self.data: list[int] = []
+self.start = len(_native_byte_data)
+self.written = 0
+'''
+
+_DATA_BYTES = '''
+if isinstance(value, _DataBuilder):
+    if value.written != value.size:
+        raise TypeError("data builder is incomplete")
+    if value.size == 0:
+        return b""
+    data: list[int] = [_native_byte_data[value.start]]
+    index = 1
+    while index < value.size:
+        data.append(_native_byte_data[value.start + index])
+        index += 1
+    return bytes(data)
+if type(value) is str:
+    return value.encode("utf-8")
+if type(value) is bytes:
+    return value
+raise TypeError("value is not text or bytes")
 '''
 
 _SET_BYTE = '''
@@ -30,9 +53,10 @@
     return _set_status_code(PORTAPY_TYPE_ERROR)
 if index < 0 or index >= target.size or byte < 0 or byte > 255:
     return _set_status_code(PORTAPY_INVALID_ARGUMENT)
-if index != len(target.data):
+if index != target.written:
     return _set_status_code(PORTAPY_INVALID_ARGUMENT)
-target.data.append(byte)
+_native_byte_data.append(byte)
+target.written += 1
 return _set_status_code(PORTAPY_OK)
 '''
 
@@ -106,7 +130,10 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
         self.generic_visit(node)
-        if node.name == "_portapy_value_from_data_begin_impl":
+        if node.name == "_data_bytes":
+            node.body = ast.parse(_DATA_BYTES).body
+            self.functions.add(node.name)
+        elif node.name == "_portapy_value_from_data_begin_impl":
             count = _map_builder_store_kind(node)
             if count != 1:
                 raise RuntimeError(
@@ -124,9 +151,17 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "_native_byte_data"
+        for node in module.body
+    ):
+        raise RuntimeError("native byte arena is already installed")
     rewriter = _Rewrite()
     module = rewriter.visit(module)
     expected = {
+        "_data_bytes",
         "_portapy_value_from_data_begin_impl",
         "_portapy_value_set_data_byte_impl",
         "_portapy_value_validate_utf8_impl",
@@ -136,6 +171,7 @@ def main() -> int:
             "native data-builder normalization missed expected shapes; "
             f"builder={rewriter.builder}, functions={sorted(rewriter.functions)}"
         )
+    module.body.extend(ast.parse(_STORAGE_SOURCE).body)
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
@@ -143,16 +179,19 @@ def main() -> int:
     verified = ast.parse(source)
     text = ast.unparse(verified)
     required = (
-        "self.size = size",
+        "_native_byte_data: list[int] = [0]",
+        "self.start = len(_native_byte_data)",
+        "self.written = 0",
         "instance._store(_DataBuilder(kind, size), _native_kind_member(kind))",
-        "index != len(target.data)",
-        "target.data.append(byte)",
+        "index != target.written",
+        "_native_byte_data.append(byte)",
+        "data: list[int] = [_native_byte_data[value.start]]",
         "_data_bytes(raw).decode('utf-8')",
     )
     absent = [marker for marker in required if marker not in text]
     if absent:
         raise RuntimeError(f"native data-builder validation failed: {absent}")
-    print("NORMALIZED NATIVE DATA BUILDERS", 4)
+    print("NORMALIZED NATIVE DATA BUILDERS", 5)
     return 0
 
 

From 51ed400218049658fa5a974742f71aaac6910a9e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:38:07 -0500
Subject: [PATCH 144/450] Test append-only native byte arena

---
 ..._normalize_full_reference_data_builders.py | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/tests/test_normalize_full_reference_data_builders.py b/tests/test_normalize_full_reference_data_builders.py
index c99db334..a6807f0b 100644
--- a/tests/test_normalize_full_reference_data_builders.py
+++ b/tests/test_normalize_full_reference_data_builders.py
@@ -36,6 +36,9 @@ def test_installs_sequential_native_data_builders(
     assert builder_normalizer.main() == 0
 
     module = ast.parse(output.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert "_native_byte_data: list[int] = [0]" in text
+
     builder = next(
         node
         for node in module.body
@@ -43,16 +46,23 @@ def test_installs_sequential_native_data_builders(
     )
     builder_text = ast.unparse(builder)
     assert "self.size = size" in builder_text
-    assert "self.data: list[int] = []" in builder_text
-    assert "while index < size" not in builder_text
+    assert "self.start = len(_native_byte_data)" in builder_text
+    assert "self.written = 0" in builder_text
+    assert "self.data" not in builder_text
+
+    materialize = _function(module, "_data_bytes")
+    assert "value.written != value.size" in materialize
+    assert "data: list[int] = [_native_byte_data[value.start]]" in materialize
+    assert "data.append(_native_byte_data[value.start + index])" in materialize
 
     begin = _function(module, "_portapy_value_from_data_begin_impl")
     assert "instance._store(_DataBuilder(kind, size), _native_kind_member(kind))" in begin
 
     setter = _function(module, "_portapy_value_set_data_byte_impl")
-    assert "index != len(target.data)" in setter
-    assert "target.data.append(byte)" in setter
-    assert "target.data[index] = byte" not in setter
+    assert "index != target.written" in setter
+    assert "_native_byte_data.append(byte)" in setter
+    assert "target.written += 1" in setter
+    assert "target.data" not in setter
 
     validator = _function(module, "_portapy_value_validate_utf8_impl")
     assert "_data_bytes(raw).decode('utf-8')" in validator

From b837561e76ff0d19d7757ec7417c50abca39f8cf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:43:25 -0500
Subject: [PATCH 145/450] Validate native UTF-8 explicitly

---
 .../normalize_full_reference_data_builders.py | 91 ++++++++++++++++---
 1 file changed, 76 insertions(+), 15 deletions(-)

diff --git a/tools/normalize_full_reference_data_builders.py b/tools/normalize_full_reference_data_builders.py
index 06c99d8e..f73e2362 100644
--- a/tools/normalize_full_reference_data_builders.py
+++ b/tools/normalize_full_reference_data_builders.py
@@ -4,7 +4,8 @@
 ``len([])`` is not a safe byte cursor. Builders instead append to one module-owned
 byte arena and retain a start/size pair. Materialization uses a one-item seed list,
 which avoids both indexed writes and the empty-list sentinel while preserving every
-byte exactly.
+byte exactly. UTF-8 is validated explicitly because the compiler's decode stub does
+not reject malformed byte sequences.
 """
 from __future__ import annotations
 
@@ -67,19 +68,77 @@
 status, raw = instance.unbox(value)
 if status is not Status.OK:
     return _set_status(status)
-try:
-    _data_bytes(raw).decode("utf-8")
-except UnicodeDecodeError:
-    status = instance._capture_native(
-        Status.TYPE_ERROR,
-        "UnicodeDecodeError",
-        "invalid UTF-8",
-        0,
-        1,
-    )
-    return _set_status(status)
-except TypeError:
+if not isinstance(raw, _DataBuilder):
     return _set_status(Status.TYPE_ERROR)
+if raw.written != raw.size:
+    return _set_status(Status.INVALID_ARGUMENT)
+index = 0
+while index < raw.size:
+    first = _native_byte_data[raw.start + index]
+    needed = 0
+    minimum = 0
+    codepoint = 0
+    if first < 128:
+        index += 1
+        continue
+    if first >= 194 and first <= 223:
+        needed = 1
+        minimum = 128
+        codepoint = first - 192
+    elif first >= 224 and first <= 239:
+        needed = 2
+        minimum = 2048
+        codepoint = first - 224
+    elif first >= 240 and first <= 244:
+        needed = 3
+        minimum = 65536
+        codepoint = first - 240
+    else:
+        status = instance._capture_native(
+            Status.TYPE_ERROR,
+            "UnicodeDecodeError",
+            "invalid UTF-8 leading byte",
+            0,
+            index + 1,
+        )
+        return _set_status(status)
+    if index + needed >= raw.size:
+        status = instance._capture_native(
+            Status.TYPE_ERROR,
+            "UnicodeDecodeError",
+            "truncated UTF-8 sequence",
+            0,
+            index + 1,
+        )
+        return _set_status(status)
+    offset = 1
+    while offset <= needed:
+        continuation = _native_byte_data[raw.start + index + offset]
+        if continuation < 128 or continuation > 191:
+            status = instance._capture_native(
+                Status.TYPE_ERROR,
+                "UnicodeDecodeError",
+                "invalid UTF-8 continuation byte",
+                0,
+                index + offset + 1,
+            )
+            return _set_status(status)
+        codepoint = codepoint * 64 + continuation - 128
+        offset += 1
+    if (
+        codepoint < minimum
+        or codepoint > 1114111
+        or (codepoint >= 55296 and codepoint <= 57343)
+    ):
+        status = instance._capture_native(
+            Status.TYPE_ERROR,
+            "UnicodeDecodeError",
+            "invalid UTF-8 code point",
+            0,
+            index + 1,
+        )
+        return _set_status(status)
+    index += needed + 1
 return _set_status(Status.OK)
 '''
 
@@ -186,12 +245,14 @@ def main() -> int:
         "index != target.written",
         "_native_byte_data.append(byte)",
         "data: list[int] = [_native_byte_data[value.start]]",
-        "_data_bytes(raw).decode('utf-8')",
+        "while index < raw.size",
+        "invalid UTF-8 continuation byte",
+        "codepoint > 1114111",
     )
     absent = [marker for marker in required if marker not in text]
     if absent:
         raise RuntimeError(f"native data-builder validation failed: {absent}")
-    print("NORMALIZED NATIVE DATA BUILDERS", 5)
+    print("NORMALIZED NATIVE DATA BUILDERS", 6)
     return 0
 
 

From c56ad02bc4fcc27fe47a393d31256fe2af81a4e3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:43:52 -0500
Subject: [PATCH 146/450] Test explicit native UTF-8 validation

---
 tests/test_normalize_full_reference_data_builders.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_reference_data_builders.py b/tests/test_normalize_full_reference_data_builders.py
index a6807f0b..24426d8d 100644
--- a/tests/test_normalize_full_reference_data_builders.py
+++ b/tests/test_normalize_full_reference_data_builders.py
@@ -65,5 +65,8 @@ def test_installs_sequential_native_data_builders(
     assert "target.data" not in setter
 
     validator = _function(module, "_portapy_value_validate_utf8_impl")
-    assert "_data_bytes(raw).decode('utf-8')" in validator
-    assert "except TypeError" in validator
+    assert "while index < raw.size" in validator
+    assert "invalid UTF-8 leading byte" in validator
+    assert "invalid UTF-8 continuation byte" in validator
+    assert "codepoint > 1114111" in validator
+    assert ".decode(" not in validator

From 06cc770b4d4ae84d1cf07fc0491b7f8cb8ff5419 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:53:27 -0500
Subject: [PATCH 147/450] Read native error text without byte encoding

---
 tools/normalize_full_reference_error_text.py | 123 +++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 tools/normalize_full_reference_error_text.py

diff --git a/tools/normalize_full_reference_error_text.py b/tools/normalize_full_reference_error_text.py
new file mode 100644
index 00000000..8b040dac
--- /dev/null
+++ b/tools/normalize_full_reference_error_text.py
@@ -0,0 +1,123 @@
+"""Expose native structured-error text without allocating encoded bytes.
+
+The pinned compiler runtime can safely access the native ``ErrorInfo`` fields, but
+its generic ``str.encode`` lowering dereferences an invalid runtime object. The C
+adapter already requests text one byte at a time, so size and byte helpers operate
+directly on the ASCII error strings produced by the native capture paths.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_TYPE_SIZE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status_code(PORTAPY_INVALID_HANDLE)
+    return 0
+error = instance.last_error()
+_set_status_code(PORTAPY_OK)
+if error is None:
+    return 0
+return len(error.type_name)
+'''
+
+_MESSAGE_SIZE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status_code(PORTAPY_INVALID_HANDLE)
+    return 0
+error = instance.last_error()
+_set_status_code(PORTAPY_OK)
+if error is None:
+    return 0
+return len(error.message)
+'''
+
+_TYPE_BYTE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status_code(PORTAPY_INVALID_HANDLE)
+    return 0
+error = instance.last_error()
+if error is None or index < 0 or index >= len(error.type_name):
+    _set_status_code(PORTAPY_INVALID_ARGUMENT)
+    return 0
+_set_status_code(PORTAPY_OK)
+return ord(error.type_name[index])
+'''
+
+_MESSAGE_BYTE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status_code(PORTAPY_INVALID_HANDLE)
+    return 0
+error = instance.last_error()
+if error is None or index < 0 or index >= len(error.message):
+    _set_status_code(PORTAPY_INVALID_ARGUMENT)
+    return 0
+_set_status_code(PORTAPY_OK)
+return ord(error.message[index])
+'''
+
+_REPLACEMENTS = {
+    "_portapy_error_type_size_impl": _TYPE_SIZE,
+    "_portapy_error_message_size_impl": _MESSAGE_SIZE,
+    "_portapy_error_type_byte_impl": _TYPE_BYTE,
+    "_portapy_error_message_byte_impl": _MESSAGE_BYTE,
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        replacement = _REPLACEMENTS.get(node.name)
+        if replacement is None:
+            return node
+        node.body = ast.parse(replacement).body
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    missing = sorted(set(_REPLACEMENTS) - rewriter.replaced)
+    if missing:
+        raise RuntimeError(f"native error text functions missing: {missing}")
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    functions = {
+        node.name: ast.unparse(node)
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name in _REPLACEMENTS
+    }
+    text = "\n".join(functions.values())
+    required = (
+        "len(error.type_name)",
+        "len(error.message)",
+        "ord(error.type_name[index])",
+        "ord(error.message[index])",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent or ".encode(" in text or "_error_bytes(" in text:
+        raise RuntimeError(
+            f"native error text validation failed: absent={absent}"
+        )
+    print("NORMALIZED NATIVE ERROR TEXT", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 945da7e69f2ad31372a00040eaea0b908a4cd9ef Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:54:03 -0500
Subject: [PATCH 148/450] Wire native error text normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 9ab110cd..f9054629 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -33,6 +33,9 @@
 from tools.normalize_full_reference_error_locations import (
     main as normalize_reference_error_locations,
 )
+from tools.normalize_full_reference_error_text import (
+    main as normalize_reference_error_text,
+)
 from tools.normalize_full_reference_errors import (
     main as normalize_reference_errors,
 )
@@ -100,6 +103,7 @@ def main() -> int:
     normalize_reference_abi_helpers()
     normalize_reference_float_bits()
     normalize_reference_errors()
+    normalize_reference_error_text()
     normalize_reference_error_locations()
     normalize_reference_value_kinds()
     normalize_reference_nested_kinds()

From 41fabcf44ba3001f12b19ab0012c4448ed24af12 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:54:18 -0500
Subject: [PATCH 149/450] Test native error text normalization

---
 ...est_normalize_full_reference_error_text.py | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_error_text.py

diff --git a/tests/test_normalize_full_reference_error_text.py b/tests/test_normalize_full_reference_error_text.py
new file mode 100644
index 00000000..4d9cde92
--- /dev/null
+++ b/tests/test_normalize_full_reference_error_text.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_error_text as text_normalizer
+
+
+def _function(module: ast.Module, name: str) -> str:
+    return ast.unparse(
+        next(
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef) and node.name == name
+        )
+    )
+
+
+def test_rewrites_error_text_helpers_without_encoding(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(text_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert text_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    type_size = _function(module, "_portapy_error_type_size_impl")
+    message_size = _function(module, "_portapy_error_message_size_impl")
+    type_byte = _function(module, "_portapy_error_type_byte_impl")
+    message_byte = _function(module, "_portapy_error_message_byte_impl")
+
+    assert "len(error.type_name)" in type_size
+    assert "len(error.message)" in message_size
+    assert "ord(error.type_name[index])" in type_byte
+    assert "ord(error.message[index])" in message_byte
+    combined = type_size + message_size + type_byte + message_byte
+    assert ".encode(" not in combined
+    assert "_error_bytes(" not in combined

From 0de0344014d3036ec046c4dd79c361024f3280c7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:02:43 -0500
Subject: [PATCH 150/450] Read native strings and bytes without encoding

---
 tools/normalize_full_reference_data_access.py | 200 ++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 tools/normalize_full_reference_data_access.py

diff --git a/tools/normalize_full_reference_data_access.py b/tools/normalize_full_reference_data_access.py
new file mode 100644
index 00000000..09670b2f
--- /dev/null
+++ b/tools/normalize_full_reference_data_access.py
@@ -0,0 +1,200 @@
+"""Expose native string/bytes payloads without ``str.encode``.
+
+The native runtime safely retains source-created ``str`` and ``bytes`` values, but
+the pinned compiler's generic encoding path is not usable. Public size/copy helpers
+therefore calculate UTF-8 widths and bytes directly from Unicode code points, while
+builder and bytes payloads are read from their native storage unchanged.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HELPERS = '''
+def _native_utf8_width(codepoint: int) -> int:
+    if codepoint < 0 or codepoint > 1114111:
+        return 0
+    if codepoint >= 55296 and codepoint <= 57343:
+        return 0
+    if codepoint <= 127:
+        return 1
+    if codepoint <= 2047:
+        return 2
+    if codepoint <= 65535:
+        return 3
+    return 4
+
+
+def _native_data_size(value: object) -> int:
+    if isinstance(value, _DataBuilder):
+        if value.written != value.size:
+            return -1
+        return value.size
+    if type(value) is bytes:
+        return len(value)
+    if type(value) is str:
+        total = 0
+        index = 0
+        while index < len(value):
+            width = _native_utf8_width(ord(value[index]))
+            if width == 0:
+                return -1
+            total += width
+            index += 1
+        return total
+    return -1
+
+
+def _native_string_byte(value: str, wanted: int) -> int:
+    offset = 0
+    index = 0
+    while index < len(value):
+        codepoint = ord(value[index])
+        width = _native_utf8_width(codepoint)
+        if width == 0:
+            return -1
+        if wanted < offset + width:
+            within = wanted - offset
+            if width == 1:
+                return codepoint
+            if width == 2:
+                if within == 0:
+                    return 192 + codepoint // 64
+                return 128 + codepoint % 64
+            if width == 3:
+                if within == 0:
+                    return 224 + codepoint // 4096
+                if within == 1:
+                    return 128 + codepoint // 64 % 64
+                return 128 + codepoint % 64
+            if within == 0:
+                return 240 + codepoint // 262144
+            if within == 1:
+                return 128 + codepoint // 4096 % 64
+            if within == 2:
+                return 128 + codepoint // 64 % 64
+            return 128 + codepoint % 64
+        offset += width
+        index += 1
+    return -1
+
+
+def _native_data_byte(value: object, index: int) -> int:
+    if isinstance(value, _DataBuilder):
+        if value.written != value.size or index < 0 or index >= value.size:
+            return -1
+        return _native_byte_data[value.start + index]
+    if type(value) is bytes:
+        if index < 0 or index >= len(value):
+            return -1
+        return value[index]
+    if type(value) is str:
+        return _native_string_byte(value, index)
+    return -1
+'''
+
+_GET_SIZE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+status, raw = instance.unbox(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+size = _native_data_size(raw)
+if size < 0:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+_set_status(Status.OK)
+return size
+'''
+
+_GET_BYTE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+status, raw = instance.unbox(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+size = _native_data_size(raw)
+if size < 0:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+if index < 0 or index >= size:
+    _set_status(Status.INVALID_ARGUMENT)
+    return 0
+result = _native_data_byte(raw, index)
+if result < 0:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+_set_status(Status.OK)
+return result
+'''
+
+_REPLACEMENTS = {
+    "_portapy_value_get_size_impl": _GET_SIZE,
+    "_portapy_value_get_byte_impl": _GET_BYTE,
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        replacement = _REPLACEMENTS.get(node.name)
+        if replacement is None:
+            return node
+        node.body = ast.parse(replacement).body
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_native_data_size"
+        for node in module.body
+    ):
+        raise RuntimeError("native data access helpers are already installed")
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    missing = sorted(set(_REPLACEMENTS) - rewriter.replaced)
+    if missing:
+        raise RuntimeError(f"native data access functions missing: {missing}")
+    module.body.extend(ast.parse(_HELPERS).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    text = ast.unparse(verified)
+    required = (
+        "_native_utf8_width(ord(value[index]))",
+        "_native_string_byte(value, index)",
+        "return value[index]",
+        "size = _native_data_size(raw)",
+        "result = _native_data_byte(raw, index)",
+    )
+    absent = [marker for marker in required if marker not in text]
+    functions = "\n".join(
+        ast.unparse(node)
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name in _REPLACEMENTS
+    )
+    if absent or ".encode(" in functions or "_data_bytes(" in functions:
+        raise RuntimeError(f"native data access validation failed: absent={absent}")
+    print("NORMALIZED NATIVE DATA ACCESS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 147cc069ea49eeffd64a0e18c86fe6d45dcdc386 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:03:21 -0500
Subject: [PATCH 151/450] Wire direct native data access

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index f9054629..ecc0df46 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,6 +27,9 @@
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_data_access import (
+    main as normalize_reference_data_access,
+)
 from tools.normalize_full_reference_data_builders import (
     main as normalize_reference_data_builders,
 )
@@ -109,6 +112,7 @@ def main() -> int:
     normalize_reference_nested_kinds()
     normalize_reference_source_preprocess()
     normalize_reference_data_builders()
+    normalize_reference_data_access()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From 261ec602ebf27dfd192361d72af8a2df31cb3fb1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:03:41 -0500
Subject: [PATCH 152/450] Test direct native UTF-8 data access

---
 ...st_normalize_full_reference_data_access.py | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_data_access.py

diff --git a/tests/test_normalize_full_reference_data_access.py b/tests/test_normalize_full_reference_data_access.py
new file mode 100644
index 00000000..5045b93a
--- /dev/null
+++ b/tests/test_normalize_full_reference_data_access.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_data_access as access_normalizer
+from tools import normalize_full_reference_data_builders as builder_normalizer
+from tools import normalize_full_reference_errors as error_normalizer
+from tools import normalize_full_reference_float_bits as float_normalizer
+
+
+class _DataBuilder:
+    pass
+
+
+def _helpers() -> dict[str, object]:
+    namespace: dict[str, object] = {
+        "_DataBuilder": _DataBuilder,
+        "_native_byte_data": [0],
+    }
+    exec(access_normalizer._HELPERS, namespace)
+    return namespace
+
+
+def test_calculates_utf8_size_and_bytes_without_encoding() -> None:
+    namespace = _helpers()
+    size = namespace["_native_data_size"]
+    byte = namespace["_native_data_byte"]
+    value = "Aπ😀"
+    expected = value.encode("utf-8")
+    assert size(value) == len(expected)
+    assert bytes(byte(value, index) for index in range(len(expected))) == expected
+    raw = b"\x00\xffA"
+    assert size(raw) == 3
+    assert [byte(raw, index) for index in range(3)] == [0, 255, 65]
+
+
+def test_installs_direct_data_access_into_native_abi(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(float_normalizer, "PATH", output)
+    monkeypatch.setattr(error_normalizer, "PATH", output)
+    monkeypatch.setattr(builder_normalizer, "PATH", output)
+    monkeypatch.setattr(access_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert float_normalizer.main() == 0
+    assert error_normalizer.main() == 0
+    assert builder_normalizer.main() == 0
+    assert access_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert "_native_string_byte(value, index)" in text
+    assert "size = _native_data_size(raw)" in text
+    assert "result = _native_data_byte(raw, index)" in text
+    functions = "\n".join(
+        ast.unparse(node)
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name in {
+            "_portapy_value_get_size_impl",
+            "_portapy_value_get_byte_impl",
+        }
+    )
+    assert ".encode(" not in functions
+    assert "_data_bytes(" not in functions

From 988bf7cf329a6eb7289781510c86becd9bd77f5c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:08:56 -0500
Subject: [PATCH 153/450] Use handle metadata for native data access

---
 tools/normalize_full_reference_data_access.py | 139 +++++++++++++-----
 1 file changed, 101 insertions(+), 38 deletions(-)

diff --git a/tools/normalize_full_reference_data_access.py b/tools/normalize_full_reference_data_access.py
index 09670b2f..cd761670 100644
--- a/tools/normalize_full_reference_data_access.py
+++ b/tools/normalize_full_reference_data_access.py
@@ -1,9 +1,9 @@
-"""Expose native string/bytes payloads without ``str.encode``.
+"""Expose native string/bytes payloads without payload introspection.
 
-The native runtime safely retains source-created ``str`` and ``bytes`` values, but
-the pinned compiler's generic encoding path is not usable. Public size/copy helpers
-therefore calculate UTF-8 widths and bytes directly from Unicode code points, while
-builder and bytes payloads are read from their native storage unchanged.
+Raw source values are untagged native pointers, so even ``type(value)`` is unsafe.
+The opaque handle's existing ``ValueKind`` plus a builder-handle ledger determine
+how data is read before the payload is touched. Unicode strings are flattened to
+UTF-8 directly from code points; bytes and builders are copied unchanged.
 """
 from __future__ import annotations
 
@@ -14,6 +14,13 @@
 PATH = Path("src/portapy/native_full_reference_entry.py")
 
 _HELPERS = '''
+_native_builder_handles: dict[str, bool] = {}
+
+
+def _native_builder_key(runtime: int, value: int) -> str:
+    return str(runtime) + ":" + str(value)
+
+
 def _native_utf8_width(codepoint: int) -> int:
     if codepoint < 0 or codepoint > 1114111:
         return 0
@@ -28,24 +35,16 @@ def _native_utf8_width(codepoint: int) -> int:
     return 4
 
 
-def _native_data_size(value: object) -> int:
-    if isinstance(value, _DataBuilder):
-        if value.written != value.size:
+def _native_string_size(value: str) -> int:
+    total = 0
+    index = 0
+    while index < len(value):
+        width = _native_utf8_width(ord(value[index]))
+        if width == 0:
             return -1
-        return value.size
-    if type(value) is bytes:
-        return len(value)
-    if type(value) is str:
-        total = 0
-        index = 0
-        while index < len(value):
-            width = _native_utf8_width(ord(value[index]))
-            if width == 0:
-                return -1
-            total += width
-            index += 1
-        return total
-    return -1
+        total += width
+        index += 1
+    return total
 
 
 def _native_string_byte(value: str, wanted: int) -> int:
@@ -82,17 +81,40 @@ def _native_string_byte(value: str, wanted: int) -> int:
     return -1
 
 
-def _native_data_byte(value: object, index: int) -> int:
-    if isinstance(value, _DataBuilder):
+def _native_data_size(
+    runtime: int,
+    handle: int,
+    kind: object,
+    value: object,
+) -> int:
+    if _native_builder_handles.get(_native_builder_key(runtime, handle), False):
+        if value.written != value.size:
+            return -1
+        return value.size
+    if kind is ValueKind.STRING:
+        return _native_string_size(value)
+    if kind is ValueKind.BYTES:
+        return len(value)
+    return -1
+
+
+def _native_data_byte(
+    runtime: int,
+    handle: int,
+    kind: object,
+    value: object,
+    index: int,
+) -> int:
+    if _native_builder_handles.get(_native_builder_key(runtime, handle), False):
         if value.written != value.size or index < 0 or index >= value.size:
             return -1
         return _native_byte_data[value.start + index]
-    if type(value) is bytes:
+    if kind is ValueKind.STRING:
+        return _native_string_byte(value, index)
+    if kind is ValueKind.BYTES:
         if index < 0 or index >= len(value):
             return -1
         return value[index]
-    if type(value) is str:
-        return _native_string_byte(value, index)
     return -1
 '''
 
@@ -101,11 +123,15 @@ def _native_data_byte(value: object, index: int) -> int:
 if instance is None:
     _set_status(Status.INVALID_HANDLE)
     return 0
+kind_status, kind = instance.value_kind(value)
+if kind_status is not Status.OK:
+    _set_status(kind_status)
+    return 0
 status, raw = instance.unbox(value)
 if status is not Status.OK:
     _set_status(status)
     return 0
-size = _native_data_size(raw)
+size = _native_data_size(runtime, value, kind, raw)
 if size < 0:
     _set_status(Status.TYPE_ERROR)
     return 0
@@ -118,18 +144,22 @@ def _native_data_byte(value: object, index: int) -> int:
 if instance is None:
     _set_status(Status.INVALID_HANDLE)
     return 0
+kind_status, kind = instance.value_kind(value)
+if kind_status is not Status.OK:
+    _set_status(kind_status)
+    return 0
 status, raw = instance.unbox(value)
 if status is not Status.OK:
     _set_status(status)
     return 0
-size = _native_data_size(raw)
+size = _native_data_size(runtime, value, kind, raw)
 if size < 0:
     _set_status(Status.TYPE_ERROR)
     return 0
 if index < 0 or index >= size:
     _set_status(Status.INVALID_ARGUMENT)
     return 0
-result = _native_data_byte(raw, index)
+result = _native_data_byte(runtime, value, kind, raw, index)
 if result < 0:
     _set_status(Status.TYPE_ERROR)
     return 0
@@ -143,12 +173,40 @@ def _native_data_byte(value: object, index: int) -> int:
 }
 
 
+def _mark_builder_result(node: ast.FunctionDef) -> int:
+    count = 0
+    body: list[ast.stmt] = []
+    for statement in node.body:
+        body.append(statement)
+        if (
+            isinstance(statement, ast.Assign)
+            and len(statement.targets) == 1
+            and isinstance(statement.targets[0], ast.Name)
+            and statement.targets[0].id == "result"
+            and isinstance(statement.value, ast.Call)
+            and isinstance(statement.value.func, ast.Attribute)
+            and statement.value.func.attr == "_store"
+        ):
+            body.extend(
+                ast.parse(
+                    "_native_builder_handles[_native_builder_key(runtime, result)] = True"
+                ).body
+            )
+            count += 1
+    node.body = body
+    return count
+
+
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.replaced: set[str] = set()
+        self.marked = 0
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
         self.generic_visit(node)
+        if node.name == "_portapy_value_from_data_begin_impl":
+            self.marked += _mark_builder_result(node)
+            return node
         replacement = _REPLACEMENTS.get(node.name)
         if replacement is None:
             return node
@@ -167,8 +225,11 @@ def main() -> int:
     rewriter = _Rewrite()
     module = rewriter.visit(module)
     missing = sorted(set(_REPLACEMENTS) - rewriter.replaced)
-    if missing:
-        raise RuntimeError(f"native data access functions missing: {missing}")
+    if missing or rewriter.marked != 1:
+        raise RuntimeError(
+            "native data access normalization missed shapes; "
+            f"missing={missing}, builder_marks={rewriter.marked}"
+        )
     module.body.extend(ast.parse(_HELPERS).body)
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -177,11 +238,13 @@ def main() -> int:
     verified = ast.parse(source)
     text = ast.unparse(verified)
     required = (
-        "_native_utf8_width(ord(value[index]))",
+        "_native_builder_handles[_native_builder_key(runtime, result)] = True",
+        "_native_string_size(value)",
         "_native_string_byte(value, index)",
-        "return value[index]",
-        "size = _native_data_size(raw)",
-        "result = _native_data_byte(raw, index)",
+        "kind is ValueKind.STRING",
+        "kind is ValueKind.BYTES",
+        "size = _native_data_size(runtime, value, kind, raw)",
+        "result = _native_data_byte(runtime, value, kind, raw, index)",
     )
     absent = [marker for marker in required if marker not in text]
     functions = "\n".join(
@@ -190,9 +253,9 @@ def main() -> int:
         if isinstance(node, ast.FunctionDef)
         and node.name in _REPLACEMENTS
     )
-    if absent or ".encode(" in functions or "_data_bytes(" in functions:
+    if absent or "type(raw)" in functions or "isinstance(raw" in functions:
         raise RuntimeError(f"native data access validation failed: absent={absent}")
-    print("NORMALIZED NATIVE DATA ACCESS", len(_REPLACEMENTS))
+    print("NORMALIZED NATIVE DATA ACCESS", len(_REPLACEMENTS) + rewriter.marked)
     return 0
 
 

From e86b6dc79fe95be189bb0b51af929c0bc486c6aa Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:09:34 -0500
Subject: [PATCH 154/450] Test metadata-driven native data access

---
 ...st_normalize_full_reference_data_access.py | 49 +++++++++++++++----
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/tests/test_normalize_full_reference_data_access.py b/tests/test_normalize_full_reference_data_access.py
index 5045b93a..f54e5ff8 100644
--- a/tests/test_normalize_full_reference_data_access.py
+++ b/tests/test_normalize_full_reference_data_access.py
@@ -15,26 +15,56 @@ class _DataBuilder:
     pass
 
 
+class _Kinds:
+    STRING = object()
+    BYTES = object()
+
+
 def _helpers() -> dict[str, object]:
     namespace: dict[str, object] = {
         "_DataBuilder": _DataBuilder,
+        "ValueKind": _Kinds,
         "_native_byte_data": [0],
     }
     exec(access_normalizer._HELPERS, namespace)
     return namespace
 
 
-def test_calculates_utf8_size_and_bytes_without_encoding() -> None:
+def test_calculates_utf8_size_and_bytes_without_introspection() -> None:
     namespace = _helpers()
     size = namespace["_native_data_size"]
     byte = namespace["_native_data_byte"]
     value = "Aπ😀"
     expected = value.encode("utf-8")
-    assert size(value) == len(expected)
-    assert bytes(byte(value, index) for index in range(len(expected))) == expected
+    assert size(1, 2, _Kinds.STRING, value) == len(expected)
+    assert bytes(
+        byte(1, 2, _Kinds.STRING, value, index)
+        for index in range(len(expected))
+    ) == expected
     raw = b"\x00\xffA"
-    assert size(raw) == 3
-    assert [byte(raw, index) for index in range(3)] == [0, 255, 65]
+    assert size(1, 3, _Kinds.BYTES, raw) == 3
+    assert [
+        byte(1, 3, _Kinds.BYTES, raw, index)
+        for index in range(3)
+    ] == [0, 255, 65]
+
+
+def test_builder_handle_uses_arena_without_payload_type_checks() -> None:
+    namespace = _helpers()
+    size = namespace["_native_data_size"]
+    byte = namespace["_native_data_byte"]
+    key = namespace["_native_builder_key"]
+    markers = namespace["_native_builder_handles"]
+    arena = namespace["_native_byte_data"]
+    builder = _DataBuilder()
+    builder.start = len(arena)
+    builder.size = 2
+    builder.written = 2
+    arena.extend([10, 255])
+    markers[key(4, 7)] = True
+    assert size(4, 7, _Kinds.STRING, builder) == 2
+    assert byte(4, 7, _Kinds.STRING, builder, 0) == 10
+    assert byte(4, 7, _Kinds.STRING, builder, 1) == 255
 
 
 def test_installs_direct_data_access_into_native_abi(
@@ -57,9 +87,10 @@ def test_installs_direct_data_access_into_native_abi(
 
     module = ast.parse(output.read_text(encoding="utf-8"))
     text = ast.unparse(module)
+    assert "_native_builder_handles[_native_builder_key(runtime, result)] = True" in text
     assert "_native_string_byte(value, index)" in text
-    assert "size = _native_data_size(raw)" in text
-    assert "result = _native_data_byte(raw, index)" in text
+    assert "size = _native_data_size(runtime, value, kind, raw)" in text
+    assert "result = _native_data_byte(runtime, value, kind, raw, index)" in text
     functions = "\n".join(
         ast.unparse(node)
         for node in module.body
@@ -69,5 +100,5 @@ def test_installs_direct_data_access_into_native_abi(
             "_portapy_value_get_byte_impl",
         }
     )
-    assert ".encode(" not in functions
-    assert "_data_bytes(" not in functions
+    assert "type(raw)" not in functions
+    assert "isinstance(raw" not in functions

From c4af0e8cc0a100f78f17dd033bb287ea4934e653 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:11:59 -0500
Subject: [PATCH 155/450] Support direct-return data builders

---
 tools/normalize_full_reference_data_access.py | 40 +++++++++++++++----
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_reference_data_access.py b/tools/normalize_full_reference_data_access.py
index cd761670..bbb3c9b6 100644
--- a/tools/normalize_full_reference_data_access.py
+++ b/tools/normalize_full_reference_data_access.py
@@ -173,26 +173,50 @@ def _native_data_byte(
 }
 
 
+def _is_store_call(node: ast.AST) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "_store"
+    )
+
+
+def _builder_marker() -> ast.stmt:
+    return ast.parse(
+        "_native_builder_handles[_native_builder_key(runtime, result)] = True"
+    ).body[0]
+
+
 def _mark_builder_result(node: ast.FunctionDef) -> int:
     count = 0
     body: list[ast.stmt] = []
     for statement in node.body:
-        body.append(statement)
         if (
             isinstance(statement, ast.Assign)
             and len(statement.targets) == 1
             and isinstance(statement.targets[0], ast.Name)
             and statement.targets[0].id == "result"
-            and isinstance(statement.value, ast.Call)
-            and isinstance(statement.value.func, ast.Attribute)
-            and statement.value.func.attr == "_store"
+            and _is_store_call(statement.value)
         ):
-            body.extend(
-                ast.parse(
-                    "_native_builder_handles[_native_builder_key(runtime, result)] = True"
-                ).body
+            body.append(statement)
+            body.append(_builder_marker())
+            count += 1
+            continue
+        if isinstance(statement, ast.Return) and _is_store_call(statement.value):
+            body.extend(ast.parse("result = None").body)
+            assignment = body[-1]
+            assert isinstance(assignment, ast.Assign)
+            assignment.value = statement.value
+            body.append(_builder_marker())
+            body.append(
+                ast.copy_location(
+                    ast.Return(value=ast.Name(id="result", ctx=ast.Load())),
+                    statement,
+                )
             )
             count += 1
+            continue
+        body.append(statement)
     node.body = body
     return count
 

From 7e0849faf6244b1c41f15c55bc3fdb1588504f0c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:22:37 -0500
Subject: [PATCH 156/450] Preserve native bytes literal payloads from source

---
 ...normalize_full_reference_bytes_literals.py | 306 ++++++++++++++++++
 1 file changed, 306 insertions(+)
 create mode 100644 tools/normalize_full_reference_bytes_literals.py

diff --git a/tools/normalize_full_reference_bytes_literals.py b/tools/normalize_full_reference_bytes_literals.py
new file mode 100644
index 00000000..7e236916
--- /dev/null
+++ b/tools/normalize_full_reference_bytes_literals.py
@@ -0,0 +1,306 @@
+"""Preserve source bytes literals at the native ABI boundary.
+
+The current compiled VM retains a placeholder for bytes constants rather than their
+original payload. Source kind tracking already knows which globals/eval results are
+bytes, so this pass parses Python bytes-literal syntax into the native byte arena and
+associates that exact payload with the public opaque handle.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HELPERS = r'''
+_native_literal_start: dict[str, int] = {}
+_native_literal_size: dict[str, int] = {}
+
+
+def _native_hex_value(char: str) -> int:
+    code = ord(char)
+    if code >= 48 and code <= 57:
+        return code - 48
+    if code >= 65 and code <= 70:
+        return code - 55
+    if code >= 97 and code <= 102:
+        return code - 87
+    return -1
+
+
+def _native_is_octal(char: str) -> bool:
+    code = ord(char)
+    return code >= 48 and code <= 55
+
+
+def _native_store_bytes_literal(key: str, expression: str) -> bool:
+    text = expression.strip()
+    index = 0
+    while index < len(text) and (
+        text[index] == "b"
+        or text[index] == "B"
+        or text[index] == "r"
+        or text[index] == "R"
+    ):
+        index += 1
+    prefix = text[0:index].lower()
+    if "b" not in prefix or index >= len(text):
+        return False
+    quote = text[index]
+    if quote != "'" and quote != '"':
+        return False
+    quote_size = 1
+    if (
+        index + 2 < len(text)
+        and text[index + 1] == quote
+        and text[index + 2] == quote
+    ):
+        quote_size = 3
+    content_start = index + quote_size
+    content_end = len(text) - quote_size
+    if content_end < content_start:
+        return False
+    check = 0
+    while check < quote_size:
+        if text[content_end + check] != quote:
+            return False
+        check += 1
+    raw = "r" in prefix
+    start = len(_native_byte_data)
+    count = 0
+    index = content_start
+    while index < content_end:
+        char = text[index]
+        value = -1
+        if not raw and char == "\\":
+            index += 1
+            if index >= content_end:
+                return False
+            escape = text[index]
+            if escape == "x":
+                if index + 2 >= content_end:
+                    return False
+                high = _native_hex_value(text[index + 1])
+                low = _native_hex_value(text[index + 2])
+                if high < 0 or low < 0:
+                    return False
+                value = high * 16 + low
+                index += 2
+            elif _native_is_octal(escape):
+                value = ord(escape) - 48
+                digits = 1
+                while (
+                    digits < 3
+                    and index + 1 < content_end
+                    and _native_is_octal(text[index + 1])
+                ):
+                    index += 1
+                    value = value * 8 + ord(text[index]) - 48
+                    digits += 1
+            elif escape == "n":
+                value = 10
+            elif escape == "r":
+                value = 13
+            elif escape == "t":
+                value = 9
+            elif escape == "b":
+                value = 8
+            elif escape == "f":
+                value = 12
+            elif escape == "v":
+                value = 11
+            elif escape == "a":
+                value = 7
+            elif escape == "\\":
+                value = 92
+            elif escape == "'":
+                value = 39
+            elif escape == '"':
+                value = 34
+            elif escape == "\n":
+                index += 1
+                continue
+            else:
+                _native_byte_data.append(92)
+                count += 1
+                value = ord(escape)
+        else:
+            value = ord(char)
+        if value < 0 or value > 255:
+            return False
+        _native_byte_data.append(value)
+        count += 1
+        index += 1
+    _native_literal_start[key] = start
+    _native_literal_size[key] = count
+    return True
+
+
+def _native_record_global_bytes(
+    runtime: int,
+    name: str,
+    expression: str,
+) -> None:
+    _native_store_bytes_literal(_native_kind_key(runtime, name), expression)
+
+
+def _native_attach_global_bytes(runtime: int, name: str, handle: int) -> None:
+    source_key = _native_kind_key(runtime, name)
+    start = _native_literal_start.get(source_key, -1)
+    if start < 0:
+        return
+    handle_key = _native_builder_key(runtime, handle)
+    _native_literal_start[handle_key] = start
+    _native_literal_size[handle_key] = _native_literal_size.get(source_key, 0)
+
+
+def _native_attach_expression_bytes(
+    runtime: int,
+    expression: str,
+    handle: int,
+) -> None:
+    _native_store_bytes_literal(
+        _native_builder_key(runtime, handle),
+        expression,
+    )
+'''
+
+
+def _call_name(node: ast.AST, name: str) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == name
+    )
+
+
+def _inject_statement_recording(function: ast.FunctionDef) -> int:
+    body: list[ast.stmt] = []
+    count = 0
+    for statement in function.body:
+        body.append(statement)
+        if (
+            isinstance(statement, ast.Expr)
+            and _call_name(statement.value, "_native_set_global_kind")
+        ):
+            body.extend(
+                ast.parse(
+                    '''if kind == PORTAPY_VALUE_BYTES:
+    _native_record_global_bytes(runtime, name, text[equals + 1:])'''
+                ).body
+            )
+            count += 1
+    function.body = body
+    return count
+
+
+def _inject_after_handle_tag(function: ast.FunctionDef, *, mode: str) -> int:
+    count = 0
+    for node in ast.walk(function):
+        if not isinstance(node, ast.If):
+            continue
+        for index, statement in enumerate(list(node.body)):
+            if (
+                isinstance(statement, ast.Expr)
+                and _call_name(statement.value, "_native_set_handle_kind")
+            ):
+                if mode == "global":
+                    source = "_native_attach_global_bytes(runtime, name_text, value)"
+                else:
+                    source = '''if _native_expression_kind(runtime, source_text) == PORTAPY_VALUE_BYTES:
+    _native_attach_expression_bytes(runtime, source_text, value)'''
+                node.body[index + 1:index + 1] = ast.parse(source).body
+                count += 1
+    return count
+
+
+def _inject_literal_data(function: ast.FunctionDef, *, byte: bool) -> int:
+    if byte:
+        statements = ast.parse(
+            '''literal_key = _native_builder_key(runtime, handle)
+literal_start = _native_literal_start.get(literal_key, -1)
+if literal_start >= 0:
+    literal_size = _native_literal_size.get(literal_key, 0)
+    if index < 0 or index >= literal_size:
+        return -1
+    return _native_byte_data[literal_start + index]'''
+        ).body
+    else:
+        statements = ast.parse(
+            '''literal_size = _native_literal_size.get(
+    _native_builder_key(runtime, handle),
+    -1,
+)
+if literal_size >= 0:
+    return literal_size'''
+        ).body
+    function.body[0:0] = statements
+    return 1
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.statement = 0
+        self.global_handle = 0
+        self.eval_handle = 0
+        self.data_size = 0
+        self.data_byte = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "_native_record_statement_kind":
+            self.statement += _inject_statement_recording(node)
+        elif node.name == "_portapy_get_global_span_impl":
+            self.global_handle += _inject_after_handle_tag(node, mode="global")
+        elif node.name == "_portapy_eval_span_impl":
+            self.eval_handle += _inject_after_handle_tag(node, mode="eval")
+        elif node.name == "_native_data_size":
+            self.data_size += _inject_literal_data(node, byte=False)
+        elif node.name == "_native_data_byte":
+            self.data_byte += _inject_literal_data(node, byte=True)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef)
+        and node.name == "_native_store_bytes_literal"
+        for node in module.body
+    ):
+        raise RuntimeError("native bytes-literal helpers are already installed")
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    counts = (
+        rewriter.statement,
+        rewriter.global_handle,
+        rewriter.eval_handle,
+        rewriter.data_size,
+        rewriter.data_byte,
+    )
+    if counts != (1, 1, 1, 1, 1):
+        raise RuntimeError(f"native bytes-literal normalization missed shapes: {counts}")
+    module.body.extend(ast.parse(_HELPERS).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    text = ast.unparse(ast.parse(source))
+    required = (
+        "_native_record_global_bytes(runtime, name, text[equals + 1:])",
+        "_native_attach_global_bytes(runtime, name_text, value)",
+        "_native_attach_expression_bytes(runtime, source_text, value)",
+        "literal_start = _native_literal_start.get(literal_key, -1)",
+        "_native_store_bytes_literal",
+        "high * 16 + low",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent:
+        raise RuntimeError(f"native bytes-literal validation failed: {absent}")
+    print("NORMALIZED NATIVE BYTES LITERALS", sum(counts))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e752ac8e67452f8aaa503344b9c9768f1929a466 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:11:29 -0500
Subject: [PATCH 157/450] Wire native bytes literal preservation into full
 runtime

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index ecc0df46..09702e6d 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,6 +27,9 @@
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
+from tools.normalize_full_reference_bytes_literals import (
+    main as normalize_reference_bytes_literals,
+)
 from tools.normalize_full_reference_data_access import (
     main as normalize_reference_data_access,
 )
@@ -113,6 +116,7 @@ def main() -> int:
     normalize_reference_source_preprocess()
     normalize_reference_data_builders()
     normalize_reference_data_access()
+    normalize_reference_bytes_literals()
     normalize_native_parser()
     normalize_calls_closures()
     normalize_keyword_calls()

From 0cf5df4b5a92d9973964107ed2003cd9284e2bf1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:12:05 -0500
Subject: [PATCH 158/450] Test native bytes literal preservation

---
 ...normalize_full_reference_bytes_literals.py | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_bytes_literals.py

diff --git a/tests/test_normalize_full_reference_bytes_literals.py b/tests/test_normalize_full_reference_bytes_literals.py
new file mode 100644
index 00000000..923fa8e5
--- /dev/null
+++ b/tests/test_normalize_full_reference_bytes_literals.py
@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_reference_bytes_literals as normalizer
+
+
+def _helpers() -> dict[str, object]:
+    namespace: dict[str, object] = {
+        "_native_byte_data": [0],
+        "_native_kind_key": lambda runtime, name: f"g:{runtime}:{name}",
+        "_native_builder_key": lambda runtime, handle: f"h:{runtime}:{handle}",
+    }
+    exec(normalizer._HELPERS, namespace)
+    return namespace
+
+
+def _payload(namespace: dict[str, object], key: str) -> list[int]:
+    arena = namespace["_native_byte_data"]
+    starts = namespace["_native_literal_start"]
+    sizes = namespace["_native_literal_size"]
+    start = starts[key]
+    size = sizes[key]
+    return arena[start : start + size]
+
+
+def test_parses_bytes_literal_escapes_exactly() -> None:
+    namespace = _helpers()
+    store = namespace["_native_store_bytes_literal"]
+
+    assert store("hex", 'b"\\x00\\xffA"') is True
+    assert _payload(namespace, "hex") == [0, 255, 65]
+
+    assert store("mixed", "b'\\101\\n\\t\\\\\\\''") is True
+    assert _payload(namespace, "mixed") == [65, 10, 9, 92, 39]
+
+    assert store("raw", 'rb"\\x41"') is True
+    assert _payload(namespace, "raw") == [92, 120, 52, 49]
+
+
+def test_rejects_non_bytes_and_invalid_hex_literals() -> None:
+    namespace = _helpers()
+    store = namespace["_native_store_bytes_literal"]
+
+    assert store("text", '"abc"') is False
+    assert store("bad", 'b"\\xz0"') is False
+    assert "text" not in namespace["_native_literal_start"]
+    assert "bad" not in namespace["_native_literal_start"]
+
+
+def test_attaches_global_and_expression_payloads_to_handles() -> None:
+    namespace = _helpers()
+    record = namespace["_native_record_global_bytes"]
+    attach_global = namespace["_native_attach_global_bytes"]
+    attach_expression = namespace["_native_attach_expression_bytes"]
+
+    record(4, "payload", 'b"\\x00\\xffA"')
+    attach_global(4, "payload", 9)
+    assert _payload(namespace, "h:4:9") == [0, 255, 65]
+
+    attach_expression(4, 'b"eval"', 10)
+    assert _payload(namespace, "h:4:10") == [101, 118, 97, 108]
+
+
+def test_installs_bytes_literal_ledger_into_native_abi(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    output.write_text(
+        '''def _native_record_statement_kind(runtime, name, text, equals, kind):
+    _native_set_global_kind(runtime, name, kind)
+
+
+def _portapy_get_global_span_impl(runtime, name_text, value, kind):
+    if value:
+        _native_set_handle_kind(runtime, value, kind)
+
+
+def _portapy_eval_span_impl(runtime, source_text, value, kind):
+    if value:
+        _native_set_handle_kind(runtime, value, kind)
+
+
+def _native_data_size(runtime, handle, kind, value):
+    return 0
+
+
+def _native_data_byte(runtime, handle, kind, value, index):
+    return 0
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", output)
+
+    assert normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert "_native_record_global_bytes(runtime, name, text[equals + 1:])" in text
+    assert "_native_attach_global_bytes(runtime, name_text, value)" in text
+    assert "_native_attach_expression_bytes(runtime, source_text, value)" in text
+    assert "literal_start = _native_literal_start.get(literal_key, -1)" in text
+    assert "_native_byte_data[literal_start + index]" in text

From eb6e52644cf01fe26213814f40cafe2357194b7a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:15:57 -0500
Subject: [PATCH 159/450] Align shared CI with main before release merge

---
 .github/workflows/ci.yml | 114 +++++++++++++++++++++++++++++++++++----
 1 file changed, 105 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7b6af059..7f9e21f8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,28 +1,124 @@
 name: CI
+
 on:
-  push:
   pull_request:
+    types: [ready_for_review]
   workflow_dispatch:
+
 permissions:
   contents: read
+
 jobs:
-  bootstrap:
-    runs-on: ubuntu-22.04
+  hosted:
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: c4444ae53c1c9b07a0d58d53dad8270af8a049df
       - uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: '3.12'
       - run: python -m pip install -e '.[test]'
-      - name: Run hosted tests
+      - name: Run complete hosted suite
+        run: python -m pytest
+      - name: Check public C example
+        run: cc -std=c11 -Wall -Wextra -Werror -Iinclude -fsyntax-only examples/embed.c
+
+  native:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-24.04
+            target: linux
+            library: dist/libportapy.so
+          - os: windows-2025
+            target: windows
+            library: dist/portapy.dll
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: c4444ae53c1c9b07a0d58d53dad8270af8a049df
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install Linux dependencies
+        if: matrix.target == 'linux'
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes nasm gcc binutils
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Install Windows dependencies
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          choco install nasm mingw -y --no-progress
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall `
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Build Linux standalone library
+        if: matrix.target == 'linux'
         shell: bash
         run: |
           mkdir -p dist
-          set -o pipefail
-          PYTHONPATH="$PWD" python -m pytest -q 2>&1 | tee dist/pytest.log
-      - run: cc -std=c11 -Wall -Wextra -Werror -Iinclude -fsyntax-only examples/embed.c
+          python tools/build_native_typed.py \
+            --target linux \
+            --output dist/libportapy.so \
+            --work-dir dist/build-verify-linux
+      - name: Build Windows standalone library
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          New-Item -ItemType Directory -Force dist | Out-Null
+          python tools/build_native_typed.py `
+            --target windows `
+            --output dist/portapy.dll `
+            --work-dir dist/build-verify-windows
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - name: Verify Linux standalone library
+        if: matrix.target == 'linux'
+        shell: bash
+        run: |
+          if readelf -dW dist/libportapy.so | grep -Ei 'libpython|python3'; then
+            echo 'CPython linkage is forbidden'
+            exit 1
+          fi
+          if readelf -dW dist/libportapy.so | grep -q TEXTREL; then
+            echo 'text relocations are forbidden'
+            exit 1
+          fi
+          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
+            tests/native_full_runtime_host.c -ldl \
+            -o dist/native_full_runtime_host
+          env -i PATH="$PATH" HOME="$HOME" \
+            ./dist/native_full_runtime_host ./dist/libportapy.so \
+            | tee dist/native-output.txt
+          grep -qx 'native-full-runtime: ok' dist/native-output.txt
+          python tests/native_traceback_adapter_probe.py dist/libportapy.so
+      - name: Verify Windows standalone library
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          $imports = (& objdump -p dist/portapy.dll | Out-String)
+          if ($imports -match '(?i)python3|python\.dll') {
+            throw 'CPython linkage is forbidden'
+          }
+          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
+            tests/native_full_runtime_host.c `
+            -o dist/native_full_runtime_host.exe
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          $output = & dist/native_full_runtime_host.exe dist/portapy.dll
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          if ($output -ne 'native-full-runtime: ok') {
+            throw "unexpected output: $output"
+          }
+          python tests/native_traceback_adapter_probe.py dist/portapy.dll
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: hosted-ci
+          name: portapy-3.14-${{ matrix.target }}
           path: dist

From c17092badb196727b7601fd6e01d7cd5ad2e55f2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:55:01 -0500
Subject: [PATCH 160/450] Preserve native BoolOp operand attributes

---
 tools/normalize_full_core_boolops.py | 112 +++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 tools/normalize_full_core_boolops.py

diff --git a/tools/normalize_full_core_boolops.py b/tools/normalize_full_core_boolops.py
new file mode 100644
index 00000000..bb48c6e8
--- /dev/null
+++ b/tools/normalize_full_core_boolops.py
@@ -0,0 +1,112 @@
+"""Force native BoolOp operands through dynamic attribute lookup.
+
+The pinned asmpython compiler correctly narrows the vendored BoolOp enough to
+read ``op``, but currently lowers the ``left`` and ``right`` fields to null
+constants inside ``native_ast._convert_expr``.  Dynamic ``getattr`` uses the
+object dictionary directly and preserves the existing short-circuit frontend
+and VM implementation without rewriting user source or evaluating operands
+more than once.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+
+
+class _OperandRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.in_convert = False
+        self.in_boolop = False
+        self.count = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        previous = self.in_convert
+        self.in_convert = node.name == "_convert_expr"
+        self.generic_visit(node)
+        self.in_convert = previous
+        return node
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        if not self.in_convert:
+            return self.generic_visit(node)
+        is_boolop = False
+        test = node.test
+        if (
+            isinstance(test, ast.Call)
+            and isinstance(test.func, ast.Name)
+            and test.func.id == "isinstance"
+            and len(test.args) == 2
+        ):
+            class_arg = test.args[1]
+            if isinstance(class_arg, ast.Name) and class_arg.id.endswith("BoolOp"):
+                is_boolop = True
+            elif isinstance(class_arg, ast.Attribute) and class_arg.attr == "BoolOp":
+                is_boolop = True
+        previous = self.in_boolop
+        self.in_boolop = is_boolop
+        self.generic_visit(node)
+        self.in_boolop = previous
+        return node
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        node = self.generic_visit(node)
+        if (
+            self.in_boolop
+            and isinstance(node, ast.Attribute)
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "node"
+            and node.attr in {"left", "right"}
+            and isinstance(node.ctx, ast.Load)
+        ):
+            self.count += 1
+            return ast.copy_location(
+                ast.Call(
+                    func=ast.Name(id="getattr", ctx=ast.Load()),
+                    args=[
+                        ast.Name(id="node", ctx=ast.Load()),
+                        ast.Constant(node.attr),
+                    ],
+                    keywords=[],
+                ),
+                node,
+            )
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewriter = _OperandRewrite()
+    module = rewriter.visit(module)
+    if rewriter.count != 2:
+        raise RuntimeError(
+            "native BoolOp operand normalization expected 2 fields, "
+            f"found {rewriter.count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    reparsed = ast.parse(source)
+    calls = [
+        node
+        for node in ast.walk(reparsed)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "getattr"
+        and len(node.args) == 2
+        and isinstance(node.args[1], ast.Constant)
+        and node.args[1].value in {"left", "right"}
+    ]
+    if len(calls) != 2:
+        raise RuntimeError(
+            f"native BoolOp dynamic operand validation found {len(calls)} calls"
+        )
+    print("NORMALIZED NATIVE BOOLOP OPERANDS", rewriter.count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 3a3f1de0a781509746480fd7e5ef3dbf933970e9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:55:39 -0500
Subject: [PATCH 161/450] Wire native BoolOp operand normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 09702e6d..0cdf2ff3 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -5,6 +5,7 @@
 
 from tools.combine_full_core_native_parser import main as combine_native_parser
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
+from tools.normalize_full_core_boolops import main as normalize_boolops
 from tools.normalize_full_core_builtins import main as normalize_builtins
 from tools.normalize_full_core_calls_closures import (
     main as normalize_calls_closures,
@@ -121,6 +122,7 @@ def main() -> int:
     normalize_calls_closures()
     normalize_keyword_calls()
     combine_native_parser()
+    normalize_boolops()
     normalize_closures()
     normalize_pattern_slices()
     normalize_extended_semantics()

From 7f2721ecfc7a42963394f239f16ddb4e4a3b03e5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:55:59 -0500
Subject: [PATCH 162/450] Test native BoolOp operand normalization

---
 tests/test_normalize_full_core_boolops.py | 53 +++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 tests/test_normalize_full_core_boolops.py

diff --git a/tests/test_normalize_full_core_boolops.py b/tests/test_normalize_full_core_boolops.py
new file mode 100644
index 00000000..c1fded5b
--- /dev/null
+++ b/tests/test_normalize_full_core_boolops.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_boolops as normalizer
+
+
+def test_rewrites_only_boolop_operands_to_dynamic_getattr(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    source = tmp_path / "native_ast.py"
+    source.write_text(
+        '''def _convert_expr(node, lifted):
+    if isinstance(node, A.BinOp):
+        return BinOp(_convert_expr(node.left, lifted), node.op, _convert_expr(node.right, lifted))
+    if isinstance(node, A.BoolOp):
+        return BoolOp(
+            And() if node.op == "and" else Or(),
+            [_convert_expr(node.left, lifted), _convert_expr(node.right, lifted)],
+        )
+    raise RuntimeError("unsupported")
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", source)
+
+    assert normalizer.main() == 0
+
+    module = ast.parse(source.read_text(encoding="utf-8"))
+    text = ast.unparse(module)
+    assert "_convert_expr(getattr(node, 'left'), lifted)" in text
+    assert "_convert_expr(getattr(node, 'right'), lifted)" in text
+    # The already-working BinOp path remains direct/static.
+    assert "_convert_expr(node.left, lifted), node.op" in text
+
+
+def test_fails_closed_without_exact_boolop_shape(tmp_path: Path, monkeypatch) -> None:
+    source = tmp_path / "native_ast.py"
+    source.write_text(
+        '''def _convert_expr(node, lifted):
+    return node
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", source)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "expected 2 fields" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing BoolOp path")

From 03b45af18c3301b600fa02f3089b5cf99f5d8eb3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:57:27 -0500
Subject: [PATCH 163/450] Realign shared CI with current main

---
 .github/workflows/ci.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7f9e21f8..85a7e41f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,8 +1,8 @@
 name: CI
 
 on:
-  pull_request:
-    types: [ready_for_review]
+  pull_request_target:
+    types: [labeled]
   workflow_dispatch:
 
 permissions:
@@ -10,6 +10,7 @@ permissions:
 
 jobs:
   hosted:
+    if: github.event_name == 'workflow_dispatch' || (github.event.pull_request.number == 46 && github.event.label.name == 'enhancement')
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
@@ -25,6 +26,7 @@ jobs:
         run: cc -std=c11 -Wall -Wextra -Werror -Iinclude -fsyntax-only examples/embed.c
 
   native:
+    if: github.event_name == 'workflow_dispatch' || (github.event.pull_request.number == 46 && github.event.label.name == 'enhancement')
     strategy:
       fail-fast: false
       matrix:

From 9041ba7737135d54cb9097f787e5f2c1923dbe2d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 20:58:33 -0500
Subject: [PATCH 164/450] Mirror main branch verification workflow

---
 .../workflows/verify-portapy-3.14-branch.yml  | 200 ++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 .github/workflows/verify-portapy-3.14-branch.yml

diff --git a/.github/workflows/verify-portapy-3.14-branch.yml b/.github/workflows/verify-portapy-3.14-branch.yml
new file mode 100644
index 00000000..6239594e
--- /dev/null
+++ b/.github/workflows/verify-portapy-3.14-branch.yml
@@ -0,0 +1,200 @@
+name: Verify PortaPy 3.14 branch
+
+on:
+  pull_request:
+    branches: [main]
+  workflow_run:
+    workflows: [Native shared-library probe]
+    types: [completed]
+  issue_comment:
+    types: [created]
+  schedule:
+    - cron: '*/5 * * * *'
+  workflow_dispatch:
+
+concurrency:
+  group: verify-portapy-3.14-branch
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  announce:
+    if: github.event_name != 'issue_comment' || (github.event.issue.number == 46 && contains(github.event.comment.body, '/verify-portapy-3.14'))
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Publish verification start
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERIFY_SHA: be5417cce8509adc3ba9d2fd9444fc716a591785
+          VERIFY_RUN_ID: ${{ github.run_id }}
+        run: |
+          gh pr view 46 --repo "${{ github.repository }}" --json body --jq .body > /tmp/body.md
+          python - <<'PY'
+          import os
+          from pathlib import Path
+          path = Path('/tmp/body.md')
+          body = path.read_text(encoding='utf-8')
+          start = '<!-- portapy-main-verification -->'
+          end = '<!-- /portapy-main-verification -->'
+          block = f'''{start}
+          ### Main-hosted exact branch verification
+
+          - Tested commit: `{os.environ["VERIFY_SHA"]}`
+          - Run: `{os.environ["VERIFY_RUN_ID"]}`
+          - Status: **in progress**
+          {end}'''
+          if start in body and end in body:
+              before, rest = body.split(start, 1)
+              _, after = rest.split(end, 1)
+              body = before.rstrip() + '\n\n' + block + after
+          else:
+              body = body.rstrip() + '\n\n' + block + '\n'
+          path.write_text(body, encoding='utf-8')
+          PY
+          gh pr edit 46 --repo "${{ github.repository }}" --body-file /tmp/body.md
+
+  hosted:
+    needs: announce
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: be5417cce8509adc3ba9d2fd9444fc716a591785
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install -e '.[test]'
+      - name: Run hosted suite
+        run: python -m pytest
+
+  native:
+    needs: announce
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-24.04
+            target: linux
+            library: dist/libportapy.so
+          - os: windows-2025
+            target: windows
+            library: dist/portapy.dll
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: be5417cce8509adc3ba9d2fd9444fc716a591785
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install Linux dependencies
+        if: matrix.target == 'linux'
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes nasm gcc binutils
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Install Windows dependencies
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          choco install nasm mingw -y --no-progress
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall `
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Build Linux library
+        if: matrix.target == 'linux'
+        shell: bash
+        run: |
+          mkdir -p dist
+          python tools/build_native_typed.py \
+            --target linux \
+            --output dist/libportapy.so \
+            --work-dir dist/build-verify-linux
+      - name: Build Windows library
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          New-Item -ItemType Directory -Force dist | Out-Null
+          python tools/build_native_typed.py `
+            --target windows `
+            --output dist/portapy.dll `
+            --work-dir dist/build-verify-windows
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - name: Verify Linux standalone library
+        if: matrix.target == 'linux'
+        shell: bash
+        run: |
+          if readelf -dW dist/libportapy.so | grep -Ei 'libpython|python3'; then exit 1; fi
+          if readelf -dW dist/libportapy.so | grep -q TEXTREL; then exit 1; fi
+          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
+            tests/native_full_runtime_host.c -ldl \
+            -o dist/native_full_runtime_host
+          env -i PATH="$PATH" HOME="$HOME" \
+            ./dist/native_full_runtime_host ./dist/libportapy.so \
+            | tee dist/native-output.txt
+          grep -qx 'native-full-runtime: ok' dist/native-output.txt
+          python tests/native_traceback_adapter_probe.py dist/libportapy.so
+      - name: Verify Windows standalone library
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          $imports = (& objdump -p dist/portapy.dll | Out-String)
+          if ($imports -match '(?i)python3|python\.dll') { throw 'CPython linkage is forbidden' }
+          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
+            tests/native_full_runtime_host.c `
+            -o dist/native_full_runtime_host.exe
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          $output = & dist/native_full_runtime_host.exe dist/portapy.dll
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          if ($output -ne 'native-full-runtime: ok') { throw "unexpected output: $output" }
+          python tests/native_traceback_adapter_probe.py dist/portapy.dll
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: portapy-3.14-${{ matrix.target }}
+          path: dist
+
+  report:
+    if: always()
+    needs: [hosted, native]
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Publish results
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERIFY_SHA: be5417cce8509adc3ba9d2fd9444fc716a591785
+          VERIFY_RUN_ID: ${{ github.run_id }}
+          HOSTED_RESULT: ${{ needs.hosted.result }}
+          NATIVE_RESULT: ${{ needs.native.result }}
+        run: |
+          gh pr view 46 --repo "${{ github.repository }}" --json body --jq .body > /tmp/body.md
+          python - <<'PY'
+          import os
+          from pathlib import Path
+          path = Path('/tmp/body.md')
+          body = path.read_text(encoding='utf-8')
+          start = '<!-- portapy-main-verification -->'
+          end = '<!-- /portapy-main-verification -->'
+          block = f'''{start}
+          ### Main-hosted exact branch verification
+
+          - Tested commit: `{os.environ["VERIFY_SHA"]}`
+          - Run: `{os.environ["VERIFY_RUN_ID"]}`
+          - Hosted suite: **{os.environ["HOSTED_RESULT"]}**
+          - Linux/Windows native matrix: **{os.environ["NATIVE_RESULT"]}**
+          {end}'''
+          if start in body and end in body:
+              before, rest = body.split(start, 1)
+              _, after = rest.split(end, 1)
+              body = before.rstrip() + '\n\n' + block + after
+          else:
+              body = body.rstrip() + '\n\n' + block + '\n'
+          path.write_text(body, encoding='utf-8')
+          PY
+          gh pr edit 46 --repo "${{ github.repository }}" --body-file /tmp/body.md

From 3aab4c59e16b8f9868a884e917661706b79c33dd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:08:40 -0500
Subject: [PATCH 165/450] Preserve native POP_TOP stack mutation

---
 tools/normalize_full_core_pop_top.py | 43 ++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 tools/normalize_full_core_pop_top.py

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
new file mode 100644
index 00000000..8c1f8c9b
--- /dev/null
+++ b/tools/normalize_full_core_pop_top.py
@@ -0,0 +1,43 @@
+"""Keep the POP_TOP list mutation visible to the native compiler.
+
+The pinned compiler mislowers a method call whose result is immediately
+ignored inside the VM dispatch loop.  Every assigned ``frame.stack.pop()``
+path works natively, while the lone bare POP_TOP call crashes.  Bind the
+removed value to a local so the list mutation is emitted normally; the local
+is intentionally unused after the assignment.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+
+_OLD = '''                elif op is Op.POP_TOP:
+                    frame.stack.pop()
+'''
+_NEW = '''                elif op is Op.POP_TOP:
+                    discarded = frame.stack.pop()
+'''
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    count = source.count(_OLD)
+    if count != 1:
+        raise RuntimeError(
+            f"native POP_TOP normalization expected one handler, found {count}"
+        )
+    source = source.replace(_OLD, _NEW, 1)
+    PATH.write_text(source, encoding="utf-8")
+
+    if source.count("discarded = frame.stack.pop()") != 1:
+        raise RuntimeError("native POP_TOP validation did not preserve assigned pop")
+    if _OLD in source:
+        raise RuntimeError("native POP_TOP bare pop remains after normalization")
+    print("NORMALIZED NATIVE POP_TOP", count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 1ab9f2630cad35963bff7792066f01b27defefb3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:09:21 -0500
Subject: [PATCH 166/450] Wire native POP_TOP normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 0cdf2ff3..07538baf 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -23,6 +23,7 @@
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
+from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
 from tools.normalize_full_reference_abi_helpers import (
@@ -126,6 +127,7 @@ def main() -> int:
     normalize_closures()
     normalize_pattern_slices()
     normalize_extended_semantics()
+    normalize_pop_top()
     normalize_collections()
     normalize_builtins()
     normalize_tracebacks()

From a7de5da69563c89c074f16d5a2c132a5936727cc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:09:37 -0500
Subject: [PATCH 167/450] Test native POP_TOP normalization

---
 tests/test_normalize_full_core_pop_top.py | 41 +++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 tests/test_normalize_full_core_pop_top.py

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
new file mode 100644
index 00000000..2e89242e
--- /dev/null
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_pop_top as normalizer
+
+
+def test_assigns_discarded_pop_result(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(
+        '''def run(frame, op):
+    if op is Op.LOAD_CONST:
+        frame.stack.append(1)
+    elif op is Op.POP_TOP:
+        frame.stack.pop()
+    elif op is Op.STORE_NAME:
+        value = frame.stack.pop()
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "discarded = frame.stack.pop()" in source
+    assert "value = frame.stack.pop()" in source
+    assert source.count("discarded = frame.stack.pop()") == 1
+
+
+def test_fails_closed_without_unique_handler(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text("def run():\n    return\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "expected one handler" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing POP_TOP handler")

From 903ff082e5dfcc155f4ff865b145c6c6fd22c116 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:16:01 -0500
Subject: [PATCH 168/450] Make native function construction type-safe

---
 tools/normalize_full_core_make_function.py | 129 +++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 tools/normalize_full_core_make_function.py

diff --git a/tools/normalize_full_core_make_function.py b/tools/normalize_full_core_make_function.py
new file mode 100644
index 00000000..026381c2
--- /dev/null
+++ b/tools/normalize_full_core_make_function.py
@@ -0,0 +1,129 @@
+"""Normalize MAKE_FUNCTION for the native compiler.
+
+The compiled VM represents user-class values as compact native class values.
+A runtime ``isinstance(nested, CodeObject)`` therefore dereferences that value
+as an object dictionary and crashes.  Give ``nested`` an explicit static
+CodeObject type instead and trust the frontend-produced constant.
+
+The original block also uses list slices and comprehensions while native slice
+objects are intentionally disabled during bootstrap.  Replace those operations
+with index-based loops so defaults, keyword defaults, and closure cells retain
+full semantics without unsupported runtime shapes.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+
+_START = "                elif op is Op.MAKE_FUNCTION:\n"
+_END = "                elif op is Op.MAKE_CLASS:\n"
+
+_REPLACEMENT = '''                elif op is Op.MAKE_FUNCTION:
+                    spec = frame.code.constants[instr.arg]
+                    nested: CodeObject = spec
+                    default_count = 0
+                    kw_default_count = 0
+                    annotations: dict[str, object] = {}
+                    if isinstance(spec, tuple) and len(spec) == 4:
+                        nested, default_count, kw_default_count, annotations = spec
+                    elif isinstance(spec, tuple) and len(spec) == 2:
+                        nested, default_count = spec
+                    elif isinstance(spec, tuple) and len(spec) == 3:
+                        nested, default_count, kw_default_count = spec
+                    else:
+                        nested = spec
+                    if nested is None:
+                        _raise_typed("TypeError: invalid function constant")
+                    count = default_count + kw_default_count
+                    if len(frame.stack) < count:
+                        _raise_typed("RuntimeError: default stack underflow")
+                    values: list[object] = []
+                    if count:
+                        value_index = len(frame.stack) - count
+                        while value_index < len(frame.stack):
+                            values.append(frame.stack[value_index])
+                            value_index += 1
+                        removed = 0
+                        while removed < count:
+                            discarded_default = frame.stack.pop()
+                            removed += 1
+                    defaults: list[object] = []
+                    default_index = 0
+                    while default_index < default_count:
+                        defaults.append(values[default_index])
+                        default_index += 1
+                    kw_defaults: dict[str, object] = {}
+                    kw_index = 0
+                    kw_name_start = len(nested.kwonly_names) - kw_default_count
+                    while kw_index < kw_default_count:
+                        kw_name = nested.kwonly_names[kw_name_start + kw_index]
+                        kw_defaults[kw_name] = values[default_count + kw_index]
+                        kw_index += 1
+                    closure: dict[str, object] = {}
+                    for name in nested.free_names:
+                        if name in frame.locals:
+                            closure[name] = frame.locals[name]
+                        elif frame.closure is not None and name in frame.closure:
+                            closure[name] = frame.closure[name]
+                    nested.validate()
+                    function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+                    if annotations:
+                        function._metadata["__annotations__"] = dict(annotations)
+                    frame.stack.append(function)
+'''
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    start = source.find(_START)
+    if start < 0:
+        raise RuntimeError("native MAKE_FUNCTION handler start not found")
+    end = source.find(_END, start + len(_START))
+    if end < 0:
+        raise RuntimeError("native MAKE_FUNCTION handler end not found")
+    if source.find(_START, start + len(_START)) >= 0:
+        raise RuntimeError("native MAKE_FUNCTION handler is not unique")
+
+    block = source[start:end]
+    required = (
+        "if not isinstance(nested, CodeObject)",
+        "values = frame.stack[-count:] if count else []",
+        "defaults = values[:default_count]",
+        "kw_defaults = {",
+        "closure = {",
+    )
+    missing = [marker for marker in required if marker not in block]
+    if missing:
+        raise RuntimeError(f"native MAKE_FUNCTION source shape changed: {missing}")
+
+    source = source[:start] + _REPLACEMENT + source[end:]
+    PATH.write_text(source, encoding="utf-8")
+
+    installed = source[start:start + len(_REPLACEMENT)]
+    validation = (
+        "nested: CodeObject = spec",
+        "if nested is None:",
+        "while default_index < default_count:",
+        "while kw_index < kw_default_count:",
+        "for name in nested.free_names:",
+        "discarded_default = frame.stack.pop()",
+    )
+    absent = [marker for marker in validation if marker not in installed]
+    if absent:
+        raise RuntimeError(f"native MAKE_FUNCTION validation failed: {absent}")
+    forbidden = (
+        "isinstance(nested, CodeObject)",
+        "frame.stack[-count:]",
+        "values[:default_count]",
+    )
+    remaining = [marker for marker in forbidden if marker in installed]
+    if remaining:
+        raise RuntimeError(f"native MAKE_FUNCTION unsafe forms remain: {remaining}")
+    print("NORMALIZED NATIVE MAKE_FUNCTION", 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From cc919dcbc64934b2f14ec9c2da95c5c0ad66e467 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:16:40 -0500
Subject: [PATCH 169/450] Wire native MAKE_FUNCTION normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 07538baf..dfb5395d 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -19,6 +19,7 @@
     main as normalize_keyword_calls,
 )
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
+from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
@@ -128,6 +129,7 @@ def main() -> int:
     normalize_pattern_slices()
     normalize_extended_semantics()
     normalize_pop_top()
+    normalize_make_function()
     normalize_collections()
     normalize_builtins()
     normalize_tracebacks()

From 8610302a214638caa751b3490669adb5ba356159 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:17:08 -0500
Subject: [PATCH 170/450] Test native MAKE_FUNCTION normalization

---
 .../test_normalize_full_core_make_function.py | 97 +++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 tests/test_normalize_full_core_make_function.py

diff --git a/tests/test_normalize_full_core_make_function.py b/tests/test_normalize_full_core_make_function.py
new file mode 100644
index 00000000..cb6b2666
--- /dev/null
+++ b/tests/test_normalize_full_core_make_function.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_make_function as normalizer
+
+
+_ORIGINAL = '''def run(frame, op, instr):
+    if op is Op.LOAD_CONST:
+        pass
+    elif op is Op.MAKE_FUNCTION:
+        spec = frame.code.constants[instr.arg]
+        default_count = 0
+        kw_default_count = 0
+        annotations: dict[str, object] = {}
+        if isinstance(spec, tuple) and len(spec) == 4:
+            nested, default_count, kw_default_count, annotations = spec
+        elif isinstance(spec, tuple) and len(spec) == 2:
+            nested, default_count = spec
+        elif isinstance(spec, tuple) and len(spec) == 3:
+            nested, default_count, kw_default_count = spec
+        else:
+            nested = spec
+        if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
+        count = default_count + kw_default_count
+        if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
+        values = frame.stack[-count:] if count else []
+        if count: del frame.stack[-count:]
+        defaults = values[:default_count]
+        kw_defaults = {
+            name: value for name, value in zip(nested.kwonly_names[-kw_default_count:], values[default_count:])
+        }
+        closure = {
+            name: (frame.locals[name] if name in frame.locals else frame.closure[name])
+            for name in nested.free_names
+            if name in frame.locals or (frame.closure is not None and name in frame.closure)
+        }
+        nested.validate()
+        function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+        if annotations:
+            function._metadata["__annotations__"] = dict(annotations)
+        frame.stack.append(function)
+    elif op is Op.MAKE_CLASS:
+        pass
+'''
+
+
+def test_removes_runtime_class_introspection_and_slices(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_ORIGINAL, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "nested: CodeObject = spec" in source
+    assert "if nested is None:" in source
+    assert "while default_index < default_count:" in source
+    assert "while kw_index < kw_default_count:" in source
+    assert "for name in nested.free_names:" in source
+    assert "isinstance(nested, CodeObject)" not in source
+    assert "frame.stack[-count:]" not in source
+    assert "values[:default_count]" not in source
+
+
+def test_preserves_make_class_boundary(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_ORIGINAL, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    source = path.read_text(encoding="utf-8")
+    assert source.count("elif op is Op.MAKE_FUNCTION:") == 1
+    assert source.count("elif op is Op.MAKE_CLASS:") == 1
+
+
+def test_fails_closed_when_source_shape_changes(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(
+        '''def run(frame, op):
+    if op is Op.MAKE_FUNCTION:
+        frame.stack.append(1)
+    elif op is Op.MAKE_CLASS:
+        pass
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "source shape changed" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unknown MAKE_FUNCTION shape")

From 173f3d9e1bfb830cf9b29150cf4ba0b054ea1836 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:18:14 -0500
Subject: [PATCH 171/450] Match production MAKE_FUNCTION indentation in tests

---
 .../test_normalize_full_core_make_function.py | 80 +++++++++----------
 1 file changed, 38 insertions(+), 42 deletions(-)

diff --git a/tests/test_normalize_full_core_make_function.py b/tests/test_normalize_full_core_make_function.py
index cb6b2666..932c2678 100644
--- a/tests/test_normalize_full_core_make_function.py
+++ b/tests/test_normalize_full_core_make_function.py
@@ -5,43 +5,40 @@
 from tools import normalize_full_core_make_function as normalizer
 
 
-_ORIGINAL = '''def run(frame, op, instr):
-    if op is Op.LOAD_CONST:
-        pass
-    elif op is Op.MAKE_FUNCTION:
-        spec = frame.code.constants[instr.arg]
-        default_count = 0
-        kw_default_count = 0
-        annotations: dict[str, object] = {}
-        if isinstance(spec, tuple) and len(spec) == 4:
-            nested, default_count, kw_default_count, annotations = spec
-        elif isinstance(spec, tuple) and len(spec) == 2:
-            nested, default_count = spec
-        elif isinstance(spec, tuple) and len(spec) == 3:
-            nested, default_count, kw_default_count = spec
-        else:
-            nested = spec
-        if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
-        count = default_count + kw_default_count
-        if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
-        values = frame.stack[-count:] if count else []
-        if count: del frame.stack[-count:]
-        defaults = values[:default_count]
-        kw_defaults = {
-            name: value for name, value in zip(nested.kwonly_names[-kw_default_count:], values[default_count:])
-        }
-        closure = {
-            name: (frame.locals[name] if name in frame.locals else frame.closure[name])
-            for name in nested.free_names
-            if name in frame.locals or (frame.closure is not None and name in frame.closure)
-        }
-        nested.validate()
-        function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
-        if annotations:
-            function._metadata["__annotations__"] = dict(annotations)
-        frame.stack.append(function)
-    elif op is Op.MAKE_CLASS:
-        pass
+_ORIGINAL = '''                elif op is Op.MAKE_FUNCTION:
+                    spec = frame.code.constants[instr.arg]
+                    default_count = 0
+                    kw_default_count = 0
+                    annotations: dict[str, object] = {}
+                    if isinstance(spec, tuple) and len(spec) == 4:
+                        nested, default_count, kw_default_count, annotations = spec
+                    elif isinstance(spec, tuple) and len(spec) == 2:
+                        nested, default_count = spec
+                    elif isinstance(spec, tuple) and len(spec) == 3:
+                        nested, default_count, kw_default_count = spec
+                    else:
+                        nested = spec
+                    if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
+                    count = default_count + kw_default_count
+                    if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
+                    values = frame.stack[-count:] if count else []
+                    if count: del frame.stack[-count:]
+                    defaults = values[:default_count]
+                    kw_defaults = {
+                        name: value for name, value in zip(nested.kwonly_names[-kw_default_count:], values[default_count:])
+                    }
+                    closure = {
+                        name: (frame.locals[name] if name in frame.locals else frame.closure[name])
+                        for name in nested.free_names
+                        if name in frame.locals or (frame.closure is not None and name in frame.closure)
+                    }
+                    nested.validate()
+                    function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+                    if annotations:
+                        function._metadata["__annotations__"] = dict(annotations)
+                    frame.stack.append(function)
+                elif op is Op.MAKE_CLASS:
+                    pass
 '''
 
 
@@ -79,11 +76,10 @@ def test_preserves_make_class_boundary(tmp_path: Path, monkeypatch) -> None:
 def test_fails_closed_when_source_shape_changes(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
     path.write_text(
-        '''def run(frame, op):
-    if op is Op.MAKE_FUNCTION:
-        frame.stack.append(1)
-    elif op is Op.MAKE_CLASS:
-        pass
+        '''                elif op is Op.MAKE_FUNCTION:
+                    frame.stack.append(1)
+                elif op is Op.MAKE_CLASS:
+                    pass
 ''',
         encoding="utf-8",
     )

From 87e675b312657b09090a3334b5dbabce060c37da Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:23:50 -0500
Subject: [PATCH 172/450] Accept normalized MAKE_FUNCTION input shape

---
 tools/normalize_full_core_make_function.py | 127 ++++++++++++---------
 1 file changed, 73 insertions(+), 54 deletions(-)

diff --git a/tools/normalize_full_core_make_function.py b/tools/normalize_full_core_make_function.py
index 026381c2..dfec6168 100644
--- a/tools/normalize_full_core_make_function.py
+++ b/tools/normalize_full_core_make_function.py
@@ -21,60 +21,74 @@
 _END = "                elif op is Op.MAKE_CLASS:\n"
 
 _REPLACEMENT = '''                elif op is Op.MAKE_FUNCTION:
-                    spec = frame.code.constants[instr.arg]
-                    nested: CodeObject = spec
-                    default_count = 0
-                    kw_default_count = 0
-                    annotations: dict[str, object] = {}
-                    if isinstance(spec, tuple) and len(spec) == 4:
-                        nested, default_count, kw_default_count, annotations = spec
-                    elif isinstance(spec, tuple) and len(spec) == 2:
-                        nested, default_count = spec
-                    elif isinstance(spec, tuple) and len(spec) == 3:
-                        nested, default_count, kw_default_count = spec
-                    else:
-                        nested = spec
-                    if nested is None:
-                        _raise_typed("TypeError: invalid function constant")
-                    count = default_count + kw_default_count
-                    if len(frame.stack) < count:
-                        _raise_typed("RuntimeError: default stack underflow")
-                    values: list[object] = []
-                    if count:
-                        value_index = len(frame.stack) - count
-                        while value_index < len(frame.stack):
-                            values.append(frame.stack[value_index])
-                            value_index += 1
-                        removed = 0
-                        while removed < count:
-                            discarded_default = frame.stack.pop()
-                            removed += 1
-                    defaults: list[object] = []
-                    default_index = 0
-                    while default_index < default_count:
-                        defaults.append(values[default_index])
-                        default_index += 1
-                    kw_defaults: dict[str, object] = {}
-                    kw_index = 0
-                    kw_name_start = len(nested.kwonly_names) - kw_default_count
-                    while kw_index < kw_default_count:
-                        kw_name = nested.kwonly_names[kw_name_start + kw_index]
-                        kw_defaults[kw_name] = values[default_count + kw_index]
-                        kw_index += 1
-                    closure: dict[str, object] = {}
-                    for name in nested.free_names:
-                        if name in frame.locals:
-                            closure[name] = frame.locals[name]
-                        elif frame.closure is not None and name in frame.closure:
-                            closure[name] = frame.closure[name]
-                    nested.validate()
-                    function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
-                    if annotations:
-                        function._metadata["__annotations__"] = dict(annotations)
-                    frame.stack.append(function)
+                     spec = frame.code.constants[instr.arg]
+                     nested: CodeObject = spec
+                     default_count = 0
+                     kw_default_count = 0
+                     annotations: dict[str, object] = {}
+                     if isinstance(spec, tuple) and len(spec) == 4:
+                         nested, default_count, kw_default_count, annotations = spec
+                     elif isinstance(spec, tuple) and len(spec) == 2:
+                         nested, default_count = spec
+                     elif isinstance(spec, tuple) and len(spec) == 3:
+                         nested, default_count, kw_default_count = spec
+                     else:
+                         nested = spec
+                     if nested is None:
+                         _raise_typed("TypeError: invalid function constant")
+                     count = default_count + kw_default_count
+                     if len(frame.stack) < count:
+                         _raise_typed("RuntimeError: default stack underflow")
+                     values: list[object] = []
+                     if count:
+                         value_index = len(frame.stack) - count
+                         while value_index < len(frame.stack):
+                             values.append(frame.stack[value_index])
+                             value_index += 1
+                         removed = 0
+                         while removed < count:
+                             discarded_default = frame.stack.pop()
+                             removed += 1
+                     defaults: list[object] = []
+                     default_index = 0
+                     while default_index < default_count:
+                         defaults.append(values[default_index])
+                         default_index += 1
+                     kw_defaults: dict[str, object] = {}
+                     kw_index = 0
+                     kw_name_start = len(nested.kwonly_names) - kw_default_count
+                     while kw_index < kw_default_count:
+                         kw_name = nested.kwonly_names[kw_name_start + kw_index]
+                         kw_defaults[kw_name] = values[default_count + kw_index]
+                         kw_index += 1
+                     closure: dict[str, object] = {}
+                     for name in nested.free_names:
+                         if name in frame.locals:
+                             closure[name] = frame.locals[name]
+                         elif frame.closure is not None and name in frame.closure:
+                             closure[name] = frame.closure[name]
+                     nested.validate()
+                     function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+                     if annotations:
+                         function._metadata["__annotations__"] = dict(annotations)
+                     frame.stack.append(function)
 '''
 
 
+_LEGACY_DEFAULTS_SHAPE = (
+    "values = frame.stack[-count:] if count else []",
+    "defaults = values[:default_count]",
+    "kw_defaults = {",
+)
+
+_NATIVE_SEMANTICS_DEFAULTS_SHAPE = (
+    "values = _full_core_probe_pop_tail(frame.stack, count)",
+    "defaults = _full_core_probe_copy_range(values, 0, default_count)",
+    "kw_defaults: dict[str, object] = {}",
+    "while kw_index < kw_default_count:",
+)
+
+
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
     start = source.find(_START)
@@ -88,16 +102,21 @@ def main() -> int:
 
     block = source[start:end]
     required = (
+        "spec = frame.code.constants[instr.arg]",
         "if not isinstance(nested, CodeObject)",
-        "values = frame.stack[-count:] if count else []",
-        "defaults = values[:default_count]",
-        "kw_defaults = {",
+        "count = default_count + kw_default_count",
         "closure = {",
+        "function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)",
+        "frame.stack.append(function)",
     )
     missing = [marker for marker in required if marker not in block]
     if missing:
         raise RuntimeError(f"native MAKE_FUNCTION source shape changed: {missing}")
 
+    defaults_shapes = (_LEGACY_DEFAULTS_SHAPE, _NATIVE_SEMANTICS_DEFAULTS_SHAPE)
+    if not any(all(marker in block for marker in shape) for shape in defaults_shapes):
+        raise RuntimeError("native MAKE_FUNCTION source shape changed: default extraction")
+
     source = source[:start] + _REPLACEMENT + source[end:]
     PATH.write_text(source, encoding="utf-8")
 

From 52192130b8c98294a78f296c5b943697c32fdc9b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:24:25 -0500
Subject: [PATCH 173/450] Test normalized MAKE_FUNCTION pipeline input

---
 .../test_normalize_full_core_make_function.py | 117 ++++++++++++------
 1 file changed, 81 insertions(+), 36 deletions(-)

diff --git a/tests/test_normalize_full_core_make_function.py b/tests/test_normalize_full_core_make_function.py
index 932c2678..60eff17e 100644
--- a/tests/test_normalize_full_core_make_function.py
+++ b/tests/test_normalize_full_core_make_function.py
@@ -6,39 +6,68 @@
 
 
 _ORIGINAL = '''                elif op is Op.MAKE_FUNCTION:
-                    spec = frame.code.constants[instr.arg]
-                    default_count = 0
-                    kw_default_count = 0
-                    annotations: dict[str, object] = {}
-                    if isinstance(spec, tuple) and len(spec) == 4:
-                        nested, default_count, kw_default_count, annotations = spec
-                    elif isinstance(spec, tuple) and len(spec) == 2:
-                        nested, default_count = spec
-                    elif isinstance(spec, tuple) and len(spec) == 3:
-                        nested, default_count, kw_default_count = spec
-                    else:
-                        nested = spec
-                    if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
-                    count = default_count + kw_default_count
-                    if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
-                    values = frame.stack[-count:] if count else []
-                    if count: del frame.stack[-count:]
-                    defaults = values[:default_count]
-                    kw_defaults = {
-                        name: value for name, value in zip(nested.kwonly_names[-kw_default_count:], values[default_count:])
-                    }
-                    closure = {
-                        name: (frame.locals[name] if name in frame.locals else frame.closure[name])
-                        for name in nested.free_names
-                        if name in frame.locals or (frame.closure is not None and name in frame.closure)
-                    }
-                    nested.validate()
-                    function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
-                    if annotations:
-                        function._metadata["__annotations__"] = dict(annotations)
-                    frame.stack.append(function)
-                elif op is Op.MAKE_CLASS:
-                    pass
+                     spec = frame.code.constants[instr.arg]
+                     default_count = 0
+                     kw_default_count = 0
+                     annotations: dict[str, object] = {}
+                     if isinstance(spec, tuple) and len(spec) == 4:
+                         nested, default_count, kw_default_count, annotations = spec
+                     elif isinstance(spec, tuple) and len(spec) == 2:
+                         nested, default_count = spec
+                     elif isinstance(spec, tuple) and len(spec) == 3:
+                         nested, default_count, kw_default_count = spec
+                     else:
+                         nested = spec
+                     if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
+                     count = default_count + kw_default_count
+                     if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
+                     values = frame.stack[-count:] if count else []
+                     if count: del frame.stack[-count:]
+                     defaults = values[:default_count]
+                     kw_defaults = {
+                         name: value for name, value in zip(nested.kwonly_names[-kw_default_count:], values[default_count:])
+                     }
+                     closure = {
+                         name: (frame.locals[name] if name in frame.locals else frame.closure[name])
+                         for name in nested.free_names
+                         if name in frame.locals or (frame.closure is not None and name in frame.closure)
+                     }
+                     nested.validate()
+                     function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+                     if annotations:
+                         function._metadata["__annotations__"] = dict(annotations)
+                     frame.stack.append(function)
+                 elif op is Op.MAKE_CLASS:
+                     pass
+'''
+
+_NATIVE_SEMANTICS_INPUT = '''                elif op is Op.MAKE_FUNCTION:
+                     spec = frame.code.constants[instr.arg]
+                     default_count = 0
+                     kw_default_count = 0
+                     annotations: dict[str, object] = {}
+                     nested = spec
+                     if not isinstance(nested, CodeObject): _raise_typed("TypeError: invalid function constant")
+                     count = default_count + kw_default_count
+                     if len(frame.stack) < count: _raise_typed("RuntimeError: default stack underflow")
+                     values = _full_core_probe_pop_tail(frame.stack, count)
+                     defaults = _full_core_probe_copy_range(values, 0, default_count)
+                     kw_defaults: dict[str, object] = {}
+                     kw_name_start = len(nested.kwonly_names) - kw_default_count
+                     kw_index = 0
+                     while kw_index < kw_default_count:
+                         kw_defaults[nested.kwonly_names[kw_name_start + kw_index]] = values[default_count + kw_index]
+                         kw_index += 1
+                     closure = {
+                         name: (frame.locals[name] if name in frame.locals else frame.closure[name])
+                         for name in nested.free_names
+                         if name in frame.locals or (frame.closure is not None and name in frame.closure)
+                     }
+                     nested.validate()
+                     function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)
+                     frame.stack.append(function)
+                 elif op is Op.MAKE_CLASS:
+                     pass
 '''
 
 
@@ -62,6 +91,22 @@ def test_removes_runtime_class_introspection_and_slices(
     assert "values[:default_count]" not in source
 
 
+def test_accepts_native_semantics_intermediate_shape(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_NATIVE_SEMANTICS_INPUT, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "nested: CodeObject = spec" in source
+    assert "discarded_default = frame.stack.pop()" in source
+    assert "_full_core_probe_pop_tail(frame.stack, count)" not in source
+    assert "_full_core_probe_copy_range(values, 0, default_count)" not in source
+
+
 def test_preserves_make_class_boundary(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
     path.write_text(_ORIGINAL, encoding="utf-8")
@@ -77,9 +122,9 @@ def test_fails_closed_when_source_shape_changes(tmp_path: Path, monkeypatch) ->
     path = tmp_path / "vm.py"
     path.write_text(
         '''                elif op is Op.MAKE_FUNCTION:
-                    frame.stack.append(1)
-                elif op is Op.MAKE_CLASS:
-                    pass
+                     frame.stack.append(1)
+                 elif op is Op.MAKE_CLASS:
+                     pass
 ''',
         encoding="utf-8",
     )

From a1ba9003ef2a92cbb56fcd24a4a2b9b3d142f508 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:45:42 -0500
Subject: [PATCH 174/450] Fix native expression kind precedence

---
 ...rmalize_full_reference_expression_kinds.py | 233 ++++++++++++++++++
 1 file changed, 233 insertions(+)
 create mode 100644 tools/normalize_full_reference_expression_kinds.py

diff --git a/tools/normalize_full_reference_expression_kinds.py b/tools/normalize_full_reference_expression_kinds.py
new file mode 100644
index 00000000..a001f4ff
--- /dev/null
+++ b/tools/normalize_full_reference_expression_kinds.py
@@ -0,0 +1,233 @@
+"""Install source-kind inference that respects expression structure.
+
+The native ABI keeps a lightweight source-derived kind ledger because raw native
+values cannot always distinguish ``None``, ``False``, and integer zero.  The
+original classifier checked literal prefixes before comparisons, so
+``\"a\" < \"b\"`` was exposed as a string even though the VM correctly returned a
+boolean.  It also treated every ``and``/``or`` expression as boolean even though
+Python returns one of the operands.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_REPLACEMENT = r'''
+def _native_has_top_level_comparison(text: str) -> bool:
+    depth = 0
+    quote = ""
+    escaped = False
+    token = ""
+    index = 0
+    while index <= len(text):
+        char = text[index] if index < len(text) else " "
+        if quote != "":
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+            token = ""
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+            token = ""
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+            token = ""
+        elif depth == 0:
+            if char.isalpha() or char == "_":
+                token += char
+            else:
+                if token == "is" or token == "in" or token == "not":
+                    return True
+                token = ""
+                if char == "<" or char == ">":
+                    return True
+                if (
+                    (char == "=" or char == "!")
+                    and index + 1 < len(text)
+                    and text[index + 1] == "="
+                ):
+                    return True
+        index += 1
+    return False
+
+
+def _native_top_level_bool_rhs(text: str) -> str:
+    depth = 0
+    quote = ""
+    escaped = False
+    token = ""
+    result = ""
+    index = 0
+    while index <= len(text):
+        char = text[index] if index < len(text) else " "
+        if quote != "":
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                quote = ""
+        elif char == "'" or char == '"':
+            quote = char
+            token = ""
+        elif char == "(" or char == "[" or char == "{":
+            depth += 1
+            token = ""
+        elif char == ")" or char == "]" or char == "}":
+            depth -= 1
+            token = ""
+        elif depth == 0:
+            if char.isalpha() or char == "_":
+                token += char
+            else:
+                if token == "and" or token == "or":
+                    result = text[index:]
+                token = ""
+        index += 1
+    return result.strip()
+
+
+def _native_expression_kind(runtime: int, expression: str) -> int:
+    text = expression.strip()
+    if text == "None":
+        return PORTAPY_VALUE_NONE
+    if text == "True" or text == "False":
+        return PORTAPY_VALUE_BOOL
+    if len(text) == 0:
+        return PORTAPY_VALUE_OBJECT
+    lower = text.lower()
+    if lower.startswith("lambda "):
+        return PORTAPY_VALUE_CALLABLE
+    if _native_has_top_level_comparison(text):
+        return PORTAPY_VALUE_BOOL
+    bool_rhs = _native_top_level_bool_rhs(text)
+    if len(bool_rhs) > 0:
+        return _native_expression_kind(runtime, bool_rhs)
+    if (
+        lower.startswith("b'")
+        or lower.startswith('b"')
+        or lower.startswith("br'")
+        or lower.startswith('br"')
+        or lower.startswith("rb'")
+        or lower.startswith('rb"')
+    ):
+        return PORTAPY_VALUE_BYTES
+    if (
+        text[0] == "'"
+        or text[0] == '"'
+        or lower.startswith("r'")
+        or lower.startswith('r"')
+        or lower.startswith("f'")
+        or lower.startswith('f"')
+        or lower.startswith("fr'")
+        or lower.startswith('fr"')
+        or lower.startswith("rf'")
+        or lower.startswith('rf"')
+    ):
+        return PORTAPY_VALUE_STRING
+    if text[0] == "[":
+        return PORTAPY_VALUE_LIST
+    if text[0] == "{":
+        return PORTAPY_VALUE_DICT
+    if text[0] == "(" and text[len(text) - 1] == ")":
+        inner = text[1:len(text) - 1]
+        if _native_has_top_level_comma(inner):
+            return PORTAPY_VALUE_TUPLE
+        return _native_expression_kind(runtime, inner)
+    if _native_has_top_level_comma(text):
+        return PORTAPY_VALUE_TUPLE
+    if _native_is_identifier(text):
+        return _native_global_kind(runtime, text)
+    if _native_is_number(text):
+        if "." in text or "e" in lower:
+            return PORTAPY_VALUE_FLOAT
+        return PORTAPY_VALUE_INT
+    open_at = text.find("(")
+    if open_at > 0:
+        callee = text[0:open_at].strip()
+        if _native_is_identifier(callee):
+            callee_kind = _native_global_kind(runtime, callee)
+            if callee_kind == PORTAPY_VALUE_CALLABLE:
+                return PORTAPY_VALUE_OBJECT
+    if _native_expression_has_kind(runtime, text, PORTAPY_VALUE_FLOAT):
+        return PORTAPY_VALUE_FLOAT
+    if "/" in text and "//" not in text:
+        return PORTAPY_VALUE_FLOAT
+    if _native_expression_has_kind(runtime, text, PORTAPY_VALUE_STRING):
+        if "+" in text:
+            return PORTAPY_VALUE_STRING
+    return PORTAPY_VALUE_INT
+'''
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    matches = [
+        index
+        for index, node in enumerate(module.body)
+        if isinstance(node, ast.FunctionDef)
+        and node.name == "_native_expression_kind"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            "native expression-kind helper: expected 1, "
+            f"found {len(matches)}"
+        )
+    existing = {
+        node.name
+        for node in module.body
+        if isinstance(node, ast.FunctionDef)
+        and node.name in {
+            "_native_has_top_level_comparison",
+            "_native_top_level_bool_rhs",
+        }
+    }
+    if existing:
+        raise RuntimeError(
+            "native expression-kind structural helpers already exist: "
+            + ", ".join(sorted(existing))
+        )
+
+    replacement = ast.parse(_REPLACEMENT).body
+    index = matches[0]
+    module.body[index:index + 1] = replacement
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    functions = {
+        node.name: node
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef)
+    }
+    required = {
+        "_native_has_top_level_comparison",
+        "_native_top_level_bool_rhs",
+        "_native_expression_kind",
+    }
+    missing = sorted(required - functions.keys())
+    if missing:
+        raise RuntimeError(
+            "native expression-kind normalization lost helpers: "
+            + ", ".join(missing)
+        )
+    expression_text = ast.unparse(functions["_native_expression_kind"])
+    if expression_text.find("_native_has_top_level_comparison(text)") < 0:
+        raise RuntimeError("native comparison kind inference was not installed")
+    if expression_text.find("_native_top_level_bool_rhs(text)") < 0:
+        raise RuntimeError("native boolean-operand kind inference was not installed")
+    print("NORMALIZED NATIVE EXPRESSION VALUE KINDS", len(replacement))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 1fad518302d48255b7368029206ab1207fdab97b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:46:14 -0500
Subject: [PATCH 175/450] Run expression kind normalization in native build

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index dfb5395d..cfe59284 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -48,6 +48,9 @@
 from tools.normalize_full_reference_errors import (
     main as normalize_reference_errors,
 )
+from tools.normalize_full_reference_expression_kinds import (
+    main as normalize_reference_expression_kinds,
+)
 from tools.normalize_full_reference_float_bits import (
     main as normalize_reference_float_bits,
 )
@@ -115,6 +118,7 @@ def main() -> int:
     normalize_reference_error_text()
     normalize_reference_error_locations()
     normalize_reference_value_kinds()
+    normalize_reference_expression_kinds()
     normalize_reference_nested_kinds()
     normalize_reference_source_preprocess()
     normalize_reference_data_builders()

From 3298a1ce4f3e66b164fe018322f85e3cb9f83e1d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 21:46:41 -0500
Subject: [PATCH 176/450] Test literal comparison and boolop value kinds

---
 ...rmalize_full_reference_expression_kinds.py | 74 +++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_expression_kinds.py

diff --git a/tests/test_normalize_full_reference_expression_kinds.py b/tests/test_normalize_full_reference_expression_kinds.py
new file mode 100644
index 00000000..74517ee7
--- /dev/null
+++ b/tests/test_normalize_full_reference_expression_kinds.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_reference_expression_kinds as normalizer
+from tools import normalize_full_reference_value_kinds as value_kinds
+
+
+_PRELUDE = '''
+PORTAPY_VALUE_NONE = 0
+PORTAPY_VALUE_BOOL = 1
+PORTAPY_VALUE_INT = 2
+PORTAPY_VALUE_FLOAT = 3
+PORTAPY_VALUE_STRING = 4
+PORTAPY_VALUE_BYTES = 5
+PORTAPY_VALUE_CALLABLE = 6
+PORTAPY_VALUE_OBJECT = 7
+PORTAPY_VALUE_TUPLE = 8
+PORTAPY_VALUE_DICT = 9
+PORTAPY_VALUE_LIST = 10
+
+class Runtime:
+    pass
+
+class ValueKind:
+    NONE = object()
+    BOOL = object()
+    INT = object()
+    FLOAT = object()
+    STRING = object()
+    BYTES = object()
+    CALLABLE = object()
+    OBJECT = object()
+    TUPLE = object()
+    DICT = object()
+    LIST = object()
+
+'''
+
+
+def _normalized_helpers(tmp_path: Path, monkeypatch) -> dict[str, object]:
+    path = tmp_path / "native_full_reference_entry.py"
+    path.write_text(_PRELUDE + value_kinds._KIND_HELPERS, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    namespace: dict[str, object] = {}
+    exec(path.read_text(encoding="utf-8"), namespace)
+    return namespace
+
+
+def test_literal_left_comparison_is_boolean(tmp_path: Path, monkeypatch) -> None:
+    namespace = _normalized_helpers(tmp_path, monkeypatch)
+    infer = namespace["_native_expression_kind"]
+
+    assert infer(1, '"abc" < "abd"') == 1
+    assert infer(1, '("abc" < "abd")') == 1
+    assert infer(1, "'a < b'") == 4
+
+
+def test_boolops_keep_operand_kinds(tmp_path: Path, monkeypatch) -> None:
+    namespace = _normalized_helpers(tmp_path, monkeypatch)
+    infer = namespace["_native_expression_kind"]
+    set_kind = namespace["_native_set_global_kind"]
+
+    set_kind(7, "empty", 4)
+    set_kind(7, "name", 4)
+    set_kind(7, "answer", 2)
+
+    assert infer(7, "empty or name") == 4
+    assert infer(7, "name and answer") == 2
+    assert infer(7, 'answer > 40 and name == "Somnia"') == 1
+    assert infer(7, "not empty") == 1

From c2475dc87e8ec918e5f3e7b0cb278a0799ff5867 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:28:14 -0500
Subject: [PATCH 177/450] Add typed native truthiness lowering

---
 tools/normalize_full_core_truthiness.py | 787 ++++++++++++++++++++++++
 1 file changed, 787 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness.py

diff --git a/tools/normalize_full_core_truthiness.py b/tools/normalize_full_core_truthiness.py
new file mode 100644
index 00000000..42e6e394
--- /dev/null
+++ b/tools/normalize_full_core_truthiness.py
@@ -0,0 +1,787 @@
+"""Install kind-aware truth-value lowering in the full native runtime.
+
+Native PortaPy values intentionally use compact raw representations.  A raw
+pointer is sufficient for ordinary object transport, but generic native
+``bool(value)`` cannot distinguish an empty string/container from a non-empty
+one.  The ABI already maintains source-derived value-kind hints; this pass
+threads those hints into the frontend and emits one typed ``TO_BOOL`` opcode at
+all user-code truth-test sites.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+VM_PATH = Path("src/portapy/core/vm.py")
+ENTRY_PATH = Path("src/portapy/native_full_reference_entry.py")
+
+TRUTH_UNKNOWN = 0
+TRUTH_BOOL = 1
+TRUTH_INT = 2
+TRUTH_FLOAT = 3
+TRUTH_STRING = 4
+TRUTH_BYTES = 5
+TRUTH_CONTAINER = 6
+TRUTH_NONE = 7
+
+
+_KIND_CONSTANTS = ast.parse(
+    """
+_TRUTH_UNKNOWN = 0
+_TRUTH_BOOL = 1
+_TRUTH_INT = 2
+_TRUTH_FLOAT = 3
+_TRUTH_STRING = 4
+_TRUTH_BYTES = 5
+_TRUTH_CONTAINER = 6
+_TRUTH_NONE = 7
+"""
+).body
+
+_KIND_METHODS = ast.parse(
+    """
+def expression_kind(self, node: ast.expr) -> int:
+    if isinstance(node, ast.Name):
+        return self.kind_hints.get(node.id, _TRUTH_UNKNOWN)
+    if isinstance(node, ast.Compare):
+        return _TRUTH_BOOL
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+        return _TRUTH_BOOL
+    if isinstance(node, ast.BoolOp):
+        if not node.values:
+            return _TRUTH_UNKNOWN
+        result = self.expression_kind(node.values[0])
+        index = 1
+        while index < len(node.values):
+            candidate = self.expression_kind(node.values[index])
+            if candidate != result:
+                return _TRUTH_UNKNOWN
+            index += 1
+        return result
+    if isinstance(node, ast.IfExp):
+        body_kind = self.expression_kind(node.body)
+        other_kind = self.expression_kind(node.orelse)
+        return body_kind if body_kind == other_kind else _TRUTH_UNKNOWN
+    if isinstance(node, ast.JoinedStr):
+        return _TRUTH_STRING
+    if isinstance(node, (ast.List, ast.Tuple, ast.Dict, ast.Set)):
+        return _TRUTH_CONTAINER
+    if isinstance(node, ast.Constant):
+        value = node.value
+        if value is None:
+            return _TRUTH_NONE
+        if value is True or value is False:
+            return _TRUTH_BOOL
+        if isinstance(value, str):
+            return _TRUTH_STRING
+        if isinstance(value, bytes):
+            return _TRUTH_BYTES
+        if isinstance(value, float):
+            return _TRUTH_FLOAT
+        if isinstance(value, int):
+            return _TRUTH_INT
+    if isinstance(node, ast.BinOp):
+        left = self.expression_kind(node.left)
+        right = self.expression_kind(node.right)
+        if isinstance(node.op, ast.Add) and left == _TRUTH_STRING and right == _TRUTH_STRING:
+            return _TRUTH_STRING
+        if isinstance(node.op, ast.Div) or left == _TRUTH_FLOAT or right == _TRUTH_FLOAT:
+            return _TRUTH_FLOAT
+        if left == _TRUTH_INT and right == _TRUTH_INT:
+            return _TRUTH_INT
+    return _TRUTH_UNKNOWN
+
+
+def emit_truth(self, node: ast.expr) -> None:
+    self.emit(Op.TO_BOOL, self.expression_kind(node))
+"""
+).body
+
+_TRUTH_HELPER = ast.parse(
+    """
+def _full_core_probe_truthy(value: object, kind: int) -> bool:
+    if kind == 7:
+        return False
+    if kind == 1 or kind == 2:
+        return value != 0
+    if kind == 3:
+        return value != 0.0
+    if kind == 4 or kind == 5 or kind == 6:
+        return len(value) != 0
+    return bool(value)
+"""
+).body[0]
+
+
+def _is_self_call(statement: ast.stmt, method: str) -> ast.Call | None:
+    if not isinstance(statement, ast.Expr) or not isinstance(statement.value, ast.Call):
+        return None
+    call = statement.value
+    if (
+        isinstance(call.func, ast.Attribute)
+        and isinstance(call.func.value, ast.Name)
+        and call.func.value.id == "self"
+        and call.func.attr == method
+    ):
+        return call
+    return None
+
+
+def _op_member(call: ast.Call, name: str) -> bool:
+    return (
+        isinstance(call.func, ast.Attribute)
+        and isinstance(call.func.value, ast.Name)
+        and call.func.value.id == "self"
+        and call.func.attr == "emit"
+        and bool(call.args)
+        and isinstance(call.args[0], ast.Attribute)
+        and isinstance(call.args[0].value, ast.Name)
+        and call.args[0].value.id == "Op"
+        and call.args[0].attr == name
+    )
+
+
+def _emit_truth_statement(expression: ast.expr) -> ast.Expr:
+    return ast.Expr(
+        value=ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id="self", ctx=ast.Load()),
+                attr="emit_truth",
+                ctx=ast.Load(),
+            ),
+            args=[expression],
+            keywords=[],
+        )
+    )
+
+
+def _kind_assignment(name: ast.expr, value: ast.expr) -> ast.Assign:
+    return ast.Assign(
+        targets=[
+            ast.Subscript(
+                value=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr="kind_hints",
+                    ctx=ast.Load(),
+                ),
+                slice=name,
+                ctx=ast.Store(),
+            )
+        ],
+        value=ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id="self", ctx=ast.Load()),
+                attr="expression_kind",
+                ctx=ast.Load(),
+            ),
+            args=[value],
+            keywords=[],
+        ),
+    )
+
+
+class _TruthSiteRewriter(ast.NodeTransformer):
+    """Insert ``emit_truth`` between expression evaluation and truth consumers."""
+
+    def __init__(self) -> None:
+        self.count = 0
+        self.assignment_count = 0
+
+    def _rewrite_sequence(self, body: list[ast.stmt]) -> list[ast.stmt]:
+        rewritten: list[ast.stmt] = []
+        index = 0
+        while index < len(body):
+            statement = body[index]
+            rewritten.append(statement)
+            expr_call = _is_self_call(statement, "expr")
+            if expr_call is not None and expr_call.args:
+                expression = expr_call.args[0]
+                next_statement = body[index + 1] if index + 1 < len(body) else None
+                next_call = _is_self_call(next_statement, "emit") if next_statement is not None else None
+                if next_call is not None and any(
+                    _op_member(next_call, name)
+                    for name in ("JUMP_IF_FALSE", "JUMP_IF_TRUE")
+                ):
+                    rewritten.append(_emit_truth_statement(expression))
+                    self.count += 1
+                elif (
+                    next_call is not None
+                    and _op_member(next_call, "DUP_TOP")
+                    and index + 2 < len(body)
+                ):
+                    third = body[index + 2]
+                    jump_calls = [
+                        node
+                        for node in ast.walk(third)
+                        if isinstance(node, ast.Call)
+                        and any(
+                            _op_member(node, name)
+                            for name in ("JUMP_IF_FALSE_KEEP", "JUMP_IF_TRUE_KEEP")
+                        )
+                    ]
+                    if jump_calls:
+                        rewritten.append(next_statement)
+                        rewritten.append(_emit_truth_statement(expression))
+                        self.count += 1
+                        index += 1
+            index += 1
+        return rewritten
+
+    def _rewrite_assign_branch(self, node: ast.If) -> None:
+        test_text = ast.unparse(node.test)
+        if "isinstance(node, ast.Assign)" in test_text:
+            for branch in ast.walk(node):
+                if not isinstance(branch, ast.If):
+                    continue
+                branch_text = ast.unparse(branch.test)
+                if (
+                    "len(node.targets) == 1" not in branch_text
+                    or "ast.Name" not in branch_text
+                ):
+                    continue
+                for index, statement in enumerate(branch.body):
+                    call = _is_self_call(statement, "store")
+                    if call is None:
+                        continue
+                    branch.body.insert(
+                        index + 1,
+                        _kind_assignment(
+                            ast.Attribute(
+                                value=ast.Subscript(
+                                    value=ast.Attribute(
+                                        value=ast.Name(id="node", ctx=ast.Load()),
+                                        attr="targets",
+                                        ctx=ast.Load(),
+                                    ),
+                                    slice=ast.Constant(0),
+                                    ctx=ast.Load(),
+                                ),
+                                attr="id",
+                                ctx=ast.Load(),
+                            ),
+                            ast.Attribute(
+                                value=ast.Name(id="node", ctx=ast.Load()),
+                                attr="value",
+                                ctx=ast.Load(),
+                            ),
+                        ),
+                    )
+                    self.assignment_count += 1
+                    return
+        if "isinstance(node, ast.AnnAssign)" in test_text and "node.value is not None" in test_text:
+            for index, statement in enumerate(node.body):
+                call = _is_self_call(statement, "store")
+                if call is None:
+                    continue
+                name = ast.Attribute(
+                    value=ast.Attribute(
+                        value=ast.Name(id="node", ctx=ast.Load()),
+                        attr="target",
+                        ctx=ast.Load(),
+                    ),
+                    attr="id",
+                    ctx=ast.Load(),
+                )
+                value = ast.Attribute(
+                    value=ast.Name(id="node", ctx=ast.Load()),
+                    attr="value",
+                    ctx=ast.Load(),
+                )
+                guarded = ast.If(
+                    test=ast.Call(
+                        func=ast.Name(id="isinstance", ctx=ast.Load()),
+                        args=[
+                            ast.Attribute(
+                                value=ast.Name(id="node", ctx=ast.Load()),
+                                attr="target",
+                                ctx=ast.Load(),
+                            ),
+                            ast.Attribute(
+                                value=ast.Name(id="ast", ctx=ast.Load()),
+                                attr="Name",
+                                ctx=ast.Load(),
+                            ),
+                        ],
+                        keywords=[],
+                    ),
+                    body=[_kind_assignment(name, value)],
+                    orelse=[],
+                )
+                node.body.insert(index + 1, guarded)
+                self.assignment_count += 1
+                return
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        self._rewrite_assign_branch(node)
+        test_text = ast.unparse(node.test)
+        if (
+            "isinstance(node, ast.UnaryOp)" in test_text
+            and "ast.Not" in test_text
+            and node.body
+        ):
+            first = _is_self_call(node.body[0], "expr")
+            if first is not None and first.args:
+                node.body.insert(1, _emit_truth_statement(first.args[0]))
+                self.count += 1
+        if "isinstance(node, ast.Assert)" in test_text and node.body:
+            first = _is_self_call(node.body[0], "expr")
+            if first is not None and first.args:
+                node.body.insert(1, _emit_truth_statement(first.args[0]))
+                self.count += 1
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        node.body = self._rewrite_sequence(node.body)
+        for child in ast.walk(node):
+            if isinstance(child, (ast.For, ast.While, ast.If, ast.With, ast.Try)):
+                child.body = self._rewrite_sequence(child.body)
+                if isinstance(child, (ast.For, ast.While, ast.If, ast.Try)):
+                    child.orelse = self._rewrite_sequence(child.orelse)
+                if isinstance(child, ast.Try):
+                    child.finalbody = self._rewrite_sequence(child.finalbody)
+                    for handler in child.handlers:
+                        handler.body = self._rewrite_sequence(handler.body)
+        return node
+
+
+class _LowererConstructorHints(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+        self.in_lowerer = False
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        previous = self.in_lowerer
+        self.in_lowerer = node.name == "_Lowerer"
+        self.generic_visit(node)
+        self.in_lowerer = previous
+        return node
+
+    def _rewrite_body(self, body: list[ast.stmt]) -> list[ast.stmt]:
+        if not self.in_lowerer:
+            return body
+        result: list[ast.stmt] = []
+        for statement in body:
+            result.append(statement)
+            if not isinstance(statement, ast.Assign) or len(statement.targets) != 1:
+                continue
+            target = statement.targets[0]
+            value = statement.value
+            if (
+                not isinstance(target, ast.Name)
+                or not isinstance(value, ast.Call)
+                or not isinstance(value.func, ast.Name)
+                or value.func.id != "_Lowerer"
+            ):
+                continue
+            result.append(
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Attribute(
+                                value=ast.Name(id=target.id, ctx=ast.Load()),
+                                attr="kind_hints",
+                                ctx=ast.Load(),
+                            ),
+                            attr="update",
+                            ctx=ast.Load(),
+                        ),
+                        args=[
+                            ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr="kind_hints",
+                                ctx=ast.Load(),
+                            )
+                        ],
+                        keywords=[],
+                    )
+                )
+            )
+            self.count += 1
+        return result
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        node.body = self._rewrite_body(node.body)
+        return node
+
+
+def _normalize_bytecode() -> int:
+    module = ast.parse(BYTECODE_PATH.read_text(encoding="utf-8"))
+    op_class = next(
+        node for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "Op"
+    )
+    if any(
+        isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == "TO_BOOL" for target in node.targets)
+        for node in op_class.body
+    ):
+        raise RuntimeError("TO_BOOL opcode already exists")
+    op_class.body.append(
+        ast.Assign(
+            targets=[ast.Name(id="TO_BOOL", ctx=ast.Store())],
+            value=ast.Constant(115),
+        )
+    )
+    valid = next(
+        node for node in module.body
+        if isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == "_VALID_OPS" for target in node.targets)
+    )
+    if not isinstance(valid.value, ast.Tuple):
+        raise RuntimeError("_VALID_OPS is not a tuple")
+    valid.value.elts.append(
+        ast.Attribute(
+            value=ast.Name(id="Op", ctx=ast.Load()),
+            attr="TO_BOOL",
+            ctx=ast.Load(),
+        )
+    )
+    ast.fix_missing_locations(module)
+    BYTECODE_PATH.write_text(ast.unparse(module) + "\n", encoding="utf-8")
+    return 2
+
+
+def _normalize_frontend() -> tuple[int, int, int]:
+    module = ast.parse(FRONTEND_PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == "_TRUTH_UNKNOWN" for target in node.targets)
+        for node in module.body
+    ):
+        raise RuntimeError("frontend truth kinds already exist")
+    lowerer = next(
+        node for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "_Lowerer"
+    )
+    field_insert = next(
+        (index for index, node in enumerate(lowerer.body)
+         if isinstance(node, ast.FunctionDef)),
+        len(lowerer.body),
+    )
+    lowerer.body.insert(
+        field_insert,
+        ast.AnnAssign(
+            target=ast.Name(id="kind_hints", ctx=ast.Store()),
+            annotation=ast.Subscript(
+                value=ast.Name(id="dict", ctx=ast.Load()),
+                slice=ast.Tuple(
+                    elts=[
+                        ast.Name(id="str", ctx=ast.Load()),
+                        ast.Name(id="int", ctx=ast.Load()),
+                    ],
+                    ctx=ast.Load(),
+                ),
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="field", ctx=ast.Load()),
+                args=[],
+                keywords=[
+                    ast.keyword(
+                        arg="default_factory",
+                        value=ast.Name(id="dict", ctx=ast.Load()),
+                    )
+                ],
+            ),
+            simple=1,
+        ),
+    )
+    expr_index = next(
+        index for index, node in enumerate(lowerer.body)
+        if isinstance(node, ast.FunctionDef) and node.name == "expr"
+    )
+    lowerer.body[expr_index:expr_index] = _KIND_METHODS
+
+    constants_at = next(
+        index for index, node in enumerate(module.body)
+        if isinstance(node, ast.FunctionDef) and node.name == "_defer_annotation"
+    )
+    module.body[constants_at:constants_at] = _KIND_CONSTANTS
+
+    constructor_rewriter = _LowererConstructorHints()
+    module = constructor_rewriter.visit(module)
+    truth_rewriter = _TruthSiteRewriter()
+    module = truth_rewriter.visit(module)
+
+    compile_function = next(
+        node for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "compile_source"
+    )
+    compile_function.args.args.append(ast.arg(arg="kind_hints", annotation=None))
+    compile_function.args.defaults.append(ast.Constant(None))
+    lowerer_assign = next(
+        index for index, node in enumerate(compile_function.body)
+        if isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == "lowerer" for target in node.targets)
+    )
+    compile_function.body.insert(
+        lowerer_assign + 1,
+        ast.If(
+            test=ast.Compare(
+                left=ast.Name(id="kind_hints", ctx=ast.Load()),
+                ops=[ast.IsNot()],
+                comparators=[ast.Constant(None)],
+            ),
+            body=[
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Attribute(
+                                value=ast.Name(id="lowerer", ctx=ast.Load()),
+                                attr="kind_hints",
+                                ctx=ast.Load(),
+                            ),
+                            attr="update",
+                            ctx=ast.Load(),
+                        ),
+                        args=[ast.Name(id="kind_hints", ctx=ast.Load())],
+                        keywords=[],
+                    )
+                )
+            ],
+            orelse=[],
+        ),
+    )
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    if "Op.TO_BOOL" not in source:
+        raise RuntimeError("frontend did not emit TO_BOOL")
+    if "def expression_kind" not in source:
+        raise RuntimeError("frontend kind inference was not installed")
+    return truth_rewriter.count, truth_rewriter.assignment_count, constructor_rewriter.count
+
+
+class _VmOpcodeInsert(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        test = node.test
+        if not (
+            isinstance(test, ast.Compare)
+            and isinstance(test.left, ast.Name)
+            and test.left.id == "op"
+            and len(test.ops) == 1
+            and isinstance(test.ops[0], ast.Is)
+            and len(test.comparators) == 1
+            and isinstance(test.comparators[0], ast.Attribute)
+            and isinstance(test.comparators[0].value, ast.Name)
+            and test.comparators[0].value.id == "Op"
+            and test.comparators[0].attr == "TRY_BEGIN"
+        ):
+            return node
+        self.count += 1
+        return ast.copy_location(
+            ast.If(
+                test=ast.Compare(
+                    left=ast.Name(id="op", ctx=ast.Load()),
+                    ops=[ast.Is()],
+                    comparators=[
+                        ast.Attribute(
+                            value=ast.Name(id="Op", ctx=ast.Load()),
+                            attr="TO_BOOL",
+                            ctx=ast.Load(),
+                        )
+                    ],
+                ),
+                body=[
+                    ast.Assign(
+                        targets=[ast.Name(id="value", ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Attribute(
+                                    value=ast.Name(id="frame", ctx=ast.Load()),
+                                    attr="stack",
+                                    ctx=ast.Load(),
+                                ),
+                                attr="pop",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[],
+                        ),
+                    ),
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Attribute(
+                                    value=ast.Name(id="frame", ctx=ast.Load()),
+                                    attr="stack",
+                                    ctx=ast.Load(),
+                                ),
+                                attr="append",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                ast.Call(
+                                    func=ast.Name(id="_full_core_probe_truthy", ctx=ast.Load()),
+                                    args=[
+                                        ast.Name(id="value", ctx=ast.Load()),
+                                        ast.Attribute(
+                                            value=ast.Name(id="instr", ctx=ast.Load()),
+                                            attr="arg",
+                                            ctx=ast.Load(),
+                                        ),
+                                    ],
+                                    keywords=[],
+                                )
+                            ],
+                            keywords=[],
+                        )
+                    ),
+                ],
+                orelse=[node],
+            ),
+            node,
+        )
+
+
+def _normalize_vm() -> int:
+    module = ast.parse(VM_PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_full_core_probe_truthy"
+        for node in module.body
+    ):
+        raise RuntimeError("VM truth helper already exists")
+    insert_at = next(
+        index for index, node in enumerate(module.body)
+        if isinstance(node, ast.ClassDef) and node.name == "VirtualMachine"
+    )
+    module.body.insert(insert_at, _TRUTH_HELPER)
+    rewriter = _VmOpcodeInsert()
+    module = rewriter.visit(module)
+    if rewriter.count != 1:
+        raise RuntimeError(
+            f"TO_BOOL VM handler expected one insertion, found {rewriter.count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    VM_PATH.write_text(source, encoding="utf-8")
+    return rewriter.count
+
+
+class _EntryRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.compile_count = 0
+        self.kind_sync_count = 0
+        self.exec_order_count = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "exec_utf8":
+            for statement in node.body:
+                if not isinstance(statement, ast.Try):
+                    continue
+                for inner in statement.body:
+                    if not isinstance(inner, ast.Assign):
+                        continue
+                    if not isinstance(inner.value, ast.Call):
+                        continue
+                    call = inner.value
+                    if isinstance(call.func, ast.Name) and call.func.id == "compile_source":
+                        call.args = [
+                            ast.Name(id="source", ctx=ast.Load()),
+                            ast.Name(id="filename", ctx=ast.Load()),
+                            ast.Constant("exec"),
+                            ast.Call(
+                                func=ast.Name(id="getattr", ctx=ast.Load()),
+                                args=[
+                                    ast.Name(id="self", ctx=ast.Load()),
+                                    ast.Constant("_native_kind_hints"),
+                                    ast.Dict(keys=[], values=[]),
+                                ],
+                                keywords=[],
+                            ),
+                        ]
+                        call.keywords = []
+                        self.compile_count += 1
+        if node.name == "_native_set_global_kind":
+            node.body.extend(
+                ast.parse(
+                    """
+instance = _runtime(runtime)
+if instance is not None:
+    hints = getattr(instance, "_native_kind_hints", None)
+    if hints is None:
+        hints = {}
+        instance._native_kind_hints = hints
+    hints[name] = kind
+"""
+                ).body
+            )
+            self.kind_sync_count += 1
+        if node.name == "_portapy_exec_span_impl":
+            record_index = next(
+                (index for index, statement in enumerate(node.body)
+                 if isinstance(statement, ast.Expr)
+                 and isinstance(statement.value, ast.Call)
+                 and isinstance(statement.value.func, ast.Name)
+                 and statement.value.func.id == "_native_record_source_kinds"),
+                -1,
+            )
+            status_index = next(
+                (index for index, statement in enumerate(node.body)
+                 if isinstance(statement, ast.Assign)
+                 and isinstance(statement.value, ast.Call)
+                 and isinstance(statement.value.func, ast.Attribute)
+                 and statement.value.func.attr == "exec_utf8"),
+                -1,
+            )
+            if record_index < 0 or status_index < 0:
+                raise RuntimeError("native exec kind-recording shape changed")
+            record = node.body.pop(record_index)
+            if record_index < status_index:
+                status_index -= 1
+            node.body.insert(status_index, record)
+            self.exec_order_count += 1
+        return node
+
+
+def _normalize_entry() -> tuple[int, int, int]:
+    module = ast.parse(ENTRY_PATH.read_text(encoding="utf-8"))
+    rewriter = _EntryRewrite()
+    module = rewriter.visit(module)
+    expected = (1, 1, 1)
+    actual = (rewriter.compile_count, rewriter.kind_sync_count, rewriter.exec_order_count)
+    if actual != expected:
+        raise RuntimeError(
+            f"native truth-hint entry rewrite expected {expected}, found {actual}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    ENTRY_PATH.write_text(source, encoding="utf-8")
+    if "compile_source(source, filename, 'exec', getattr(self, '_native_kind_hints', {}))" not in source:
+        raise RuntimeError("Runtime compile_source kind hints were not installed")
+    return actual
+
+
+def main() -> int:
+    bytecode_count = _normalize_bytecode()
+    truth_count, assignment_count, constructor_count = _normalize_frontend()
+    vm_count = _normalize_vm()
+    compile_count, sync_count, order_count = _normalize_entry()
+    print(
+        "NORMALIZED NATIVE TRUTHINESS",
+        bytecode_count,
+        truth_count,
+        assignment_count,
+        constructor_count,
+        vm_count,
+        compile_count,
+        sync_count,
+        order_count,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 0d1fbd1135739297fdabb8264f53f48cbf344755 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:28:46 -0500
Subject: [PATCH 178/450] Run typed truthiness normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index cfe59284..20195e37 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,6 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
+from tools.normalize_full_core_truthiness import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )
@@ -139,6 +140,7 @@ def main() -> int:
     normalize_tracebacks()
     _normalize_nested_code_introspection()
     _normalize_opcode_validation()
+    normalize_truthiness()
     return 0
 
 

From fe2bc5c28aa859eec095ac2aff51f55f1e1c5daf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:33:11 -0500
Subject: [PATCH 179/450] Inject truth hints into reference runtime

---
 ...normalize_full_core_truthiness_complete.py | 178 ++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness_complete.py

diff --git a/tools/normalize_full_core_truthiness_complete.py b/tools/normalize_full_core_truthiness_complete.py
new file mode 100644
index 00000000..68c153ce
--- /dev/null
+++ b/tools/normalize_full_core_truthiness_complete.py
@@ -0,0 +1,178 @@
+"""Complete the typed-truthiness normalization across imported Runtime code."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_truthiness as base
+
+
+REFERENCE_PATH = Path("src/portapy/reference_api.py")
+ENTRY_PATH = Path("src/portapy/native_full_reference_entry.py")
+
+
+class _ReferenceRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name != "Runtime":
+            return node
+        method = next(
+            (
+                item
+                for item in node.body
+                if isinstance(item, ast.FunctionDef) and item.name == "exec_utf8"
+            ),
+            None,
+        )
+        if method is None:
+            raise RuntimeError("reference Runtime.exec_utf8 is missing")
+        for statement in ast.walk(method):
+            if not isinstance(statement, ast.Assign):
+                continue
+            call = statement.value
+            if not (
+                isinstance(call, ast.Call)
+                and isinstance(call.func, ast.Name)
+                and call.func.id == "compile_source"
+            ):
+                continue
+            call.args = [
+                ast.Name(id="source", ctx=ast.Load()),
+                ast.Name(id="filename", ctx=ast.Load()),
+                ast.Constant("exec"),
+                ast.Call(
+                    func=ast.Name(id="getattr", ctx=ast.Load()),
+                    args=[
+                        ast.Name(id="self", ctx=ast.Load()),
+                        ast.Constant("_native_kind_hints"),
+                        ast.Dict(keys=[], values=[]),
+                    ],
+                    keywords=[],
+                ),
+            ]
+            call.keywords = []
+            self.count += 1
+        return node
+
+
+def _normalize_reference() -> int:
+    module = ast.parse(REFERENCE_PATH.read_text(encoding="utf-8"))
+    rewriter = _ReferenceRewrite()
+    module = rewriter.visit(module)
+    if rewriter.count != 1:
+        raise RuntimeError(
+            f"reference Runtime truth hints expected 1 compile call, found {rewriter.count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    REFERENCE_PATH.write_text(source, encoding="utf-8")
+    expected = "compile_source(source, filename, 'exec', getattr(self, '_native_kind_hints', {}))"
+    if expected not in source:
+        raise RuntimeError("reference Runtime compile kind hints were not installed")
+    return rewriter.count
+
+
+class _EntryRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.kind_sync_count = 0
+        self.exec_order_count = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "_native_set_global_kind":
+            node.body.extend(
+                ast.parse(
+                    """
+instance = _runtime(runtime)
+if instance is not None:
+    hints = getattr(instance, "_native_kind_hints", None)
+    if hints is None:
+        hints = {}
+        instance._native_kind_hints = hints
+    hints[name] = kind
+"""
+                ).body
+            )
+            self.kind_sync_count += 1
+        if node.name == "_portapy_exec_span_impl":
+            record_index = next(
+                (
+                    index
+                    for index, statement in enumerate(node.body)
+                    if isinstance(statement, ast.Expr)
+                    and isinstance(statement.value, ast.Call)
+                    and isinstance(statement.value.func, ast.Name)
+                    and statement.value.func.id == "_native_record_source_kinds"
+                ),
+                -1,
+            )
+            status_index = next(
+                (
+                    index
+                    for index, statement in enumerate(node.body)
+                    if isinstance(statement, ast.Assign)
+                    and isinstance(statement.value, ast.Call)
+                    and isinstance(statement.value.func, ast.Attribute)
+                    and statement.value.func.attr == "exec_utf8"
+                ),
+                -1,
+            )
+            if record_index < 0 or status_index < 0:
+                raise RuntimeError("native exec kind-recording shape changed")
+            record = node.body.pop(record_index)
+            if record_index < status_index:
+                status_index -= 1
+            node.body.insert(status_index, record)
+            self.exec_order_count += 1
+        return node
+
+
+def _normalize_entry() -> tuple[int, int]:
+    module = ast.parse(ENTRY_PATH.read_text(encoding="utf-8"))
+    rewriter = _EntryRewrite()
+    module = rewriter.visit(module)
+    actual = (rewriter.kind_sync_count, rewriter.exec_order_count)
+    if actual != (1, 1):
+        raise RuntimeError(
+            f"native truth-hint entry rewrite expected (1, 1), found {actual}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    ENTRY_PATH.write_text(source, encoding="utf-8")
+    set_kind = source.find("def _native_set_global_kind")
+    runtime_sync = source.find("instance = _runtime(runtime)", set_kind)
+    if set_kind < 0 or runtime_sync < set_kind:
+        raise RuntimeError("native global kind hints were not synchronized")
+    exec_start = source.find("def _portapy_exec_span_impl")
+    record = source.find("_native_record_source_kinds(runtime, source_text)", exec_start)
+    execute = source.find("status = instance.exec_utf8(source_text)", exec_start)
+    if exec_start < 0 or record < exec_start or execute < exec_start or record > execute:
+        raise RuntimeError("native source kinds are not recorded before compilation")
+    return actual
+
+
+def main() -> int:
+    bytecode_count = base._normalize_bytecode()
+    truth_count, assignment_count, constructor_count = base._normalize_frontend()
+    vm_count = base._normalize_vm()
+    reference_count = _normalize_reference()
+    sync_count, order_count = _normalize_entry()
+    print(
+        "NORMALIZED NATIVE TRUTHINESS",
+        bytecode_count,
+        truth_count,
+        assignment_count,
+        constructor_count,
+        vm_count,
+        reference_count,
+        sync_count,
+        order_count,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 62e03963f5da83b7c23234824b0a8af79937c240 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:33:52 -0500
Subject: [PATCH 180/450] Use complete native truthiness pass

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 20195e37..c14ba402 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,7 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness import main as normalize_truthiness
+from tools.normalize_full_core_truthiness_complete import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From ba2f691ad21d6be053bf7856d59833580614cf4b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:40:54 -0500
Subject: [PATCH 181/450] Keep truthiness output compiler safe

---
 ...lize_full_core_truthiness_compiler_safe.py | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness_compiler_safe.py

diff --git a/tools/normalize_full_core_truthiness_compiler_safe.py b/tools/normalize_full_core_truthiness_compiler_safe.py
new file mode 100644
index 00000000..09c6fcb9
--- /dev/null
+++ b/tools/normalize_full_core_truthiness_compiler_safe.py
@@ -0,0 +1,37 @@
+"""Run typed truthiness normalization and repair compiler-sensitive spelling."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools.normalize_full_core_truthiness_complete import main as normalize_truthiness
+
+
+VM_PATH = Path("src/portapy/core/vm.py")
+
+
+def main() -> int:
+    normalize_truthiness()
+
+    source = VM_PATH.read_text(encoding="utf-8")
+    old = "                    frame.stack[-1], frame.stack[-2] = (frame.stack[-2], frame.stack[-1])"
+    new = (
+        "                    swap_value = frame.stack[-1]\n"
+        "                    frame.stack[-1] = frame.stack[-2]\n"
+        "                    frame.stack[-2] = swap_value"
+    )
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native compiler-safe SWAP normalization expected 1 match, found {count}"
+        )
+    source = source.replace(old, new, 1)
+    VM_PATH.write_text(source, encoding="utf-8")
+
+    if "frame.stack[-1], frame.stack[-2] =" in source:
+        raise RuntimeError("native subscript tuple assignment survived SWAP normalization")
+    print("NORMALIZED COMPILER-SAFE NATIVE SWAP", count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 3234278e4a2ead98819bb8d53fc727b0ffb1bca6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:41:28 -0500
Subject: [PATCH 182/450] Use compiler-safe truthiness normalization

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index c14ba402..1afcf802 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,7 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness_complete import main as normalize_truthiness
+from tools.normalize_full_core_truthiness_compiler_safe import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From 10ffc92a56fc49b223dcb2a0771cdf563e1d7853 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:52:02 -0500
Subject: [PATCH 183/450] Transport truth hints through source directives

---
 ...rmalize_full_core_truthiness_directives.py | 316 ++++++++++++++++++
 1 file changed, 316 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness_directives.py

diff --git a/tools/normalize_full_core_truthiness_directives.py b/tools/normalize_full_core_truthiness_directives.py
new file mode 100644
index 00000000..64a97eb0
--- /dev/null
+++ b/tools/normalize_full_core_truthiness_directives.py
@@ -0,0 +1,316 @@
+"""Use compiler-only source directives to transport cross-call truth kinds.
+
+Passing the hint dictionary as an additional native function argument crosses a
+still-opaque container calling boundary.  Instead, the ABI prepends reserved
+assignments which the frontend consumes as compile-time metadata and never emits
+as runtime bytecode.  This keeps the typed ``TO_BOOL`` implementation while
+avoiding native object transport entirely.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools.normalize_full_core_truthiness_compiler_safe import (
+    main as normalize_truthiness,
+)
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+REFERENCE_PATH = Path("src/portapy/reference_api.py")
+ENTRY_PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_DIRECTIVE_PREFIX = "__portapy_internal_kind_"
+_EVAL_MARKER = "# __portapy_eval_expression__\n"
+
+
+def _directive_guard() -> ast.If:
+    return ast.parse(
+        f'''if (
+    isinstance(statement, ast.Assign)
+    and len(statement.targets) == 1
+    and isinstance(statement.targets[0], ast.Name)
+    and statement.targets[0].id.startswith("{_DIRECTIVE_PREFIX}")
+    and isinstance(statement.value, ast.Constant)
+):
+    hint_name = statement.targets[0].id[len("{_DIRECTIVE_PREFIX}"):]
+    lowerer.kind_hints[hint_name] = statement.value.value
+    continue
+'''
+    ).body[0]
+
+
+def _normalize_frontend() -> int:
+    module = ast.parse(FRONTEND_PATH.read_text(encoding="utf-8"))
+    function = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "compile_source"
+    )
+
+    if not function.args.args or function.args.args[-1].arg != "kind_hints":
+        raise RuntimeError("compile_source native hint argument is missing")
+    function.args.args.pop()
+    if not function.args.defaults:
+        raise RuntimeError("compile_source native hint default is missing")
+    function.args.defaults.pop()
+
+    removed = 0
+    new_body: list[ast.stmt] = []
+    for statement in function.body:
+        if (
+            isinstance(statement, ast.If)
+            and isinstance(statement.test, ast.Compare)
+            and isinstance(statement.test.left, ast.Name)
+            and statement.test.left.id == "kind_hints"
+        ):
+            removed += 1
+            continue
+        new_body.append(statement)
+    function.body = new_body
+    if removed != 1:
+        raise RuntimeError(
+            f"compile_source hint dictionary bootstrap expected 1 block, found {removed}"
+        )
+
+    loops = [
+        node
+        for node in ast.walk(function)
+        if isinstance(node, ast.For)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "statement"
+        and isinstance(node.iter, ast.Attribute)
+        and isinstance(node.iter.value, ast.Name)
+        and node.iter.value.id == "module"
+        and node.iter.attr == "body"
+    ]
+    if len(loops) != 1:
+        raise RuntimeError(
+            f"compile_source statement loop expected 1 match, found {len(loops)}"
+        )
+    loops[0].body.insert(0, _directive_guard())
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    if "kind_hints=None" in source:
+        raise RuntimeError("compile_source still accepts a native hint dictionary")
+    if _DIRECTIVE_PREFIX not in source:
+        raise RuntimeError("compile-time kind directives were not installed")
+    return 1
+
+
+class _ReferenceRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.compile_count = 0
+        self.eval_count = 0
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name != "Runtime":
+            return node
+
+        exec_method = next(
+            item
+            for item in node.body
+            if isinstance(item, ast.FunctionDef) and item.name == "exec_utf8"
+        )
+        for statement in ast.walk(exec_method):
+            if not isinstance(statement, ast.Assign):
+                continue
+            call = statement.value
+            if (
+                isinstance(call, ast.Call)
+                and isinstance(call.func, ast.Name)
+                and call.func.id == "compile_source"
+            ):
+                call.args = [
+                    ast.Name(id="source", ctx=ast.Load()),
+                    ast.Name(id="filename", ctx=ast.Load()),
+                ]
+                call.keywords = []
+                self.compile_count += 1
+
+        eval_method = next(
+            item
+            for item in node.body
+            if isinstance(item, ast.FunctionDef) and item.name == "eval_utf8"
+        )
+        insert_at = next(
+            index
+            for index, statement in enumerate(eval_method.body)
+            if isinstance(statement, ast.AugAssign)
+            and isinstance(statement.target, ast.Attribute)
+            and statement.target.attr == "_eval_counter"
+        )
+        setup = ast.parse(
+            f'''prefix = ""
+marker = {_EVAL_MARKER!r}
+marker_at = expression.find(marker)
+if marker_at >= 0:
+    prefix = expression[0:marker_at]
+    expression = expression[marker_at + len(marker):]
+'''
+        ).body
+        eval_method.body[insert_at:insert_at] = setup
+
+        for statement in ast.walk(eval_method):
+            if not isinstance(statement, ast.Assign):
+                continue
+            call = statement.value
+            if not (
+                isinstance(call, ast.Call)
+                and isinstance(call.func, ast.Attribute)
+                and isinstance(call.func.value, ast.Name)
+                and call.func.value.id == "self"
+                and call.func.attr == "exec_utf8"
+                and call.args
+            ):
+                continue
+            call.args[0] = ast.BinOp(
+                left=ast.Name(id="prefix", ctx=ast.Load()),
+                op=ast.Add(),
+                right=call.args[0],
+            )
+            self.eval_count += 1
+        return node
+
+
+def _normalize_reference() -> tuple[int, int]:
+    module = ast.parse(REFERENCE_PATH.read_text(encoding="utf-8"))
+    rewriter = _ReferenceRewrite()
+    module = rewriter.visit(module)
+    actual = (rewriter.compile_count, rewriter.eval_count)
+    if actual != (1, 1):
+        raise RuntimeError(
+            f"reference truth directive rewrite expected (1, 1), found {actual}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    REFERENCE_PATH.write_text(source, encoding="utf-8")
+    if "getattr(self, '_native_kind_hints'" in source:
+        raise RuntimeError("reference Runtime still transports a native hint dictionary")
+    if _EVAL_MARKER.strip() not in source:
+        raise RuntimeError("reference eval directive marker was not installed")
+    return actual
+
+
+_HELPER = ast.parse(
+    f'''def _native_source_with_kind_hints(runtime: int, source: str) -> str:
+    result = ""
+    wanted = str(runtime) + ":"
+    for key, kind in _native_global_kinds.items():
+        if key.startswith(wanted):
+            name = key[len(wanted):]
+            if _native_is_identifier(name):
+                result += "{_DIRECTIVE_PREFIX}" + name + " = " + str(kind) + "\\n"
+    return result + {_EVAL_MARKER!r} + source
+'''
+).body[0]
+
+
+class _EntryRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.kind_reset = 0
+        self.exec_count = 0
+        self.eval_count = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name == "_native_set_global_kind":
+            if len(node.body) < 2:
+                raise RuntimeError("native global-kind dictionary transport is missing")
+            node.body = node.body[:1]
+            self.kind_reset += 1
+            return node
+
+        if node.name not in {"_portapy_exec_span_impl", "_portapy_eval_span_impl"}:
+            return node
+        call_name = "exec_utf8" if node.name == "_portapy_exec_span_impl" else "eval_utf8"
+        status_index = -1
+        for index, statement in enumerate(node.body):
+            if not isinstance(statement, ast.Assign):
+                continue
+            call = statement.value
+            if (
+                isinstance(call, ast.Call)
+                and isinstance(call.func, ast.Attribute)
+                and call.func.attr == call_name
+                and call.args
+            ):
+                status_index = index
+                call.args[0] = ast.Name(id="compiled_source", ctx=ast.Load())
+                break
+        if status_index < 0:
+            raise RuntimeError(f"native {call_name} source call was not found")
+        node.body.insert(
+            status_index,
+            ast.Assign(
+                targets=[ast.Name(id="compiled_source", ctx=ast.Store())],
+                value=ast.Call(
+                    func=ast.Name(id="_native_source_with_kind_hints", ctx=ast.Load()),
+                    args=[
+                        ast.Name(id="runtime", ctx=ast.Load()),
+                        ast.Name(id="source_text", ctx=ast.Load()),
+                    ],
+                    keywords=[],
+                ),
+            ),
+        )
+        if call_name == "exec_utf8":
+            self.exec_count += 1
+        else:
+            self.eval_count += 1
+        return node
+
+
+def _normalize_entry() -> tuple[int, int, int]:
+    module = ast.parse(ENTRY_PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef)
+        and node.name == "_native_source_with_kind_hints"
+        for node in module.body
+    ):
+        raise RuntimeError("native source kind directive helper already exists")
+    rewriter = _EntryRewrite()
+    module = rewriter.visit(module)
+    actual = (rewriter.kind_reset, rewriter.exec_count, rewriter.eval_count)
+    if actual != (1, 1, 1):
+        raise RuntimeError(
+            f"native truth directive entry rewrite expected (1, 1, 1), found {actual}"
+        )
+    insert_at = next(
+        index
+        for index, node in enumerate(module.body)
+        if isinstance(node, ast.FunctionDef) and node.name == "_native_expression_kind"
+    )
+    module.body.insert(insert_at, _HELPER)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    ENTRY_PATH.write_text(source, encoding="utf-8")
+    if "_native_kind_hints" in source:
+        raise RuntimeError("native Runtime attribute hint transport survived")
+    if source.count("_native_source_with_kind_hints(runtime, source_text)") != 2:
+        raise RuntimeError("native source directives were not applied to exec and eval")
+    return actual
+
+
+def main() -> int:
+    normalize_truthiness()
+    frontend_count = _normalize_frontend()
+    compile_count, reference_eval_count = _normalize_reference()
+    reset_count, entry_exec_count, entry_eval_count = _normalize_entry()
+    print(
+        "NORMALIZED NATIVE TRUTH DIRECTIVES",
+        frontend_count,
+        compile_count,
+        reference_eval_count,
+        reset_count,
+        entry_exec_count,
+        entry_eval_count,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 6b9a24ce0ec0fd3ae90b8dbdc41408e84ace8c7f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 22:52:42 -0500
Subject: [PATCH 184/450] Use source directive truth hints

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 1afcf802..160fd6cf 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,7 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness_compiler_safe import main as normalize_truthiness
+from tools.normalize_full_core_truthiness_directives import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From d470de970a9d8d49b11703841f178dc89fdc4eab Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:00:43 -0500
Subject: [PATCH 185/450] Use list-backed native truth hints

---
 tools/normalize_full_core_truthiness_lists.py | 97 +++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness_lists.py

diff --git a/tools/normalize_full_core_truthiness_lists.py b/tools/normalize_full_core_truthiness_lists.py
new file mode 100644
index 00000000..ccbc4dc3
--- /dev/null
+++ b/tools/normalize_full_core_truthiness_lists.py
@@ -0,0 +1,97 @@
+"""Replace the frontend's native dict hint ledger with parallel lists."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools.normalize_full_core_truthiness_directives import (
+    main as normalize_truthiness,
+)
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+
+
+def _replace(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native list-backed truth hints {label}: expected 1 match, found {count}"
+        )
+    return source.replace(old, new, 1)
+
+
+def main() -> int:
+    normalize_truthiness()
+
+    source = FRONTEND_PATH.read_text(encoding="utf-8")
+    source = _replace(
+        source,
+        "    kind_hints: dict[str, int] = field(default_factory=dict)\n",
+        "    kind_hint_names: list[str] = field(default_factory=list)\n"
+        "    kind_hint_values: list[int] = field(default_factory=list)\n",
+        "fields",
+    )
+    anchor = "    def expression_kind(self, node: ast.expr) -> int:\n"
+    methods = '''    def kind_hint(self, name: str) -> int:
+        index = 0
+        while index < len(self.kind_hint_names):
+            if self.kind_hint_names[index] == name:
+                return self.kind_hint_values[index]
+            index += 1
+        return _TRUTH_UNKNOWN
+
+    def set_kind_hint(self, name: str, kind: int) -> None:
+        index = 0
+        while index < len(self.kind_hint_names):
+            if self.kind_hint_names[index] == name:
+                self.kind_hint_values[index] = kind
+                return
+            index += 1
+        self.kind_hint_names.append(name)
+        self.kind_hint_values.append(kind)
+
+    def copy_kind_hints(self, other: object) -> None:
+        index = 0
+        while index < len(other.kind_hint_names):
+            self.set_kind_hint(
+                other.kind_hint_names[index],
+                other.kind_hint_values[index],
+            )
+            index += 1
+
+'''
+    source = _replace(source, anchor, methods + anchor, "method insertion")
+    source = _replace(
+        source,
+        "            return self.kind_hints.get(node.id, _TRUTH_UNKNOWN)",
+        "            return self.kind_hint(node.id)",
+        "name lookup",
+    )
+    source = _replace(
+        source,
+        "        nested.kind_hints.update(self.kind_hints)",
+        "        nested.copy_kind_hints(self)",
+        "nested copy",
+    )
+    source = _replace(
+        source,
+        "                self.kind_hints[node.targets[0].id] = self.expression_kind(node.value)",
+        "                self.set_kind_hint(node.targets[0].id, self.expression_kind(node.value))",
+        "assignment recording",
+    )
+    source = _replace(
+        source,
+        "            lowerer.kind_hints[hint_name] = statement.value.value",
+        "            lowerer.set_kind_hint(hint_name, statement.value.value)",
+        "directive recording",
+    )
+
+    if "kind_hints" in source:
+        raise RuntimeError("native dict truth-hint ledger survived list normalization")
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    print("NORMALIZED LIST-BACKED NATIVE TRUTH HINTS", 5)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 6bb9d5abfa0e3cfa705651afa28e87b51b23301d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:01:18 -0500
Subject: [PATCH 186/450] Use list-backed truth hint normalization

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 160fd6cf..fdcb8a96 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,7 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness_directives import main as normalize_truthiness
+from tools.normalize_full_core_truthiness_lists import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From 414dd8409e9a8656fb8245d0141b58cf589bc445 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:04:08 -0500
Subject: [PATCH 187/450] Validate list-backed hints precisely

---
 tools/normalize_full_core_truthiness_lists.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_truthiness_lists.py b/tools/normalize_full_core_truthiness_lists.py
index ccbc4dc3..511ac32f 100644
--- a/tools/normalize_full_core_truthiness_lists.py
+++ b/tools/normalize_full_core_truthiness_lists.py
@@ -86,8 +86,18 @@ def copy_kind_hints(self, other: object) -> None:
         "directive recording",
     )
 
-    if "kind_hints" in source:
-        raise RuntimeError("native dict truth-hint ledger survived list normalization")
+    forbidden = (
+        "kind_hints: dict",
+        "self.kind_hints",
+        "lowerer.kind_hints",
+        "nested.kind_hints",
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
+        raise RuntimeError(
+            "native dict truth-hint ledger survived list normalization: "
+            + ", ".join(remaining)
+        )
     FRONTEND_PATH.write_text(source, encoding="utf-8")
     print("NORMALIZED LIST-BACKED NATIVE TRUTH HINTS", 5)
     return 0

From d8d4a27b127b586393e5fab279098480fa9aa051 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:12:53 -0500
Subject: [PATCH 188/450] Make native truth inference AST safe

---
 ...normalize_full_core_truthiness_safe_ast.py | 159 ++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 tools/normalize_full_core_truthiness_safe_ast.py

diff --git a/tools/normalize_full_core_truthiness_safe_ast.py b/tools/normalize_full_core_truthiness_safe_ast.py
new file mode 100644
index 00000000..8516d7de
--- /dev/null
+++ b/tools/normalize_full_core_truthiness_safe_ast.py
@@ -0,0 +1,159 @@
+"""Finish typed truthiness without opaque AST-field dereferences."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools.normalize_full_core_truthiness_lists import main as normalize_truthiness
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+
+_SAFE_KIND_METHOD = '''    def expression_kind(self, node: ast.expr) -> int:
+        if isinstance(node, ast.Name):
+            name: str = getattr(node, "id")
+            return self.kind_hint(name)
+        if isinstance(node, ast.Compare):
+            return _TRUTH_BOOL
+        if isinstance(node, ast.UnaryOp):
+            operator = getattr(node, "op")
+            if isinstance(operator, ast.Not):
+                return _TRUTH_BOOL
+        if isinstance(node, ast.JoinedStr):
+            return _TRUTH_STRING
+        if isinstance(node, (ast.List, ast.Tuple, ast.Dict, ast.Set)):
+            return _TRUTH_CONTAINER
+        if isinstance(node, ast.Constant):
+            value: object = getattr(node, "value")
+            if value is None:
+                return _TRUTH_NONE
+            if value is True or value is False:
+                return _TRUTH_BOOL
+            if isinstance(value, str):
+                return _TRUTH_STRING
+            if isinstance(value, bytes):
+                return _TRUTH_BYTES
+            if isinstance(value, float):
+                return _TRUTH_FLOAT
+            if isinstance(value, int):
+                return _TRUTH_INT
+        return _TRUTH_UNKNOWN
+
+'''
+
+
+def _replace(source: str, old: str, new: str, label: str, expected: int = 1) -> str:
+    count = source.count(old)
+    if count != expected:
+        raise RuntimeError(
+            f"native AST-safe truthiness {label}: expected {expected}, found {count}"
+        )
+    return source.replace(old, new)
+
+
+def main() -> int:
+    normalize_truthiness()
+    source = FRONTEND_PATH.read_text(encoding="utf-8")
+
+    start = source.find("    def expression_kind(self, node: ast.expr) -> int:\n")
+    end = source.find("    def emit_truth(self, node: ast.expr) -> None:\n", start)
+    if start < 0 or end < 0:
+        raise RuntimeError("native expression-kind method boundary was not found")
+    source = source[:start] + _SAFE_KIND_METHOD + source[end:]
+
+    source = _replace(
+        source,
+        "                self.set_kind_hint(node.targets[0].id, self.expression_kind(node.value))\n",
+        "",
+        "assignment walker removal",
+    )
+    source = _replace(
+        source,
+        "            self.emit_truth(node.operand)\n",
+        "            self.emit_truth(getattr(node, \"operand\"))\n",
+        "unary operand",
+    )
+    source = _replace(
+        source,
+        "            self.emit_truth(node.test)\n",
+        "            self.emit_truth(getattr(node, \"test\"))\n",
+        "assert test",
+    )
+
+    source = _replace(
+        source,
+        "                self.emit(Op.DUP_TOP)\n"
+        "                exits.append(self.emit(Op.JUMP_IF_FALSE_KEEP if isinstance(node.op, ast.And) else Op.JUMP_IF_TRUE_KEEP))",
+        "                self.emit(Op.DUP_TOP)\n"
+        "                self.emit_truth(value)\n"
+        "                exits.append(self.emit(Op.JUMP_IF_FALSE_KEEP if isinstance(node.op, ast.And) else Op.JUMP_IF_TRUE_KEEP))",
+        "boolean operands",
+    )
+    source = _replace(
+        source,
+        "        elif isinstance(node, ast.IfExp):\n"
+        "            self.expr(node.test)\n"
+        "            otherwise = self.emit(Op.JUMP_IF_FALSE)",
+        "        elif isinstance(node, ast.IfExp):\n"
+        "            self.expr(node.test)\n"
+        "            self.emit_truth(getattr(node, \"test\"))\n"
+        "            otherwise = self.emit(Op.JUMP_IF_FALSE)",
+        "conditional expression",
+    )
+    source = _replace(
+        source,
+        "        elif isinstance(node, ast.If):\n"
+        "            self.expr(node.test)\n"
+        "            otherwise = self.emit(Op.JUMP_IF_FALSE)",
+        "        elif isinstance(node, ast.If):\n"
+        "            self.expr(node.test)\n"
+        "            self.emit_truth(getattr(node, \"test\"))\n"
+        "            otherwise = self.emit(Op.JUMP_IF_FALSE)",
+        "if statement",
+    )
+    source = _replace(
+        source,
+        "        elif isinstance(node, ast.While):\n"
+        "            start = len(self.instructions)\n"
+        "            self.expr(node.test)\n"
+        "            exit_jump = self.emit(Op.JUMP_IF_FALSE)",
+        "        elif isinstance(node, ast.While):\n"
+        "            start = len(self.instructions)\n"
+        "            self.expr(node.test)\n"
+        "            self.emit_truth(getattr(node, \"test\"))\n"
+        "            exit_jump = self.emit(Op.JUMP_IF_FALSE)",
+        "while statement",
+    )
+    source = _replace(
+        source,
+        "                if case.guard is not None:\n"
+        "                    self.expr(case.guard)\n"
+        "                    guard_jump = self.emit(Op.JUMP_IF_FALSE)",
+        "                if case.guard is not None:\n"
+        "                    self.expr(case.guard)\n"
+        "                    self.emit_truth(getattr(case, \"guard\"))\n"
+        "                    guard_jump = self.emit(Op.JUMP_IF_FALSE)",
+        "match guard",
+    )
+
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    forbidden = (
+        "self.expression_kind(node.value)",
+        "self.expression_kind(node.left)",
+        "self.expression_kind(node.right)",
+        "self.expression_kind(node.body)",
+        "self.expression_kind(node.orelse)",
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
+        raise RuntimeError(
+            "unsafe recursive AST kind inference survived: " + ", ".join(remaining)
+        )
+    if source.count("self.emit_truth(") < 7:
+        raise RuntimeError("native truth conversion was not installed at all branch sites")
+    print("NORMALIZED AST-SAFE NATIVE TRUTHINESS", source.count("self.emit_truth("))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 8d7e2354a6c4d533ed5ca628f827a59567e0e053 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:13:26 -0500
Subject: [PATCH 189/450] Use AST-safe truth normalization

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index fdcb8a96..178acb85 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -27,7 +27,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness_lists import main as normalize_truthiness
+from tools.normalize_full_core_truthiness_safe_ast import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From d84eac11caa8cbc4f716da762a17a8556bb0e065 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:22:29 -0500
Subject: [PATCH 190/450] Use value semantics for native strings

---
 .../normalize_full_core_string_comparisons.py | 128 ++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 tools/normalize_full_core_string_comparisons.py

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
new file mode 100644
index 00000000..e726b466
--- /dev/null
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -0,0 +1,128 @@
+"""Give native VM string comparisons Python value semantics."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools.normalize_full_core_truthiness_safe_ast import main as normalize_truthiness
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+VM_PATH = Path("src/portapy/core/vm.py")
+
+_HELPER = '''def _full_core_probe_compare_strings(left: str, right: str, operation: int) -> bool:
+    if operation == 20:
+        return left == right
+    if operation == 21:
+        return left < right
+    if operation == 22:
+        return left <= right
+    if operation == 23:
+        return left > right
+    if operation == 24:
+        return left >= right
+    return left != right
+
+
+'''
+
+
+def _replace(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native string comparison {label}: expected 1 match, found {count}"
+        )
+    return source.replace(old, new, 1)
+
+
+def _normalize_frontend() -> int:
+    source = FRONTEND_PATH.read_text(encoding="utf-8")
+    old = '''            operands = [node.left, *node.comparators]
+            for index, op in enumerate(node.ops):
+                self.expr(operands[index])
+                self.expr(operands[index + 1])
+                self.emit(_compare_opcode(op))
+                if index:
+                    self.emit(Op.BINARY_BOOL_AND)
+'''
+    new = '''            operands = [node.left, *node.comparators]
+            for index, op in enumerate(node.ops):
+                left_operand = operands[index]
+                right_operand = operands[index + 1]
+                self.expr(left_operand)
+                self.expr(right_operand)
+                comparison_kind = _TRUTH_UNKNOWN
+                if (
+                    self.expression_kind(left_operand) == _TRUTH_STRING
+                    and self.expression_kind(right_operand) == _TRUTH_STRING
+                ):
+                    comparison_kind = _TRUTH_STRING
+                self.emit(_compare_opcode(op), comparison_kind)
+                if index:
+                    self.emit(Op.BINARY_BOOL_AND)
+'''
+    source = _replace(source, old, new, "frontend lowering")
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    if "self.emit(_compare_opcode(op), comparison_kind)" not in source:
+        raise RuntimeError("native string comparison kind was not emitted")
+    return 1
+
+
+def _normalize_vm() -> int:
+    source = VM_PATH.read_text(encoding="utf-8")
+    class_anchor = "class VirtualMachine:"
+    source = _replace(source, class_anchor, _HELPER + class_anchor, "helper insertion")
+    old = '''                    if op is Op.COMPARE_EQ:
+                        frame.stack.append(left == right)
+                    elif op is Op.COMPARE_LT:
+                        frame.stack.append(left < right)
+                    elif op is Op.COMPARE_LE:
+                        frame.stack.append(left <= right)
+                    elif op is Op.COMPARE_GT:
+                        frame.stack.append(left > right)
+                    elif op is Op.COMPARE_GE:
+                        frame.stack.append(left >= right)
+                    elif op is Op.COMPARE_NE:
+                        frame.stack.append(left != right)
+'''
+    new = '''                    if instr.arg == 4 and op in (
+                        Op.COMPARE_EQ,
+                        Op.COMPARE_LT,
+                        Op.COMPARE_LE,
+                        Op.COMPARE_GT,
+                        Op.COMPARE_GE,
+                        Op.COMPARE_NE,
+                    ):
+                        frame.stack.append(
+                            _full_core_probe_compare_strings(left, right, op)
+                        )
+                    elif op is Op.COMPARE_EQ:
+                        frame.stack.append(left == right)
+                    elif op is Op.COMPARE_LT:
+                        frame.stack.append(left < right)
+                    elif op is Op.COMPARE_LE:
+                        frame.stack.append(left <= right)
+                    elif op is Op.COMPARE_GT:
+                        frame.stack.append(left > right)
+                    elif op is Op.COMPARE_GE:
+                        frame.stack.append(left >= right)
+                    elif op is Op.COMPARE_NE:
+                        frame.stack.append(left != right)
+'''
+    source = _replace(source, old, new, "VM dispatch")
+    VM_PATH.write_text(source, encoding="utf-8")
+    if source.count("_full_core_probe_compare_strings") != 2:
+        raise RuntimeError("native string comparison helper validation failed")
+    return 1
+
+
+def main() -> int:
+    normalize_truthiness()
+    frontend_count = _normalize_frontend()
+    vm_count = _normalize_vm()
+    print("NORMALIZED NATIVE STRING COMPARISONS", frontend_count, vm_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 900761b3e714ffe617879225692b33ecf46a1d25 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:22:56 -0500
Subject: [PATCH 191/450] Run native string comparison normalization

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 178acb85..f9f32c30 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -26,8 +26,8 @@
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
+from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_core_truthiness_safe_ast import main as normalize_truthiness
 from tools.normalize_full_reference_abi_helpers import (
     main as normalize_reference_abi_helpers,
 )

From 4d748b6ac53ba855a70ac721614cedd3d452f5b6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:25:16 -0500
Subject: [PATCH 192/450] Match normalized comparison lowering

---
 tools/normalize_full_core_string_comparisons.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
index e726b466..1bcbea1c 100644
--- a/tools/normalize_full_core_string_comparisons.py
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -37,7 +37,9 @@ def _replace(source: str, old: str, new: str, label: str) -> str:
 
 def _normalize_frontend() -> int:
     source = FRONTEND_PATH.read_text(encoding="utf-8")
-    old = '''            operands = [node.left, *node.comparators]
+    old = '''            operands = [node.left]
+            for comparator in node.comparators:
+                operands.append(comparator)
             for index, op in enumerate(node.ops):
                 self.expr(operands[index])
                 self.expr(operands[index + 1])
@@ -45,7 +47,9 @@ def _normalize_frontend() -> int:
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
 '''
-    new = '''            operands = [node.left, *node.comparators]
+    new = '''            operands = [node.left]
+            for comparator in node.comparators:
+                operands.append(comparator)
             for index, op in enumerate(node.ops):
                 left_operand = operands[index]
                 right_operand = operands[index + 1]

From 82128042f400a5dec52ca4947681376ff2c86dd9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:31:17 -0500
Subject: [PATCH 193/450] Inline native string operand classification

---
 .../normalize_full_core_string_comparisons.py | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
index 1bcbea1c..e626c1e5 100644
--- a/tools/normalize_full_core_string_comparisons.py
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -55,12 +55,25 @@ def _normalize_frontend() -> int:
                 right_operand = operands[index + 1]
                 self.expr(left_operand)
                 self.expr(right_operand)
-                comparison_kind = _TRUTH_UNKNOWN
-                if (
-                    self.expression_kind(left_operand) == _TRUTH_STRING
-                    and self.expression_kind(right_operand) == _TRUTH_STRING
-                ):
-                    comparison_kind = _TRUTH_STRING
+                left_is_string = False
+                if isinstance(left_operand, ast.Name):
+                    left_name: str = getattr(left_operand, "id")
+                    left_is_string = self.kind_hint(left_name) == _TRUTH_STRING
+                elif isinstance(left_operand, ast.Constant):
+                    left_value: object = getattr(left_operand, "value")
+                    left_is_string = isinstance(left_value, str)
+                elif isinstance(left_operand, ast.JoinedStr):
+                    left_is_string = True
+                right_is_string = False
+                if isinstance(right_operand, ast.Name):
+                    right_name: str = getattr(right_operand, "id")
+                    right_is_string = self.kind_hint(right_name) == _TRUTH_STRING
+                elif isinstance(right_operand, ast.Constant):
+                    right_value: object = getattr(right_operand, "value")
+                    right_is_string = isinstance(right_value, str)
+                elif isinstance(right_operand, ast.JoinedStr):
+                    right_is_string = True
+                comparison_kind = _TRUTH_STRING if left_is_string and right_is_string else _TRUTH_UNKNOWN
                 self.emit(_compare_opcode(op), comparison_kind)
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
@@ -69,6 +82,8 @@ def _normalize_frontend() -> int:
     FRONTEND_PATH.write_text(source, encoding="utf-8")
     if "self.emit(_compare_opcode(op), comparison_kind)" not in source:
         raise RuntimeError("native string comparison kind was not emitted")
+    if "self.expression_kind(left_operand)" in source or "self.expression_kind(right_operand)" in source:
+        raise RuntimeError("native comparison still crosses the opaque AST classifier boundary")
     return 1
 
 

From 5915212470b4bcb6339a5f6974ba52beed3d2f1b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:38:37 -0500
Subject: [PATCH 194/450] Preserve typed comparison operands

---
 tools/normalize_full_core_string_comparisons.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
index e626c1e5..90090739 100644
--- a/tools/normalize_full_core_string_comparisons.py
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -47,12 +47,11 @@ def _normalize_frontend() -> int:
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
 '''
-    new = '''            operands = [node.left]
-            for comparator in node.comparators:
-                operands.append(comparator)
-            for index, op in enumerate(node.ops):
-                left_operand = operands[index]
-                right_operand = operands[index + 1]
+    new = '''            left_operand: ast.expr = getattr(node, "left")
+            index = 0
+            while index < len(node.ops):
+                op = node.ops[index]
+                right_operand: ast.expr = node.comparators[index]
                 self.expr(left_operand)
                 self.expr(right_operand)
                 left_is_string = False
@@ -77,11 +76,15 @@ def _normalize_frontend() -> int:
                 self.emit(_compare_opcode(op), comparison_kind)
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
+                left_operand = right_operand
+                index += 1
 '''
     source = _replace(source, old, new, "frontend lowering")
     FRONTEND_PATH.write_text(source, encoding="utf-8")
     if "self.emit(_compare_opcode(op), comparison_kind)" not in source:
         raise RuntimeError("native string comparison kind was not emitted")
+    if "operands = [node.left]" in source:
+        raise RuntimeError("native comparison still erases AST operand types in a list")
     if "self.expression_kind(left_operand)" in source or "self.expression_kind(right_operand)" in source:
         raise RuntimeError("native comparison still crosses the opaque AST classifier boundary")
     return 1

From 084f1b6e480173f296fc3dec235e6f4dd727a293 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:44:44 -0500
Subject: [PATCH 195/450] Stamp native AST comparison metadata

---
 .../normalize_full_core_string_comparisons.py | 137 +++++++++++++++---
 1 file changed, 118 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
index 90090739..764be1fe 100644
--- a/tools/normalize_full_core_string_comparisons.py
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -1,12 +1,14 @@
 """Give native VM string comparisons Python value semantics."""
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 from tools.normalize_full_core_truthiness_safe_ast import main as normalize_truthiness
 
 
 FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+NATIVE_AST_PATH = Path("src/portapy/core/native_ast.py")
 VM_PATH = Path("src/portapy/core/vm.py")
 
 _HELPER = '''def _full_core_probe_compare_strings(left: str, right: str, operation: int) -> bool:
@@ -35,6 +37,105 @@ def _replace(source: str, old: str, new: str, label: str) -> str:
     return source.replace(old, new, 1)
 
 
+def _is_source_node_test(node: ast.If, suffix: str) -> bool:
+    test = node.test
+    if not (
+        isinstance(test, ast.Call)
+        and isinstance(test.func, ast.Name)
+        and test.func.id == "isinstance"
+        and len(test.args) == 2
+        and isinstance(test.args[0], ast.Name)
+        and test.args[0].id == "node"
+    ):
+        return False
+    expected = test.args[1]
+    if isinstance(expected, ast.Name):
+        return expected.id.endswith(suffix)
+    if isinstance(expected, ast.Attribute):
+        return expected.attr == suffix
+    return False
+
+
+def _normalize_native_ast_metadata() -> int:
+    module = ast.parse(NATIVE_AST_PATH.read_text(encoding="utf-8"))
+    converter = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef) and node.name == "_convert_expr"
+        ),
+        None,
+    )
+    if converter is None:
+        raise RuntimeError("native AST expression converter is missing")
+
+    name_count = 0
+    string_count = 0
+    fstring_count = 0
+    for node in ast.walk(converter):
+        if not isinstance(node, ast.If):
+            continue
+        if _is_source_node_test(node, "Name"):
+            node.body = ast.parse(
+                "converted = Name(node.name)\n"
+                "converted._native_name = node.name\n"
+                "return converted\n"
+            ).body
+            name_count += 1
+        elif _is_source_node_test(node, "StrLit"):
+            node.body = ast.parse(
+                "converted = Constant(node.value)\n"
+                "converted._native_kind = 4\n"
+                "return converted\n"
+            ).body
+            string_count += 1
+        elif _is_source_node_test(node, "FString"):
+            original = list(node.body)
+            if not original:
+                raise RuntimeError("native FString conversion body is empty")
+            # Preserve the existing segment conversion, then stamp its result
+            # immediately before the final return.
+            final_return = original[-1]
+            if not isinstance(final_return, ast.Return):
+                raise RuntimeError("native FString conversion has no final return")
+            result_name = "converted_fstring"
+            node.body = original[:-1]
+            node.body.extend(
+                [
+                    ast.Assign(
+                        targets=[ast.Name(id=result_name, ctx=ast.Store())],
+                        value=final_return.value,
+                    ),
+                    ast.Assign(
+                        targets=[
+                            ast.Attribute(
+                                value=ast.Name(id=result_name, ctx=ast.Load()),
+                                attr="_native_kind",
+                                ctx=ast.Store(),
+                            )
+                        ],
+                        value=ast.Constant(4),
+                    ),
+                    ast.Return(value=ast.Name(id=result_name, ctx=ast.Load())),
+                ]
+            )
+            fstring_count += 1
+
+    if name_count != 1 or string_count != 1 or fstring_count != 1:
+        raise RuntimeError(
+            "native AST comparison metadata expected one Name, StrLit, and FString "
+            f"conversion; found {(name_count, string_count, fstring_count)}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    NATIVE_AST_PATH.write_text(source, encoding="utf-8")
+    if source.count("._native_kind = 4") != 2:
+        raise RuntimeError("native string metadata stamping validation failed")
+    if source.count("._native_name =") != 1:
+        raise RuntimeError("native name metadata stamping validation failed")
+    return 3
+
+
 def _normalize_frontend() -> int:
     source = FRONTEND_PATH.read_text(encoding="utf-8")
     old = '''            operands = [node.left]
@@ -54,24 +155,16 @@ def _normalize_frontend() -> int:
                 right_operand: ast.expr = node.comparators[index]
                 self.expr(left_operand)
                 self.expr(right_operand)
-                left_is_string = False
-                if isinstance(left_operand, ast.Name):
-                    left_name: str = getattr(left_operand, "id")
+                left_kind: int = getattr(left_operand, "_native_kind", _TRUTH_UNKNOWN)
+                left_name: str = getattr(left_operand, "_native_name", "")
+                left_is_string = left_kind == _TRUTH_STRING
+                if not left_is_string and left_name != "":
                     left_is_string = self.kind_hint(left_name) == _TRUTH_STRING
-                elif isinstance(left_operand, ast.Constant):
-                    left_value: object = getattr(left_operand, "value")
-                    left_is_string = isinstance(left_value, str)
-                elif isinstance(left_operand, ast.JoinedStr):
-                    left_is_string = True
-                right_is_string = False
-                if isinstance(right_operand, ast.Name):
-                    right_name: str = getattr(right_operand, "id")
+                right_kind: int = getattr(right_operand, "_native_kind", _TRUTH_UNKNOWN)
+                right_name: str = getattr(right_operand, "_native_name", "")
+                right_is_string = right_kind == _TRUTH_STRING
+                if not right_is_string and right_name != "":
                     right_is_string = self.kind_hint(right_name) == _TRUTH_STRING
-                elif isinstance(right_operand, ast.Constant):
-                    right_value: object = getattr(right_operand, "value")
-                    right_is_string = isinstance(right_value, str)
-                elif isinstance(right_operand, ast.JoinedStr):
-                    right_is_string = True
                 comparison_kind = _TRUTH_STRING if left_is_string and right_is_string else _TRUTH_UNKNOWN
                 self.emit(_compare_opcode(op), comparison_kind)
                 if index:
@@ -85,8 +178,8 @@ def _normalize_frontend() -> int:
         raise RuntimeError("native string comparison kind was not emitted")
     if "operands = [node.left]" in source:
         raise RuntimeError("native comparison still erases AST operand types in a list")
-    if "self.expression_kind(left_operand)" in source or "self.expression_kind(right_operand)" in source:
-        raise RuntimeError("native comparison still crosses the opaque AST classifier boundary")
+    if "isinstance(left_operand" in source or "isinstance(right_operand" in source:
+        raise RuntimeError("native comparison still rediscovers erased AST classes")
     return 1
 
 
@@ -140,9 +233,15 @@ def _normalize_vm() -> int:
 
 def main() -> int:
     normalize_truthiness()
+    metadata_count = _normalize_native_ast_metadata()
     frontend_count = _normalize_frontend()
     vm_count = _normalize_vm()
-    print("NORMALIZED NATIVE STRING COMPARISONS", frontend_count, vm_count)
+    print(
+        "NORMALIZED NATIVE STRING COMPARISONS",
+        metadata_count,
+        frontend_count,
+        vm_count,
+    )
     return 0
 
 

From b342d9214746384733b1119a01359c87b4457bac Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:51:46 -0500
Subject: [PATCH 196/450] Reject mixed native string ordering

---
 .../normalize_full_core_string_comparisons.py | 102 ++++++++++++++----
 1 file changed, 83 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_string_comparisons.py b/tools/normalize_full_core_string_comparisons.py
index 764be1fe..4da99544 100644
--- a/tools/normalize_full_core_string_comparisons.py
+++ b/tools/normalize_full_core_string_comparisons.py
@@ -11,6 +11,8 @@
 NATIVE_AST_PATH = Path("src/portapy/core/native_ast.py")
 VM_PATH = Path("src/portapy/core/vm.py")
 
+_MIXED_STRING_KIND = 8
+
 _HELPER = '''def _full_core_probe_compare_strings(left: str, right: str, operation: int) -> bool:
     if operation == 20:
         return left == right
@@ -70,6 +72,8 @@ def _normalize_native_ast_metadata() -> int:
         raise RuntimeError("native AST expression converter is missing")
 
     name_count = 0
+    integer_count = 0
+    float_count = 0
     string_count = 0
     fstring_count = 0
     for node in ast.walk(converter):
@@ -82,6 +86,28 @@ def _normalize_native_ast_metadata() -> int:
                 "return converted\n"
             ).body
             name_count += 1
+        elif _is_source_node_test(node, "IntLit"):
+            node.body = ast.parse(
+                "if node.is_none:\n"
+                "    converted = Constant(None)\n"
+                "    converted._native_kind = 7\n"
+                "    return converted\n"
+                "if node.is_bool:\n"
+                "    converted = Constant(bool(node.value))\n"
+                "    converted._native_kind = 1\n"
+                "    return converted\n"
+                "converted = Constant(node.value)\n"
+                "converted._native_kind = 2\n"
+                "return converted\n"
+            ).body
+            integer_count += 1
+        elif _is_source_node_test(node, "FloatLit"):
+            node.body = ast.parse(
+                "converted = Constant(node.value)\n"
+                "converted._native_kind = 3\n"
+                "return converted\n"
+            ).body
+            float_count += 1
         elif _is_source_node_test(node, "StrLit"):
             node.body = ast.parse(
                 "converted = Constant(node.value)\n"
@@ -93,8 +119,6 @@ def _normalize_native_ast_metadata() -> int:
             original = list(node.body)
             if not original:
                 raise RuntimeError("native FString conversion body is empty")
-            # Preserve the existing segment conversion, then stamp its result
-            # immediately before the final return.
             final_return = original[-1]
             if not isinstance(final_return, ast.Return):
                 raise RuntimeError("native FString conversion has no final return")
@@ -121,19 +145,34 @@ def _normalize_native_ast_metadata() -> int:
             )
             fstring_count += 1
 
-    if name_count != 1 or string_count != 1 or fstring_count != 1:
+    actual = (
+        name_count,
+        integer_count,
+        float_count,
+        string_count,
+        fstring_count,
+    )
+    if actual != (1, 1, 1, 1, 1):
         raise RuntimeError(
-            "native AST comparison metadata expected one Name, StrLit, and FString "
-            f"conversion; found {(name_count, string_count, fstring_count)}"
+            "native AST comparison metadata expected one Name, IntLit, FloatLit, "
+            f"StrLit, and FString conversion; found {actual}"
         )
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     NATIVE_AST_PATH.write_text(source, encoding="utf-8")
-    if source.count("._native_kind = 4") != 2:
-        raise RuntimeError("native string metadata stamping validation failed")
-    if source.count("._native_name =") != 1:
-        raise RuntimeError("native name metadata stamping validation failed")
-    return 3
+    for marker in (
+        "._native_kind = 1",
+        "._native_kind = 2",
+        "._native_kind = 3",
+        "._native_kind = 4",
+        "._native_kind = 7",
+        "._native_name =",
+    ):
+        if marker not in source:
+            raise RuntimeError(
+                f"native comparison metadata stamping lost {marker!r}"
+            )
+    return 5
 
 
 def _normalize_frontend() -> int:
@@ -148,7 +187,7 @@ def _normalize_frontend() -> int:
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
 '''
-    new = '''            left_operand: ast.expr = getattr(node, "left")
+    new = f'''            left_operand: ast.expr = getattr(node, "left")
             index = 0
             while index < len(node.ops):
                 op = node.ops[index]
@@ -157,15 +196,21 @@ def _normalize_frontend() -> int:
                 self.expr(right_operand)
                 left_kind: int = getattr(left_operand, "_native_kind", _TRUTH_UNKNOWN)
                 left_name: str = getattr(left_operand, "_native_name", "")
-                left_is_string = left_kind == _TRUTH_STRING
-                if not left_is_string and left_name != "":
-                    left_is_string = self.kind_hint(left_name) == _TRUTH_STRING
+                if left_kind == _TRUTH_UNKNOWN and left_name != "":
+                    left_kind = self.kind_hint(left_name)
                 right_kind: int = getattr(right_operand, "_native_kind", _TRUTH_UNKNOWN)
                 right_name: str = getattr(right_operand, "_native_name", "")
-                right_is_string = right_kind == _TRUTH_STRING
-                if not right_is_string and right_name != "":
-                    right_is_string = self.kind_hint(right_name) == _TRUTH_STRING
-                comparison_kind = _TRUTH_STRING if left_is_string and right_is_string else _TRUTH_UNKNOWN
+                if right_kind == _TRUTH_UNKNOWN and right_name != "":
+                    right_kind = self.kind_hint(right_name)
+                comparison_kind = _TRUTH_UNKNOWN
+                if left_kind == _TRUTH_STRING and right_kind == _TRUTH_STRING:
+                    comparison_kind = _TRUTH_STRING
+                elif (
+                    left_kind == _TRUTH_STRING and right_kind != _TRUTH_UNKNOWN
+                ) or (
+                    right_kind == _TRUTH_STRING and left_kind != _TRUTH_UNKNOWN
+                ):
+                    comparison_kind = {_MIXED_STRING_KIND}
                 self.emit(_compare_opcode(op), comparison_kind)
                 if index:
                     self.emit(Op.BINARY_BOOL_AND)
@@ -176,6 +221,8 @@ def _normalize_frontend() -> int:
     FRONTEND_PATH.write_text(source, encoding="utf-8")
     if "self.emit(_compare_opcode(op), comparison_kind)" not in source:
         raise RuntimeError("native string comparison kind was not emitted")
+    if f"comparison_kind = {_MIXED_STRING_KIND}" not in source:
+        raise RuntimeError("native mixed string comparison tag was not emitted")
     if "operands = [node.left]" in source:
         raise RuntimeError("native comparison still erases AST operand types in a list")
     if "isinstance(left_operand" in source or "isinstance(right_operand" in source:
@@ -200,7 +247,20 @@ def _normalize_vm() -> int:
                     elif op is Op.COMPARE_NE:
                         frame.stack.append(left != right)
 '''
-    new = '''                    if instr.arg == 4 and op in (
+    new = f'''                    if instr.arg == {_MIXED_STRING_KIND} and op is Op.COMPARE_EQ:
+                        frame.stack.append(False)
+                    elif instr.arg == {_MIXED_STRING_KIND} and op is Op.COMPARE_NE:
+                        frame.stack.append(True)
+                    elif instr.arg == {_MIXED_STRING_KIND} and op in (
+                        Op.COMPARE_LT,
+                        Op.COMPARE_LE,
+                        Op.COMPARE_GT,
+                        Op.COMPARE_GE,
+                    ):
+                        _raise_typed(
+                            "TypeError: ordering comparison between string and non-string"
+                        )
+                    elif instr.arg == 4 and op in (
                         Op.COMPARE_EQ,
                         Op.COMPARE_LT,
                         Op.COMPARE_LE,
@@ -228,6 +288,10 @@ def _normalize_vm() -> int:
     VM_PATH.write_text(source, encoding="utf-8")
     if source.count("_full_core_probe_compare_strings") != 2:
         raise RuntimeError("native string comparison helper validation failed")
+    if f"instr.arg == {_MIXED_STRING_KIND}" not in source:
+        raise RuntimeError("native mixed string comparison VM dispatch is missing")
+    if "ordering comparison between string and non-string" not in source:
+        raise RuntimeError("native mixed string ordering error is missing")
     return 1
 
 

From 0ce02918c532364a990b03b90c6ac57fd64325fe Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Tue, 21 Jul 2026 23:59:41 -0500
Subject: [PATCH 197/450] Preserve native TypeError ABI status

---
 tools/normalize_full_reference_type_errors.py | 136 ++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 tools/normalize_full_reference_type_errors.py

diff --git a/tools/normalize_full_reference_type_errors.py b/tools/normalize_full_reference_type_errors.py
new file mode 100644
index 00000000..6bed0857
--- /dev/null
+++ b/tools/normalize_full_reference_type_errors.py
@@ -0,0 +1,136 @@
+"""Preserve real VM TypeError exceptions at the public native ABI boundary."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/reference_api.py")
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        self.generic_visit(node)
+        if node.name != "Runtime":
+            return node
+        method = next(
+            (
+                item
+                for item in node.body
+                if isinstance(item, ast.FunctionDef) and item.name == "exec_utf8"
+            ),
+            None,
+        )
+        if method is None:
+            raise RuntimeError("reference Runtime.exec_utf8 is missing")
+        for statement in method.body:
+            if not isinstance(statement, ast.Try):
+                continue
+            if not any(
+                isinstance(item, ast.Expr)
+                and isinstance(item.value, ast.Call)
+                and isinstance(item.value.func, ast.Attribute)
+                and item.value.func.attr == "run"
+                for item in statement.body
+            ):
+                continue
+            broad_index = next(
+                (
+                    index
+                    for index, handler in enumerate(statement.handlers)
+                    if isinstance(handler.type, ast.Name)
+                    and handler.type.id == "BaseException"
+                ),
+                -1,
+            )
+            if broad_index < 0:
+                raise RuntimeError(
+                    "reference Runtime.exec_utf8 has no BaseException handler"
+                )
+            if any(
+                isinstance(handler.type, ast.Name)
+                and handler.type.id == "TypeError"
+                for handler in statement.handlers
+            ):
+                raise RuntimeError(
+                    "reference Runtime.exec_utf8 already preserves TypeError"
+                )
+            handler = ast.ExceptHandler(
+                type=ast.Name(id="TypeError", ctx=ast.Load()),
+                name="error",
+                body=[
+                    ast.Return(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr="_capture_native",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                ast.Attribute(
+                                    value=ast.Name(id="Status", ctx=ast.Load()),
+                                    attr="TYPE_ERROR",
+                                    ctx=ast.Load(),
+                                ),
+                                ast.Constant("TypeError"),
+                                ast.Constant("PortaPy type error"),
+                            ],
+                            keywords=[],
+                        )
+                    )
+                ],
+            )
+            statement.handlers.insert(broad_index, handler)
+            self.count += 1
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    if rewriter.count != 1:
+        raise RuntimeError(
+            "native reference TypeError normalization expected 1 handler, "
+            f"found {rewriter.count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    runtime = next(
+        node
+        for node in verified.body
+        if isinstance(node, ast.ClassDef) and node.name == "Runtime"
+    )
+    method = next(
+        node
+        for node in runtime.body
+        if isinstance(node, ast.FunctionDef) and node.name == "exec_utf8"
+    )
+    text = ast.unparse(method)
+    required = (
+        "except TypeError as error:",
+        "Status.TYPE_ERROR",
+        "self._capture_native(",
+        "except BaseException as error:",
+    )
+    missing = [marker for marker in required if marker not in text]
+    if missing:
+        raise RuntimeError(
+            f"native reference TypeError validation failed: {missing}"
+        )
+    if text.find("except TypeError as error:") > text.find(
+        "except BaseException as error:"
+    ):
+        raise RuntimeError("native TypeError handler follows the broad handler")
+    print("NORMALIZED NATIVE REFERENCE TYPE ERRORS", rewriter.count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 88a043c4350f5c193de7675d520ce702d87f012f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 00:00:20 -0500
Subject: [PATCH 198/450] Preserve native TypeError status in build

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index f9f32c30..5e29765f 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -64,6 +64,9 @@
 from tools.normalize_full_reference_source_preprocess import (
     main as normalize_reference_source_preprocess,
 )
+from tools.normalize_full_reference_type_errors import (
+    main as normalize_reference_type_errors,
+)
 from tools.normalize_full_reference_value_kinds import (
     main as normalize_reference_value_kinds,
 )
@@ -141,6 +144,7 @@ def main() -> int:
     _normalize_nested_code_introspection()
     _normalize_opcode_validation()
     normalize_truthiness()
+    normalize_reference_type_errors()
     return 0
 
 

From 93dfc1ae6210ff04a2f4f8f1c41d9cd455f96584 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:02:27 -0500
Subject: [PATCH 199/450] Fix TypeError handler order validation

---
 tools/normalize_full_reference_type_errors.py | 52 ++++++++++++-------
 1 file changed, 33 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_reference_type_errors.py b/tools/normalize_full_reference_type_errors.py
index 6bed0857..4d688211 100644
--- a/tools/normalize_full_reference_type_errors.py
+++ b/tools/normalize_full_reference_type_errors.py
@@ -8,6 +8,16 @@
 PATH = Path("src/portapy/reference_api.py")
 
 
+def _is_vm_run_try(statement: ast.stmt) -> bool:
+    return isinstance(statement, ast.Try) and any(
+        isinstance(item, ast.Expr)
+        and isinstance(item.value, ast.Call)
+        and isinstance(item.value.func, ast.Attribute)
+        and item.value.func.attr == "run"
+        for item in statement.body
+    )
+
+
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.count = 0
@@ -27,15 +37,7 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
         if method is None:
             raise RuntimeError("reference Runtime.exec_utf8 is missing")
         for statement in method.body:
-            if not isinstance(statement, ast.Try):
-                continue
-            if not any(
-                isinstance(item, ast.Expr)
-                and isinstance(item.value, ast.Call)
-                and isinstance(item.value.func, ast.Attribute)
-                and item.value.func.attr == "run"
-                for item in statement.body
-            ):
+            if not _is_vm_run_try(statement):
                 continue
             broad_index = next(
                 (
@@ -112,22 +114,34 @@ def main() -> int:
         for node in runtime.body
         if isinstance(node, ast.FunctionDef) and node.name == "exec_utf8"
     )
-    text = ast.unparse(method)
-    required = (
-        "except TypeError as error:",
-        "Status.TYPE_ERROR",
-        "self._capture_native(",
-        "except BaseException as error:",
+    run_try = next(
+        statement for statement in method.body if _is_vm_run_try(statement)
     )
-    missing = [marker for marker in required if marker not in text]
+    handler_names = [
+        handler.type.id if isinstance(handler.type, ast.Name) else ""
+        for handler in run_try.handlers
+    ]
+    required_handlers = ("TypeError", "BaseException")
+    missing = [name for name in required_handlers if name not in handler_names]
     if missing:
         raise RuntimeError(
             f"native reference TypeError validation failed: {missing}"
         )
-    if text.find("except TypeError as error:") > text.find(
-        "except BaseException as error:"
-    ):
+    if handler_names.index("TypeError") > handler_names.index("BaseException"):
         raise RuntimeError("native TypeError handler follows the broad handler")
+
+    type_handler = run_try.handlers[handler_names.index("TypeError")]
+    text = ast.unparse(type_handler)
+    required_markers = (
+        "except TypeError as error:",
+        "Status.TYPE_ERROR",
+        "self._capture_native(",
+    )
+    missing_markers = [marker for marker in required_markers if marker not in text]
+    if missing_markers:
+        raise RuntimeError(
+            f"native reference TypeError validation failed: {missing_markers}"
+        )
     print("NORMALIZED NATIVE REFERENCE TYPE ERRORS", rewriter.count)
     return 0
 

From dd59f538594277cfe54a9dabaff9907eaa191723 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:02:42 -0500
Subject: [PATCH 200/450] Test native TypeError handler ordering

---
 ...st_normalize_full_reference_type_errors.py | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_type_errors.py

diff --git a/tests/test_normalize_full_reference_type_errors.py b/tests/test_normalize_full_reference_type_errors.py
new file mode 100644
index 00000000..39e0cf63
--- /dev/null
+++ b/tests/test_normalize_full_reference_type_errors.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+from tools import normalize_full_reference_runtime as runtime_normalizer
+from tools import normalize_full_reference_type_errors as type_error_normalizer
+
+
+REFERENCE_SOURCE = Path("src/portapy/reference_api.py")
+
+
+def _is_vm_run_try(statement: ast.stmt) -> bool:
+    return isinstance(statement, ast.Try) and any(
+        isinstance(item, ast.Expr)
+        and isinstance(item.value, ast.Call)
+        and isinstance(item.value.func, ast.Attribute)
+        and item.value.func.attr == "run"
+        for item in statement.body
+    )
+
+
+def test_type_error_handler_precedes_base_exception(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "reference_api.py"
+    path.write_text(REFERENCE_SOURCE.read_text(encoding="utf-8"), encoding="utf-8")
+    monkeypatch.setattr(runtime_normalizer, "PATH", path)
+    monkeypatch.setattr(type_error_normalizer, "PATH", path)
+
+    assert runtime_normalizer.main() == 0
+    assert type_error_normalizer.main() == 0
+
+    module = ast.parse(path.read_text(encoding="utf-8"))
+    runtime = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "Runtime"
+    )
+    method = next(
+        node
+        for node in runtime.body
+        if isinstance(node, ast.FunctionDef) and node.name == "exec_utf8"
+    )
+    run_try = next(statement for statement in method.body if _is_vm_run_try(statement))
+    handler_names = [
+        handler.type.id if isinstance(handler.type, ast.Name) else ""
+        for handler in run_try.handlers
+    ]
+
+    assert handler_names.index("TypeError") < handler_names.index("BaseException")
+    type_handler = run_try.handlers[handler_names.index("TypeError")]
+    handler_source = ast.unparse(type_handler)
+    assert "Status.TYPE_ERROR" in handler_source
+    assert "self._capture_native(" in handler_source

From df153236fe45408562ce097e088384c5c507e51e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:20:44 -0500
Subject: [PATCH 201/450] Add native string concatenation semantics

---
 tools/normalize_full_core_string_addition.py | 226 +++++++++++++++++++
 1 file changed, 226 insertions(+)
 create mode 100644 tools/normalize_full_core_string_addition.py

diff --git a/tools/normalize_full_core_string_addition.py b/tools/normalize_full_core_string_addition.py
new file mode 100644
index 00000000..80c310a2
--- /dev/null
+++ b/tools/normalize_full_core_string_addition.py
@@ -0,0 +1,226 @@
+"""Give native VM string addition Python content semantics."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+NATIVE_AST_PATH = Path("src/portapy/core/native_ast.py")
+VM_PATH = Path("src/portapy/core/vm.py")
+
+_STRING_KIND = 4
+_MIXED_STRING_KIND = 8
+
+_CONCAT_HELPER = '''def _full_core_probe_concat_strings(left: str, right: str) -> str:
+    return f"{left}{right}"
+
+
+'''
+
+
+def _replace(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native string addition {label}: expected 1 match, found {count}"
+        )
+    return source.replace(old, new, 1)
+
+
+def _replace_one_of(
+    source: str,
+    replacements: tuple[tuple[str, str], ...],
+    label: str,
+) -> str:
+    matches = [(old, new) for old, new in replacements if source.count(old) == 1]
+    if len(matches) != 1:
+        counts = [source.count(old) for old, _ in replacements]
+        raise RuntimeError(
+            f"native string addition {label}: expected one source shape, found {counts}"
+        )
+    old, new = matches[0]
+    return source.replace(old, new, 1)
+
+
+def _is_source_node_test(node: ast.If, suffix: str) -> bool:
+    test = node.test
+    if not (
+        isinstance(test, ast.Call)
+        and isinstance(test.func, ast.Name)
+        and test.func.id == "isinstance"
+        and len(test.args) == 2
+        and isinstance(test.args[0], ast.Name)
+        and test.args[0].id == "node"
+    ):
+        return False
+    expected = test.args[1]
+    if isinstance(expected, ast.Name):
+        return expected.id.endswith(suffix)
+    if isinstance(expected, ast.Attribute):
+        return expected.attr == suffix
+    return False
+
+
+def _normalize_native_ast_metadata() -> int:
+    module = ast.parse(NATIVE_AST_PATH.read_text(encoding="utf-8"))
+    converter = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef) and node.name == "_convert_expr"
+        ),
+        None,
+    )
+    if converter is None:
+        raise RuntimeError("native AST expression converter is missing")
+
+    count = 0
+    for node in ast.walk(converter):
+        if not isinstance(node, ast.If) or not _is_source_node_test(node, "BinOp"):
+            continue
+        node.body = ast.parse(
+            "left: expr = _convert_expr(node.left, lifted)\n"
+            "right: expr = _convert_expr(node.right, lifted)\n"
+            "converted: expr = BinOp(left, _BIN_OPS[node.op], right)\n"
+            "if node.op == '+':\n"
+            "    left_kind: int = getattr(left, '_native_kind', 0)\n"
+            "    right_kind: int = getattr(right, '_native_kind', 0)\n"
+            "    if left_kind == 4 and right_kind == 4:\n"
+            "        converted._native_kind = 4\n"
+            "return converted\n"
+        ).body
+        count += 1
+
+    if count != 1:
+        raise RuntimeError(
+            f"native AST string addition expected one BinOp conversion, found {count}"
+        )
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    NATIVE_AST_PATH.write_text(source, encoding="utf-8")
+    required = (
+        "node.op == '+'",
+        "converted._native_kind = 4",
+        "left: expr = _convert_expr(node.left, lifted)",
+        "right: expr = _convert_expr(node.right, lifted)",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(
+            f"native AST string addition metadata validation failed: {missing}"
+        )
+    return count
+
+
+def _normalize_frontend() -> int:
+    source = FRONTEND_PATH.read_text(encoding="utf-8")
+    old = '''        elif isinstance(node, ast.BinOp) and _binary_opcode(node.op) is not None:
+            self.expr(node.left)
+            self.expr(node.right)
+            self.emit(_binary_opcode(node.op))
+'''
+    new = f'''        elif isinstance(node, ast.BinOp) and _binary_opcode(node.op) is not None:
+            binary_opcode: int = _binary_opcode(node.op)
+            left_operand: ast.expr = getattr(node, "left")
+            right_operand: ast.expr = getattr(node, "right")
+            self.expr(left_operand)
+            self.expr(right_operand)
+            left_kind: int = getattr(left_operand, "_native_kind", _TRUTH_UNKNOWN)
+            left_name: str = getattr(left_operand, "_native_name", "")
+            if left_kind == _TRUTH_UNKNOWN and left_name != "":
+                left_kind = self.kind_hint(left_name)
+            right_kind: int = getattr(right_operand, "_native_kind", _TRUTH_UNKNOWN)
+            right_name: str = getattr(right_operand, "_native_name", "")
+            if right_kind == _TRUTH_UNKNOWN and right_name != "":
+                right_kind = self.kind_hint(right_name)
+            binary_kind = _TRUTH_UNKNOWN
+            if binary_opcode == Op.BINARY_ADD:
+                if left_kind == _TRUTH_STRING and right_kind == _TRUTH_STRING:
+                    binary_kind = _TRUTH_STRING
+                elif (
+                    left_kind == _TRUTH_STRING and right_kind != _TRUTH_UNKNOWN
+                ) or (
+                    right_kind == _TRUTH_STRING and left_kind != _TRUTH_UNKNOWN
+                ):
+                    binary_kind = {_MIXED_STRING_KIND}
+            self.emit(binary_opcode, binary_kind)
+'''
+    source = _replace(source, old, new, "frontend lowering")
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    required = (
+        "self.emit(binary_opcode, binary_kind)",
+        "binary_opcode == Op.BINARY_ADD",
+        "binary_kind = _TRUTH_STRING",
+        f"binary_kind = {_MIXED_STRING_KIND}",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(
+            f"native frontend string addition validation failed: {missing}"
+        )
+    return 1
+
+
+def _normalize_vm() -> int:
+    source = VM_PATH.read_text(encoding="utf-8")
+    class_anchor = "class VirtualMachine:"
+    source = _replace(
+        source,
+        class_anchor,
+        _CONCAT_HELPER + class_anchor,
+        "helper insertion",
+    )
+    inline_old = "                    if op is Op.BINARY_ADD: frame.stack.append(left + right)\n"
+    expanded_old = '''                    if op is Op.BINARY_ADD:
+                        frame.stack.append(left + right)
+'''
+    replacement = f'''                    if op is Op.BINARY_ADD:
+                        if instr.arg == {_STRING_KIND}:
+                            frame.stack.append(
+                                _full_core_probe_concat_strings(left, right)
+                            )
+                        elif instr.arg == {_MIXED_STRING_KIND}:
+                            _raise_typed(
+                                "TypeError: can only concatenate string to string"
+                            )
+                        else:
+                            frame.stack.append(left + right)
+'''
+    source = _replace_one_of(
+        source,
+        ((inline_old, replacement), (expanded_old, replacement)),
+        "VM dispatch",
+    )
+    VM_PATH.write_text(source, encoding="utf-8")
+    required = (
+        "def _full_core_probe_concat_strings",
+        f"instr.arg == {_STRING_KIND}",
+        f"instr.arg == {_MIXED_STRING_KIND}",
+        "can only concatenate string to string",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(
+            f"native VM string addition validation failed: {missing}"
+        )
+    if source.count("_full_core_probe_concat_strings") != 2:
+        raise RuntimeError("native string concatenation helper validation failed")
+    return 1
+
+
+def main() -> int:
+    metadata_count = _normalize_native_ast_metadata()
+    frontend_count = _normalize_frontend()
+    vm_count = _normalize_vm()
+    print(
+        "NORMALIZED NATIVE STRING ADDITION",
+        metadata_count,
+        frontend_count,
+        vm_count,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 5e91985a1980bcddc4a0720f0b2f4234f3317e59 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:21:26 -0500
Subject: [PATCH 202/450] Run native string addition normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5e29765f..070c733a 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -26,6 +26,7 @@
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
+from tools.normalize_full_core_string_addition import main as normalize_string_addition
 from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
 from tools.normalize_full_reference_abi_helpers import (
@@ -144,6 +145,7 @@ def main() -> int:
     _normalize_nested_code_introspection()
     _normalize_opcode_validation()
     normalize_truthiness()
+    normalize_string_addition()
     normalize_reference_type_errors()
     return 0
 

From 1186e55a0871a35b4eed81d7fdcdc280f475fb58 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:21:47 -0500
Subject: [PATCH 203/450] Test native string addition normalization

---
 ...est_normalize_full_core_string_addition.py | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 tests/test_normalize_full_core_string_addition.py

diff --git a/tests/test_normalize_full_core_string_addition.py b/tests/test_normalize_full_core_string_addition.py
new file mode 100644
index 00000000..28f88a9d
--- /dev/null
+++ b/tests/test_normalize_full_core_string_addition.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+from tools import normalize_full_core_string_addition as normalizer
+
+
+NATIVE_AST_SOURCE = '''
+class A:
+    class BinOp: pass
+class expr: pass
+class BinOp(expr):
+    def __init__(self, left, op, right):
+        self.left = left
+        self.op = op
+        self.right = right
+_BIN_OPS = {"+": object()}
+def _convert_expr(node, lifted):
+    if isinstance(node, A.BinOp):
+        return BinOp(_convert_expr(node.left, lifted), _BIN_OPS[node.op], _convert_expr(node.right, lifted))
+    return expr()
+'''
+
+FRONTEND_SOURCE = '''
+class Lowerer:
+    def expr(self, node):
+        if False:
+            pass
+        elif isinstance(node, ast.BinOp) and _binary_opcode(node.op) is not None:
+            self.expr(node.left)
+            self.expr(node.right)
+            self.emit(_binary_opcode(node.op))
+'''
+
+VM_SOURCE = '''
+class VirtualMachine:
+    def run(self, frame, instr, op):
+        left = None
+        right = None
+        if op is Op.BINARY_ADD: frame.stack.append(left + right)
+'''
+
+
+def test_installs_typed_native_string_addition(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    native_ast = tmp_path / "native_ast.py"
+    frontend = tmp_path / "frontend.py"
+    vm = tmp_path / "vm.py"
+    native_ast.write_text(NATIVE_AST_SOURCE, encoding="utf-8")
+    frontend.write_text(FRONTEND_SOURCE, encoding="utf-8")
+    vm.write_text(VM_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "NATIVE_AST_PATH", native_ast)
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+    monkeypatch.setattr(normalizer, "VM_PATH", vm)
+
+    assert normalizer.main() == 0
+
+    native_text = native_ast.read_text(encoding="utf-8")
+    assert "converted._native_kind = 4" in native_text
+    assert "node.op == '+'" in native_text
+
+    frontend_text = frontend.read_text(encoding="utf-8")
+    assert "self.emit(binary_opcode, binary_kind)" in frontend_text
+    assert "binary_kind = _TRUTH_STRING" in frontend_text
+    assert "binary_kind = 8" in frontend_text
+
+    vm_text = vm.read_text(encoding="utf-8")
+    assert "def _full_core_probe_concat_strings" in vm_text
+    assert 'return f"{left}{right}"' in vm_text
+    assert "instr.arg == 4" in vm_text
+    assert "instr.arg == 8" in vm_text
+    assert "can only concatenate string to string" in vm_text
+
+    ast.parse(native_text)
+    ast.parse(frontend_text)
+    ast.parse(vm_text)

From 3f9f23d84ad0d5d8c248489b625c0f6aea937c15 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:28:51 -0500
Subject: [PATCH 204/450] Keep POP_TOP mutation observable

---
 tools/normalize_full_core_pop_top.py | 43 +++++++++++++++++++---------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index 8c1f8c9b..f1fe2b51 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -1,10 +1,9 @@
 """Keep the POP_TOP list mutation visible to the native compiler.
 
-The pinned compiler mislowers a method call whose result is immediately
-ignored inside the VM dispatch loop.  Every assigned ``frame.stack.pop()``
-path works natively, while the lone bare POP_TOP call crashes.  Bind the
-removed value to a local so the list mutation is emitted normally; the local
-is intentionally unused after the assignment.
+The pinned compiler can eliminate a list ``pop()`` whose result only lands in an
+unused local, turning expression statements into a native crash. Store the
+removed value on the VM instance instead: the observable attribute write keeps
+the mutation alive without affecting the value stack or program namespace.
 """
 from __future__ import annotations
 
@@ -13,29 +12,45 @@
 
 PATH = Path("src/portapy/core/vm.py")
 
+_INIT_OLD = '''    def __init__(self) -> None:
+        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
+        self._current_frame: Frame | None = None
+'''
+_INIT_NEW = '''    def __init__(self) -> None:
+        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
+        self._current_frame: Frame | None = None
+        self._discarded: object = None
+'''
 _OLD = '''                elif op is Op.POP_TOP:
                     frame.stack.pop()
 '''
 _NEW = '''                elif op is Op.POP_TOP:
-                    discarded = frame.stack.pop()
+                    self._discarded = frame.stack.pop()
 '''
 
 
-def main() -> int:
-    source = PATH.read_text(encoding="utf-8")
-    count = source.count(_OLD)
+def _replace_once(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
     if count != 1:
         raise RuntimeError(
-            f"native POP_TOP normalization expected one handler, found {count}"
+            f"native POP_TOP {label} normalization expected one match, found {count}"
         )
-    source = source.replace(_OLD, _NEW, 1)
+    return source.replace(old, new, 1)
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    source = _replace_once(source, _INIT_OLD, _INIT_NEW, "VM field")
+    source = _replace_once(source, _OLD, _NEW, "handler")
     PATH.write_text(source, encoding="utf-8")
 
-    if source.count("discarded = frame.stack.pop()") != 1:
-        raise RuntimeError("native POP_TOP validation did not preserve assigned pop")
+    if source.count("self._discarded = frame.stack.pop()") != 1:
+        raise RuntimeError("native POP_TOP validation lost observable assigned pop")
+    if source.count("self._discarded: object = None") != 1:
+        raise RuntimeError("native POP_TOP validation lost discard field")
     if _OLD in source:
         raise RuntimeError("native POP_TOP bare pop remains after normalization")
-    print("NORMALIZED NATIVE POP_TOP", count)
+    print("NORMALIZED NATIVE POP_TOP", 2)
     return 0
 
 

From 04ebb2162d954c103fe38989633af43dd702d8bf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:29:09 -0500
Subject: [PATCH 205/450] Test observable POP_TOP storage

---
 tests/test_normalize_full_core_pop_top.py | 45 +++++++++++++++--------
 1 file changed, 29 insertions(+), 16 deletions(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index 2e89242e..79c9753a 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -5,37 +5,50 @@
 from tools import normalize_full_core_pop_top as normalizer
 
 
-def test_assigns_discarded_pop_result(tmp_path: Path, monkeypatch) -> None:
+VM_SOURCE = '''class VirtualMachine:
+    def __init__(self) -> None:
+        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
+        self._current_frame: Frame | None = None
+
+    def run(self, frame, op):
+        if op is Op.LOAD_CONST:
+            frame.stack.append(1)
+        elif op is Op.POP_TOP:
+            frame.stack.pop()
+        elif op is Op.STORE_NAME:
+            value = frame.stack.pop()
+'''
+
+
+def test_stores_discarded_pop_on_vm(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
-    path.write_text(
-        '''def run(frame, op):
-    if op is Op.LOAD_CONST:
-        frame.stack.append(1)
-    elif op is Op.POP_TOP:
-        frame.stack.pop()
-    elif op is Op.STORE_NAME:
-        value = frame.stack.pop()
-''',
-        encoding="utf-8",
-    )
+    path.write_text(VM_SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "discarded = frame.stack.pop()" in source
+    assert "self._discarded: object = None" in source
+    assert "self._discarded = frame.stack.pop()" in source
     assert "value = frame.stack.pop()" in source
-    assert source.count("discarded = frame.stack.pop()") == 1
+    assert source.count("self._discarded = frame.stack.pop()") == 1
 
 
 def test_fails_closed_without_unique_handler(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
-    path.write_text("def run():\n    return\n", encoding="utf-8")
+    path.write_text(
+        '''class VirtualMachine:
+    def __init__(self) -> None:
+        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
+        self._current_frame: Frame | None = None
+''',
+        encoding="utf-8",
+    )
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "expected one handler" in str(error)
+        assert "handler normalization" in str(error)
     else:
         raise AssertionError("normalizer accepted a missing POP_TOP handler")

From 7ecbe5ec5455222107420b77a1fac9b87d9eb477 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:35:04 -0500
Subject: [PATCH 206/450] Avoid native list pop for POP_TOP

---
 tools/normalize_full_core_pop_top.py | 45 ++++++++++------------------
 1 file changed, 15 insertions(+), 30 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index f1fe2b51..5ed36d38 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -1,9 +1,10 @@
-"""Keep the POP_TOP list mutation visible to the native compiler.
+"""Lower POP_TOP without the pinned compiler's crashing list-pop call.
 
-The pinned compiler can eliminate a list ``pop()`` whose result only lands in an
-unused local, turning expression statements into a native crash. Store the
-removed value on the VM instance instead: the observable attribute write keeps
-the mutation alive without affecting the value stack or program namespace.
+The generic VM can use ``frame.stack.pop()``, but that method call crashes when
+it appears as the standalone POP_TOP operation in a native build. Other VM paths
+already exercise list slicing successfully, so replace the stack with every item
+except its final element. This preserves the exact stack effect without calling
+``pop`` at all.
 """
 from __future__ import annotations
 
@@ -12,45 +13,29 @@
 
 PATH = Path("src/portapy/core/vm.py")
 
-_INIT_OLD = '''    def __init__(self) -> None:
-        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
-        self._current_frame: Frame | None = None
-'''
-_INIT_NEW = '''    def __init__(self) -> None:
-        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
-        self._current_frame: Frame | None = None
-        self._discarded: object = None
-'''
 _OLD = '''                elif op is Op.POP_TOP:
                     frame.stack.pop()
 '''
 _NEW = '''                elif op is Op.POP_TOP:
-                    self._discarded = frame.stack.pop()
+                    frame.stack = frame.stack[:-1]
 '''
 
 
-def _replace_once(source: str, old: str, new: str, label: str) -> str:
-    count = source.count(old)
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    count = source.count(_OLD)
     if count != 1:
         raise RuntimeError(
-            f"native POP_TOP {label} normalization expected one match, found {count}"
+            f"native POP_TOP normalization expected one handler, found {count}"
         )
-    return source.replace(old, new, 1)
-
-
-def main() -> int:
-    source = PATH.read_text(encoding="utf-8")
-    source = _replace_once(source, _INIT_OLD, _INIT_NEW, "VM field")
-    source = _replace_once(source, _OLD, _NEW, "handler")
+    source = source.replace(_OLD, _NEW, 1)
     PATH.write_text(source, encoding="utf-8")
 
-    if source.count("self._discarded = frame.stack.pop()") != 1:
-        raise RuntimeError("native POP_TOP validation lost observable assigned pop")
-    if source.count("self._discarded: object = None") != 1:
-        raise RuntimeError("native POP_TOP validation lost discard field")
+    if source.count("frame.stack = frame.stack[:-1]") != 1:
+        raise RuntimeError("native POP_TOP validation lost slice-based stack shrink")
     if _OLD in source:
         raise RuntimeError("native POP_TOP bare pop remains after normalization")
-    print("NORMALIZED NATIVE POP_TOP", 2)
+    print("NORMALIZED NATIVE POP_TOP", count)
     return 0
 
 

From 96092dfd239437d4bb0f4a0bf34a499b376bea84 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:35:22 -0500
Subject: [PATCH 207/450] Test slice-based POP_TOP lowering

---
 tests/test_normalize_full_core_pop_top.py | 37 ++++++++---------------
 1 file changed, 12 insertions(+), 25 deletions(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index 79c9753a..fee809d0 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -5,22 +5,17 @@
 from tools import normalize_full_core_pop_top as normalizer
 
 
-VM_SOURCE = '''class VirtualMachine:
-    def __init__(self) -> None:
-        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
-        self._current_frame: Frame | None = None
-
-    def run(self, frame, op):
-        if op is Op.LOAD_CONST:
-            frame.stack.append(1)
-        elif op is Op.POP_TOP:
-            frame.stack.pop()
-        elif op is Op.STORE_NAME:
-            value = frame.stack.pop()
+VM_SOURCE = '''def run(frame, op):
+    if op is Op.LOAD_CONST:
+        frame.stack.append(1)
+    elif op is Op.POP_TOP:
+        frame.stack.pop()
+    elif op is Op.STORE_NAME:
+        value = frame.stack.pop()
 '''
 
 
-def test_stores_discarded_pop_on_vm(tmp_path: Path, monkeypatch) -> None:
+def test_replaces_pop_top_with_stack_slice(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
     path.write_text(VM_SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
@@ -28,27 +23,19 @@ def test_stores_discarded_pop_on_vm(tmp_path: Path, monkeypatch) -> None:
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "self._discarded: object = None" in source
-    assert "self._discarded = frame.stack.pop()" in source
+    assert "frame.stack = frame.stack[:-1]" in source
     assert "value = frame.stack.pop()" in source
-    assert source.count("self._discarded = frame.stack.pop()") == 1
+    assert source.count("frame.stack = frame.stack[:-1]") == 1
 
 
 def test_fails_closed_without_unique_handler(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
-    path.write_text(
-        '''class VirtualMachine:
-    def __init__(self) -> None:
-        self._synthetic_tracebacks: dict[int, "_PyTBProxy"] = {}
-        self._current_frame: Frame | None = None
-''',
-        encoding="utf-8",
-    )
+    path.write_text("def run():\n    return\n", encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "handler normalization" in str(error)
+        assert "expected one handler" in str(error)
     else:
         raise AssertionError("normalizer accepted a missing POP_TOP handler")

From f2b4780be424c7694521124576c638c849998e19 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:41:47 -0500
Subject: [PATCH 208/450] Stop emitting POP_TOP for expression statements

---
 tools/normalize_full_core_pop_top.py | 40 +++++++++++++++-------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index 5ed36d38..54d5f909 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -1,23 +1,21 @@
-"""Lower POP_TOP without the pinned compiler's crashing list-pop call.
-
-The generic VM can use ``frame.stack.pop()``, but that method call crashes when
-it appears as the standalone POP_TOP operation in a native build. Other VM paths
-already exercise list slicing successfully, so replace the stack with every item
-except its final element. This preserves the exact stack effect without calling
-``pop`` at all.
+"""Avoid the pinned native compiler's crashing POP_TOP dispatch.
+
+Expression statements still have to be evaluated for side effects, but their
+result does not need to be removed before the frame's explicit return. Native
+frames may therefore retain these unused values underneath later operands. The
+bytecode operations consume only the values they push, and RETURN uses the
+explicit top value, so removing this one emission preserves observable Python
+semantics while bypassing the broken standalone stack-removal path.
 """
 from __future__ import annotations
 
 from pathlib import Path
 
 
-PATH = Path("src/portapy/core/vm.py")
+PATH = Path("src/portapy/core/frontend.py")
 
-_OLD = '''                elif op is Op.POP_TOP:
-                    frame.stack.pop()
-'''
-_NEW = '''                elif op is Op.POP_TOP:
-                    frame.stack = frame.stack[:-1]
+_OLD = '''            if not self.interactive and not isinstance(node.value, ast.Yield):
+                self.emit(Op.POP_TOP)
 '''
 
 
@@ -26,16 +24,20 @@ def main() -> int:
     count = source.count(_OLD)
     if count != 1:
         raise RuntimeError(
-            f"native POP_TOP normalization expected one handler, found {count}"
+            "native expression POP_TOP normalization expected one emission, "
+            f"found {count}"
         )
-    source = source.replace(_OLD, _NEW, 1)
+    source = source.replace(_OLD, "", 1)
     PATH.write_text(source, encoding="utf-8")
 
-    if source.count("frame.stack = frame.stack[:-1]") != 1:
-        raise RuntimeError("native POP_TOP validation lost slice-based stack shrink")
     if _OLD in source:
-        raise RuntimeError("native POP_TOP bare pop remains after normalization")
-    print("NORMALIZED NATIVE POP_TOP", count)
+        raise RuntimeError("native expression POP_TOP emission remains")
+    marker = '''        if isinstance(node, ast.Expr):
+            self.expr(node.value)
+'''
+    if marker not in source:
+        raise RuntimeError("native expression evaluation was not preserved")
+    print("REMOVED NATIVE EXPRESSION POP_TOP", count)
     return 0
 
 

From 23d22d29b418c9586bce8e8f286aae2de41f59b0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:42:06 -0500
Subject: [PATCH 209/450] Test omitted expression POP_TOP emission

---
 tests/test_normalize_full_core_pop_top.py | 39 ++++++++++++-----------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index fee809d0..2f8adf7b 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -5,37 +5,40 @@
 from tools import normalize_full_core_pop_top as normalizer
 
 
-VM_SOURCE = '''def run(frame, op):
-    if op is Op.LOAD_CONST:
-        frame.stack.append(1)
-    elif op is Op.POP_TOP:
-        frame.stack.pop()
-    elif op is Op.STORE_NAME:
-        value = frame.stack.pop()
+FRONTEND_SOURCE = '''class Lowerer:
+    def stmt(self, node):
+        if isinstance(node, ast.Expr):
+            self.expr(node.value)
+            if not self.interactive and not isinstance(node.value, ast.Yield):
+                self.emit(Op.POP_TOP)
+        elif isinstance(node, ast.Pass):
+            return
 '''
 
 
-def test_replaces_pop_top_with_stack_slice(tmp_path: Path, monkeypatch) -> None:
-    path = tmp_path / "vm.py"
-    path.write_text(VM_SOURCE, encoding="utf-8")
+def test_preserves_expression_evaluation_without_pop_top(
+    tmp_path: Path, monkeypatch
+) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(FRONTEND_SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "frame.stack = frame.stack[:-1]" in source
-    assert "value = frame.stack.pop()" in source
-    assert source.count("frame.stack = frame.stack[:-1]") == 1
+    assert "self.expr(node.value)" in source
+    assert "self.emit(Op.POP_TOP)" not in source
+    assert "elif isinstance(node, ast.Pass):" in source
 
 
-def test_fails_closed_without_unique_handler(tmp_path: Path, monkeypatch) -> None:
-    path = tmp_path / "vm.py"
-    path.write_text("def run():\n    return\n", encoding="utf-8")
+def test_fails_closed_without_unique_emission(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text("def stmt():\n    return\n", encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "expected one handler" in str(error)
+        assert "expected one emission" in str(error)
     else:
-        raise AssertionError("normalizer accepted a missing POP_TOP handler")
+        raise AssertionError("normalizer accepted a missing POP_TOP emission")

From 10aba301528bd8369d9345c3a9920221e97195b5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:51:37 -0500
Subject: [PATCH 210/450] Lower every POP_TOP through stable name storage

---
 tools/normalize_full_core_pop_top.py | 76 +++++++++++++++++++---------
 1 file changed, 53 insertions(+), 23 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index 54d5f909..86d2d28e 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -1,11 +1,11 @@
-"""Avoid the pinned native compiler's crashing POP_TOP dispatch.
-
-Expression statements still have to be evaluated for side effects, but their
-result does not need to be removed before the frame's explicit return. Native
-frames may therefore retain these unused values underneath later operands. The
-bytecode operations consume only the values they push, and RETURN uses the
-explicit top value, so removing this one emission preserves observable Python
-semantics while bypassing the broken standalone stack-removal path.
+"""Lower native POP_TOP uses through stable STORE_NAME/DELETE_NAME ops.
+
+The pinned native compiler crashes in the VM's standalone POP_TOP dispatch,
+regardless of whether that handler calls ``pop`` or uses slicing. STORE_NAME's
+stack pop is already exercised successfully throughout the runtime, so emit a
+short-lived internal binding for every discard and immediately delete it. The
+internal name contains characters that cannot occur in a Python identifier,
+preventing collisions with user code.
 """
 from __future__ import annotations
 
@@ -13,31 +13,61 @@
 
 
 PATH = Path("src/portapy/core/frontend.py")
+_EXPECTED_EMISSIONS = 5
+
+_HELPER_ANCHOR = '''        return len(self.instructions) - 1
+
+    def patch(self, offset: int, target: int) -> None:
+'''
+_HELPER_REPLACEMENT = '''        return len(self.instructions) - 1
+
+    def discard_top(self) -> None:
+        discard_name = f"<discard:{len(self.instructions)}>"
+        discard_index = self.name_index(discard_name)
+        self.emit(Op.STORE_NAME, discard_index)
+        self.emit(Op.DELETE_NAME, discard_index)
 
-_OLD = '''            if not self.interactive and not isinstance(node.value, ast.Yield):
-                self.emit(Op.POP_TOP)
+    def patch(self, offset: int, target: int) -> None:
 '''
+_OLD_EMISSION = "self.emit(Op.POP_TOP)"
+_NEW_EMISSION = "self.discard_top()"
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    count = source.count(_OLD)
-    if count != 1:
+
+    anchor_count = source.count(_HELPER_ANCHOR)
+    if anchor_count != 1:
         raise RuntimeError(
-            "native expression POP_TOP normalization expected one emission, "
-            f"found {count}"
+            "native discard helper insertion expected one anchor, "
+            f"found {anchor_count}"
         )
-    source = source.replace(_OLD, "", 1)
+    source = source.replace(_HELPER_ANCHOR, _HELPER_REPLACEMENT, 1)
+
+    emission_count = source.count(_OLD_EMISSION)
+    if emission_count != _EXPECTED_EMISSIONS:
+        raise RuntimeError(
+            "native POP_TOP normalization expected "
+            f"{_EXPECTED_EMISSIONS} emissions, found {emission_count}"
+        )
+    source = source.replace(_OLD_EMISSION, _NEW_EMISSION)
     PATH.write_text(source, encoding="utf-8")
 
-    if _OLD in source:
-        raise RuntimeError("native expression POP_TOP emission remains")
-    marker = '''        if isinstance(node, ast.Expr):
-            self.expr(node.value)
-'''
-    if marker not in source:
-        raise RuntimeError("native expression evaluation was not preserved")
-    print("REMOVED NATIVE EXPRESSION POP_TOP", count)
+    if _OLD_EMISSION in source:
+        raise RuntimeError("native POP_TOP emission remains after normalization")
+    if source.count(_NEW_EMISSION) != _EXPECTED_EMISSIONS:
+        raise RuntimeError("native discard calls were not installed everywhere")
+    required = (
+        "def discard_top(self) -> None:",
+        'discard_name = f"<discard:{len(self.instructions)}>"',
+        "self.emit(Op.STORE_NAME, discard_index)",
+        "self.emit(Op.DELETE_NAME, discard_index)",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native discard helper validation failed: {missing}")
+
+    print("NORMALIZED NATIVE POP_TOP EMISSIONS", emission_count)
     return 0
 
 

From 17a6d0a9ba5c572db3b1cb215ed3905d996ac6d1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 01:52:02 -0500
Subject: [PATCH 211/450] Test stable lowering for all POP_TOP emissions

---
 tests/test_normalize_full_core_pop_top.py | 52 ++++++++++++++++-------
 1 file changed, 37 insertions(+), 15 deletions(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index 2f8adf7b..1ddec491 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -5,18 +5,32 @@
 from tools import normalize_full_core_pop_top as normalizer
 
 
-FRONTEND_SOURCE = '''class Lowerer:
-    def stmt(self, node):
-        if isinstance(node, ast.Expr):
-            self.expr(node.value)
-            if not self.interactive and not isinstance(node.value, ast.Yield):
-                self.emit(Op.POP_TOP)
-        elif isinstance(node, ast.Pass):
-            return
+FRONTEND_SOURCE = '''class _Lowerer:
+    def emit(self, op, arg=0):
+        self.instructions.append(Instruction(op, arg))
+        return len(self.instructions) - 1
+
+    def patch(self, offset: int, target: int) -> None:
+        return
+
+    def first(self):
+        self.emit(Op.POP_TOP)
+
+    def second(self):
+        self.emit(Op.POP_TOP)
+
+    def third(self):
+        self.emit(Op.POP_TOP)
+
+    def fourth(self):
+        self.emit(Op.POP_TOP)
+
+    def fifth(self):
+        self.emit(Op.POP_TOP)
 '''
 
 
-def test_preserves_expression_evaluation_without_pop_top(
+def test_lowers_all_pop_top_emissions_to_internal_bindings(
     tmp_path: Path, monkeypatch
 ) -> None:
     path = tmp_path / "frontend.py"
@@ -26,19 +40,27 @@ def test_preserves_expression_evaluation_without_pop_top(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "self.expr(node.value)" in source
     assert "self.emit(Op.POP_TOP)" not in source
-    assert "elif isinstance(node, ast.Pass):" in source
+    assert source.count("self.discard_top()") == 5
+    assert "def discard_top(self) -> None:" in source
+    assert 'discard_name = f"<discard:{len(self.instructions)}>"' in source
+    assert "self.emit(Op.STORE_NAME, discard_index)" in source
+    assert "self.emit(Op.DELETE_NAME, discard_index)" in source
 
 
-def test_fails_closed_without_unique_emission(tmp_path: Path, monkeypatch) -> None:
+def test_fails_closed_when_emission_count_changes(
+    tmp_path: Path, monkeypatch
+) -> None:
     path = tmp_path / "frontend.py"
-    path.write_text("def stmt():\n    return\n", encoding="utf-8")
+    path.write_text(
+        FRONTEND_SOURCE.replace("        self.emit(Op.POP_TOP)\n", "", 1),
+        encoding="utf-8",
+    )
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "expected one emission" in str(error)
+        assert "expected 5 emissions" in str(error)
     else:
-        raise AssertionError("normalizer accepted a missing POP_TOP emission")
+        raise AssertionError("normalizer accepted an unexpected POP_TOP count")

From 6191c0bed75472fce4f85db32eaa23b079b93ca4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:02:24 -0500
Subject: [PATCH 212/450] Use identifier-safe native discard names

---
 tools/normalize_full_core_pop_top.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index 86d2d28e..f3a43a64 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -3,9 +3,9 @@
 The pinned native compiler crashes in the VM's standalone POP_TOP dispatch,
 regardless of whether that handler calls ``pop`` or uses slicing. STORE_NAME's
 stack pop is already exercised successfully throughout the runtime, so emit a
-short-lived internal binding for every discard and immediately delete it. The
-internal name contains characters that cannot occur in a Python identifier,
-preventing collisions with user code.
+short-lived internal binding for every discard and immediately delete it. Use
+the project's reserved ``__pyinbin_`` namespace because native name storage
+expects identifier-shaped keys.
 """
 from __future__ import annotations
 
@@ -22,7 +22,7 @@ def patch(self, offset: int, target: int) -> None:
 _HELPER_REPLACEMENT = '''        return len(self.instructions) - 1
 
     def discard_top(self) -> None:
-        discard_name = f"<discard:{len(self.instructions)}>"
+        discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"
         discard_index = self.name_index(discard_name)
         self.emit(Op.STORE_NAME, discard_index)
         self.emit(Op.DELETE_NAME, discard_index)
@@ -59,7 +59,7 @@ def main() -> int:
         raise RuntimeError("native discard calls were not installed everywhere")
     required = (
         "def discard_top(self) -> None:",
-        'discard_name = f"<discard:{len(self.instructions)}>"',
+        'discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"',
         "self.emit(Op.STORE_NAME, discard_index)",
         "self.emit(Op.DELETE_NAME, discard_index)",
     )

From 804e82159d461065aaccf45843861196db82ed65 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:02:50 -0500
Subject: [PATCH 213/450] Expect identifier-safe discard names

---
 tests/test_normalize_full_core_pop_top.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index 1ddec491..6c3e98cc 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -43,7 +43,10 @@ def test_lowers_all_pop_top_emissions_to_internal_bindings(
     assert "self.emit(Op.POP_TOP)" not in source
     assert source.count("self.discard_top()") == 5
     assert "def discard_top(self) -> None:" in source
-    assert 'discard_name = f"<discard:{len(self.instructions)}>"' in source
+    assert (
+        'discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"'
+        in source
+    )
     assert "self.emit(Op.STORE_NAME, discard_index)" in source
     assert "self.emit(Op.DELETE_NAME, discard_index)" in source
 

From ac68ee08da6d2e3fc2a8453a454c39815f6961d0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:08:31 -0500
Subject: [PATCH 214/450] Inline native discard bytecode emissions

---
 tools/normalize_full_core_pop_top.py | 67 ++++++++++------------------
 1 file changed, 23 insertions(+), 44 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index f3a43a64..2c8315b8 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -1,11 +1,9 @@
-"""Lower native POP_TOP uses through stable STORE_NAME/DELETE_NAME ops.
+"""Lower native POP_TOP uses through inline STORE_NAME/DELETE_NAME ops.
 
-The pinned native compiler crashes in the VM's standalone POP_TOP dispatch,
-regardless of whether that handler calls ``pop`` or uses slicing. STORE_NAME's
-stack pop is already exercised successfully throughout the runtime, so emit a
-short-lived internal binding for every discard and immediately delete it. Use
-the project's reserved ``__pyinbin_`` namespace because native name storage
-expects identifier-shaped keys.
+The pinned native compiler crashes in the VM's standalone POP_TOP dispatch.
+A helper method that emitted the replacement instructions was also miscompiled
+when the frontend itself ran natively. Inline the two already-stable bytecode
+emissions at every discard site, using PortaPy's reserved internal namespace.
 """
 from __future__ import annotations
 
@@ -15,35 +13,19 @@
 PATH = Path("src/portapy/core/frontend.py")
 _EXPECTED_EMISSIONS = 5
 
-_HELPER_ANCHOR = '''        return len(self.instructions) - 1
-
-    def patch(self, offset: int, target: int) -> None:
-'''
-_HELPER_REPLACEMENT = '''        return len(self.instructions) - 1
-
-    def discard_top(self) -> None:
-        discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"
-        discard_index = self.name_index(discard_name)
-        self.emit(Op.STORE_NAME, discard_index)
-        self.emit(Op.DELETE_NAME, discard_index)
-
-    def patch(self, offset: int, target: int) -> None:
-'''
 _OLD_EMISSION = "self.emit(Op.POP_TOP)"
-_NEW_EMISSION = "self.discard_top()"
+_NEW_EMISSION = '''self.emit(
+                    Op.STORE_NAME,
+                    self.name_index("__pyinbin_internal_discard"),
+                )
+                self.emit(
+                    Op.DELETE_NAME,
+                    self.name_index("__pyinbin_internal_discard"),
+                )'''
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-
-    anchor_count = source.count(_HELPER_ANCHOR)
-    if anchor_count != 1:
-        raise RuntimeError(
-            "native discard helper insertion expected one anchor, "
-            f"found {anchor_count}"
-        )
-    source = source.replace(_HELPER_ANCHOR, _HELPER_REPLACEMENT, 1)
-
     emission_count = source.count(_OLD_EMISSION)
     if emission_count != _EXPECTED_EMISSIONS:
         raise RuntimeError(
@@ -55,19 +37,16 @@ def main() -> int:
 
     if _OLD_EMISSION in source:
         raise RuntimeError("native POP_TOP emission remains after normalization")
-    if source.count(_NEW_EMISSION) != _EXPECTED_EMISSIONS:
-        raise RuntimeError("native discard calls were not installed everywhere")
-    required = (
-        "def discard_top(self) -> None:",
-        'discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"',
-        "self.emit(Op.STORE_NAME, discard_index)",
-        "self.emit(Op.DELETE_NAME, discard_index)",
-    )
-    missing = [marker for marker in required if marker not in source]
-    if missing:
-        raise RuntimeError(f"native discard helper validation failed: {missing}")
-
-    print("NORMALIZED NATIVE POP_TOP EMISSIONS", emission_count)
+    if source.count('self.name_index("__pyinbin_internal_discard")') != (
+        _EXPECTED_EMISSIONS * 2
+    ):
+        raise RuntimeError("native inline discard names were not installed everywhere")
+    if source.count("Op.STORE_NAME,") < _EXPECTED_EMISSIONS:
+        raise RuntimeError("native inline discard stores are missing")
+    if source.count("Op.DELETE_NAME,") < _EXPECTED_EMISSIONS:
+        raise RuntimeError("native inline discard deletes are missing")
+
+    print("NORMALIZED INLINE NATIVE POP_TOP EMISSIONS", emission_count)
     return 0
 
 

From 4b00f133673015f8abc42177cc4e2ad5a8782fb4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:09:08 -0500
Subject: [PATCH 215/450] Preserve indentation for inline discard lowering

---
 tools/normalize_full_core_pop_top.py | 54 ++++++++++++++++++----------
 1 file changed, 35 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_pop_top.py b/tools/normalize_full_core_pop_top.py
index 2c8315b8..a3b8a297 100644
--- a/tools/normalize_full_core_pop_top.py
+++ b/tools/normalize_full_core_pop_top.py
@@ -3,7 +3,8 @@
 The pinned native compiler crashes in the VM's standalone POP_TOP dispatch.
 A helper method that emitted the replacement instructions was also miscompiled
 when the frontend itself ran natively. Inline the two already-stable bytecode
-emissions at every discard site, using PortaPy's reserved internal namespace.
+emissions at every discard site, preserving each site's nesting indentation and
+using PortaPy's reserved internal namespace.
 """
 from __future__ import annotations
 
@@ -12,38 +13,53 @@
 
 PATH = Path("src/portapy/core/frontend.py")
 _EXPECTED_EMISSIONS = 5
-
 _OLD_EMISSION = "self.emit(Op.POP_TOP)"
-_NEW_EMISSION = '''self.emit(
-                    Op.STORE_NAME,
-                    self.name_index("__pyinbin_internal_discard"),
-                )
-                self.emit(
-                    Op.DELETE_NAME,
-                    self.name_index("__pyinbin_internal_discard"),
-                )'''
+_INTERNAL_NAME = "__pyinbin_internal_discard"
+
+
+def _replacement_lines(indent: str) -> list[str]:
+    return [
+        f"{indent}self.emit(",
+        f"{indent}    Op.STORE_NAME,",
+        f'{indent}    self.name_index("{_INTERNAL_NAME}"),',
+        f"{indent})",
+        f"{indent}self.emit(",
+        f"{indent}    Op.DELETE_NAME,",
+        f'{indent}    self.name_index("{_INTERNAL_NAME}"),',
+        f"{indent})",
+    ]
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    emission_count = source.count(_OLD_EMISSION)
+    output: list[str] = []
+    emission_count = 0
+    for line in source.splitlines():
+        if line.strip() != _OLD_EMISSION:
+            output.append(line)
+            continue
+        indent = line[: len(line) - len(line.lstrip())]
+        output.extend(_replacement_lines(indent))
+        emission_count += 1
+
     if emission_count != _EXPECTED_EMISSIONS:
         raise RuntimeError(
             "native POP_TOP normalization expected "
             f"{_EXPECTED_EMISSIONS} emissions, found {emission_count}"
         )
-    source = source.replace(_OLD_EMISSION, _NEW_EMISSION)
-    PATH.write_text(source, encoding="utf-8")
 
-    if _OLD_EMISSION in source:
+    normalized = "\n".join(output) + ("\n" if source.endswith("\n") else "")
+    PATH.write_text(normalized, encoding="utf-8")
+
+    if _OLD_EMISSION in normalized:
         raise RuntimeError("native POP_TOP emission remains after normalization")
-    if source.count('self.name_index("__pyinbin_internal_discard")') != (
-        _EXPECTED_EMISSIONS * 2
-    ):
+    expected_names = _EXPECTED_EMISSIONS * 2
+    marker = f'self.name_index("{_INTERNAL_NAME}")'
+    if normalized.count(marker) != expected_names:
         raise RuntimeError("native inline discard names were not installed everywhere")
-    if source.count("Op.STORE_NAME,") < _EXPECTED_EMISSIONS:
+    if normalized.count("Op.STORE_NAME,") < _EXPECTED_EMISSIONS:
         raise RuntimeError("native inline discard stores are missing")
-    if source.count("Op.DELETE_NAME,") < _EXPECTED_EMISSIONS:
+    if normalized.count("Op.DELETE_NAME,") < _EXPECTED_EMISSIONS:
         raise RuntimeError("native inline discard deletes are missing")
 
     print("NORMALIZED INLINE NATIVE POP_TOP EMISSIONS", emission_count)

From 0bd33b0497135d750a60828ff18cbb3e395d14b8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:09:27 -0500
Subject: [PATCH 216/450] Test inline indentation-safe discard lowering

---
 tests/test_normalize_full_core_pop_top.py | 34 ++++++++++-------------
 1 file changed, 14 insertions(+), 20 deletions(-)

diff --git a/tests/test_normalize_full_core_pop_top.py b/tests/test_normalize_full_core_pop_top.py
index 6c3e98cc..a5564363 100644
--- a/tests/test_normalize_full_core_pop_top.py
+++ b/tests/test_normalize_full_core_pop_top.py
@@ -1,26 +1,23 @@
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 from tools import normalize_full_core_pop_top as normalizer
 
 
 FRONTEND_SOURCE = '''class _Lowerer:
-    def emit(self, op, arg=0):
-        self.instructions.append(Instruction(op, arg))
-        return len(self.instructions) - 1
-
-    def patch(self, offset: int, target: int) -> None:
-        return
-
     def first(self):
         self.emit(Op.POP_TOP)
 
-    def second(self):
-        self.emit(Op.POP_TOP)
+    def second(self, condition):
+        if condition:
+            self.emit(Op.POP_TOP)
 
-    def third(self):
-        self.emit(Op.POP_TOP)
+    def third(self, condition):
+        if condition:
+            if condition:
+                self.emit(Op.POP_TOP)
 
     def fourth(self):
         self.emit(Op.POP_TOP)
@@ -30,7 +27,7 @@ def fifth(self):
 '''
 
 
-def test_lowers_all_pop_top_emissions_to_internal_bindings(
+def test_inlines_all_discard_emissions_with_original_indentation(
     tmp_path: Path, monkeypatch
 ) -> None:
     path = tmp_path / "frontend.py"
@@ -41,14 +38,11 @@ def test_lowers_all_pop_top_emissions_to_internal_bindings(
 
     source = path.read_text(encoding="utf-8")
     assert "self.emit(Op.POP_TOP)" not in source
-    assert source.count("self.discard_top()") == 5
-    assert "def discard_top(self) -> None:" in source
-    assert (
-        'discard_name = f"__pyinbin_internal_discard_{len(self.instructions)}"'
-        in source
-    )
-    assert "self.emit(Op.STORE_NAME, discard_index)" in source
-    assert "self.emit(Op.DELETE_NAME, discard_index)" in source
+    assert "def discard_top" not in source
+    assert source.count('self.name_index("__pyinbin_internal_discard")') == 10
+    assert source.count("Op.STORE_NAME,") == 5
+    assert source.count("Op.DELETE_NAME,") == 5
+    ast.parse(source)
 
 
 def test_fails_closed_when_emission_count_changes(

From d1e783c8a74ba206a6d12914b6e0fbdd6c29e01b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:22:39 -0500
Subject: [PATCH 217/450] Type native parser expression results as objects

---
 ...ize_full_core_native_parser_expressions.py | 119 ++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 tools/normalize_full_core_native_parser_expressions.py

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
new file mode 100644
index 00000000..f4dc93ce
--- /dev/null
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -0,0 +1,119 @@
+"""Preserve opaque AST expression objects in the embedded native parser.
+
+The pinned compiler defaults an unannotated result of ``self._parse_expr()`` to
+an integer inside ``Parser._parse_stmt``. Subsequent ``isinstance`` checks then
+try to treat that integer as an object pointer. Annotate every simple local
+assignment from ``_parse_expr`` in that method as ``object`` before compiling the
+combined parser/runtime module.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+
+
+def _is_parse_expr_call(node: ast.expr) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and isinstance(node.func.value, ast.Name)
+        and node.func.value.id == "self"
+        and node.func.attr == "_parse_expr"
+    )
+
+
+class _AnnotateExpressionResults(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_Assign(self, node: ast.Assign) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            len(node.targets) != 1
+            or not isinstance(node.targets[0], ast.Name)
+            or not _is_parse_expr_call(node.value)
+        ):
+            return node
+        self.count += 1
+        return ast.copy_location(
+            ast.AnnAssign(
+                target=node.targets[0],
+                annotation=ast.Name(id="object", ctx=ast.Load()),
+                value=node.value,
+                simple=1,
+            ),
+            node,
+        )
+
+
+def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
+    parser_class = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.ClassDef) and node.name == "_npr_parser_Parser"
+        ),
+        None,
+    )
+    if parser_class is None:
+        raise RuntimeError("embedded native Parser class is missing")
+    method = next(
+        (
+            node
+            for node in parser_class.body
+            if isinstance(node, ast.FunctionDef) and node.name == "_parse_stmt"
+        ),
+        None,
+    )
+    if method is None:
+        raise RuntimeError("embedded native Parser._parse_stmt is missing")
+    return method
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    method = _parse_stmt_method(module)
+    annotator = _AnnotateExpressionResults()
+    annotator.visit(method)
+    if annotator.count < 1:
+        raise RuntimeError("native Parser._parse_stmt had no expression results to type")
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    verified_method = _parse_stmt_method(verified)
+    remaining = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and isinstance(node.targets[0], ast.Name)
+        and _is_parse_expr_call(node.value)
+    ]
+    if remaining:
+        raise RuntimeError(
+            "native Parser._parse_stmt still contains untyped expression results"
+        )
+    typed = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.annotation, ast.Name)
+        and node.annotation.id == "object"
+        and node.value is not None
+        and _is_parse_expr_call(node.value)
+    ]
+    if len(typed) != annotator.count:
+        raise RuntimeError("native parser expression annotations were not preserved")
+
+    print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 6486ef9f875841208179171e36fc5a3341f4ba8e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:23:23 -0500
Subject: [PATCH 218/450] Type embedded parser expression results

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 070c733a..d1e61e87 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -21,6 +21,9 @@
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
+from tools.normalize_full_core_native_parser_expressions import (
+    main as normalize_native_parser_expressions,
+)
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
@@ -133,6 +136,7 @@ def main() -> int:
     normalize_calls_closures()
     normalize_keyword_calls()
     combine_native_parser()
+    normalize_native_parser_expressions()
     normalize_boolops()
     normalize_closures()
     normalize_pattern_slices()

From d84ee9bae30f9a5822bad86997177513962547f0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:23:44 -0500
Subject: [PATCH 219/450] Test native parser expression result typing

---
 ...ize_full_core_native_parser_expressions.py | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_parser_expressions.py

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
new file mode 100644
index 00000000..1442521a
--- /dev/null
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_native_parser_expressions as normalizer
+
+
+SOURCE = '''class _npr_parser_Parser:
+    def _parse_stmt(self):
+        expr = self._parse_expr()
+        if condition:
+            value = self._parse_expr()
+        other = self._peek()
+        return expr
+
+    def another_method(self):
+        untouched = self._parse_expr()
+        return untouched
+'''
+
+
+def test_types_parse_stmt_expression_results_only(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "expr: object = self._parse_expr()" in source
+    assert "value: object = self._parse_expr()" in source
+    assert "untouched = self._parse_expr()" in source
+    assert "other = self._peek()" in source
+    ast.parse(source)
+
+
+def test_fails_closed_without_parser_method(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text("class Other:\n    pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "Parser class is missing" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing embedded parser")

From 6a0593fcb48df07c3c1286db657c1cd9d6eb84c4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:40:20 -0500
Subject: [PATCH 220/450] Use dict-backed native AST expression locals

---
 ...malize_full_core_native_parser_expressions.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index f4dc93ce..66624351 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -1,10 +1,10 @@
-"""Preserve opaque AST expression objects in the embedded native parser.
+"""Preserve dict-backed AST expressions in the embedded native parser.
 
 The pinned compiler defaults an unannotated result of ``self._parse_expr()`` to
-an integer inside ``Parser._parse_stmt``. Subsequent ``isinstance`` checks then
-try to treat that integer as an object pointer. Annotate every simple local
-assignment from ``_parse_expr`` in that method as ``object`` before compiling the
-combined parser/runtime module.
+an integer inside ``Parser._parse_stmt``. ``object`` annotations also fall back
+to integer storage. Native class instances are dict-backed, and the following
+``isinstance`` checks already dispatch through dict lookups, so annotate every
+simple local assignment from ``_parse_expr`` in that method as ``dict``.
 """
 from __future__ import annotations
 
@@ -41,7 +41,7 @@ def visit_Assign(self, node: ast.Assign) -> ast.AST:
         return ast.copy_location(
             ast.AnnAssign(
                 target=node.targets[0],
-                annotation=ast.Name(id="object", ctx=ast.Load()),
+                annotation=ast.Name(id="dict", ctx=ast.Load()),
                 value=node.value,
                 simple=1,
             ),
@@ -104,14 +104,14 @@ def main() -> int:
         for node in ast.walk(verified_method)
         if isinstance(node, ast.AnnAssign)
         and isinstance(node.annotation, ast.Name)
-        and node.annotation.id == "object"
+        and node.annotation.id == "dict"
         and node.value is not None
         and _is_parse_expr_call(node.value)
     ]
     if len(typed) != annotator.count:
         raise RuntimeError("native parser expression annotations were not preserved")
 
-    print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
+    print("TYPED DICT-BACKED NATIVE PARSER EXPRESSIONS", annotator.count)
     return 0
 
 

From 1fbc7c84cb7a8bbbbf630ad0782e74a8005851ff Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 02:40:49 -0500
Subject: [PATCH 221/450] Expect dict-backed parser expression locals

---
 tests/test_normalize_full_core_native_parser_expressions.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
index 1442521a..f88cc735 100644
--- a/tests/test_normalize_full_core_native_parser_expressions.py
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -28,10 +28,11 @@ def test_types_parse_stmt_expression_results_only(tmp_path: Path, monkeypatch) -
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "expr: object = self._parse_expr()" in source
-    assert "value: object = self._parse_expr()" in source
+    assert "expr: dict = self._parse_expr()" in source
+    assert "value: dict = self._parse_expr()" in source
     assert "untouched = self._parse_expr()" in source
     assert "other = self._peek()" in source
+    assert ": object = self._parse_expr()" not in source
     ast.parse(source)
 
 

From dcd2dce8e213207a88423865545fe54f7567ed3b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:19:55 -0500
Subject: [PATCH 222/450] Fast-path native expression statements before
 assignment checks

---
 ...ize_full_core_native_parser_expressions.py | 57 ++++++++++++++++---
 1 file changed, 49 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index 66624351..270f5716 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -1,10 +1,11 @@
-"""Preserve dict-backed AST expressions in the embedded native parser.
-
-The pinned compiler defaults an unannotated result of ``self._parse_expr()`` to
-an integer inside ``Parser._parse_stmt``. ``object`` annotations also fall back
-to integer storage. Native class instances are dict-backed, and the following
-``isinstance`` checks already dispatch through dict lookups, so annotate every
-simple local assignment from ``_parse_expr`` in that method as ``dict``.
+"""Preserve parsed AST values and fast-path native expression statements.
+
+The pinned compiler cannot safely compile the heterogeneous ``isinstance`` chain
+that follows ``expr = self._parse_expr()`` in the embedded parser: it substitutes
+a static type token for the returned AST object. A newline means the statement is
+unambiguously an expression statement, so return it immediately before reaching
+those assignment-target checks. Remaining expression locals keep an explicit
+``dict`` annotation matching the parser nodes' native dict-backed representation.
 """
 from __future__ import annotations
 
@@ -73,6 +74,30 @@ def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
     return method
 
 
+def _install_expression_statement_fast_path(method: ast.FunctionDef) -> int:
+    replacement: list[ast.stmt] = []
+    inserted = 0
+    for statement in method.body:
+        replacement.append(statement)
+        if not (
+            isinstance(statement, ast.AnnAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.target.id == "expr"
+            and statement.value is not None
+            and _is_parse_expr_call(statement.value)
+        ):
+            continue
+        fast_path = ast.parse(
+            "if self._check('NEWLINE'):\n"
+            "    self._eat()\n"
+            "    return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)\n"
+        ).body[0]
+        replacement.append(ast.copy_location(fast_path, statement))
+        inserted += 1
+    method.body = replacement
+    return inserted
+
+
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     method = _parse_stmt_method(module)
@@ -80,6 +105,12 @@ def main() -> int:
     annotator.visit(method)
     if annotator.count < 1:
         raise RuntimeError("native Parser._parse_stmt had no expression results to type")
+    fast_path_count = _install_expression_statement_fast_path(method)
+    if fast_path_count != 1:
+        raise RuntimeError(
+            "native Parser._parse_stmt expression fast path expected one insertion, "
+            f"found {fast_path_count}"
+        )
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -110,8 +141,18 @@ def main() -> int:
     ]
     if len(typed) != annotator.count:
         raise RuntimeError("native parser expression annotations were not preserved")
+    fast_paths = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_npr_ast_nodes_ExprStmt"
+    ]
+    if len(fast_paths) != 1:
+        raise RuntimeError("native parser expression fast path was not preserved")
 
-    print("TYPED DICT-BACKED NATIVE PARSER EXPRESSIONS", annotator.count)
+    print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
+    print("FAST-PATHED NATIVE EXPRESSION STATEMENTS", fast_path_count)
     return 0
 
 

From 8285e9f3eefea59d3500b4fa60baed208bf5184c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:20:14 -0500
Subject: [PATCH 223/450] Test native expression-statement fast path

---
 ...ize_full_core_native_parser_expressions.py | 32 +++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
index f88cc735..ae92bfc5 100644
--- a/tests/test_normalize_full_core_native_parser_expressions.py
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -8,7 +8,10 @@
 
 SOURCE = '''class _npr_parser_Parser:
     def _parse_stmt(self):
+        pos = self._peek().pos
         expr = self._parse_expr()
+        if isinstance(expr, Name):
+            return expr
         if condition:
             value = self._parse_expr()
         other = self._peek()
@@ -20,7 +23,9 @@ def another_method(self):
 '''
 
 
-def test_types_parse_stmt_expression_results_only(tmp_path: Path, monkeypatch) -> None:
+def test_types_results_and_fast_paths_expression_statements(
+    tmp_path: Path, monkeypatch
+) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
@@ -32,7 +37,12 @@ def test_types_parse_stmt_expression_results_only(tmp_path: Path, monkeypatch) -
     assert "value: dict = self._parse_expr()" in source
     assert "untouched = self._parse_expr()" in source
     assert "other = self._peek()" in source
-    assert ": object = self._parse_expr()" not in source
+    assert "if self._check('NEWLINE'):" in source
+    assert "self._eat()" in source
+    assert "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)" in source
+    assert source.index("if self._check('NEWLINE'):") < source.index(
+        "if isinstance(expr, Name):"
+    )
     ast.parse(source)
 
 
@@ -47,3 +57,21 @@ def test_fails_closed_without_parser_method(tmp_path: Path, monkeypatch) -> None
         assert "Parser class is missing" in str(error)
     else:
         raise AssertionError("normalizer accepted a missing embedded parser")
+
+
+def test_fails_closed_without_main_expr_assignment(
+    tmp_path: Path, monkeypatch
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace("        expr = self._parse_expr()\n", "        expr = 1\n"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "fast path expected one insertion" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing expression fast path")

From 5fa87440d5a30c6efe6c9f98ceb96dacb6b9fc8f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:24:21 -0500
Subject: [PATCH 224/450] Validate native expression fast path
 deterministically

---
 ...rmalize_full_core_native_parser_expressions.py | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index 270f5716..119cc8ee 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -141,15 +141,14 @@ def main() -> int:
     ]
     if len(typed) != annotator.count:
         raise RuntimeError("native parser expression annotations were not preserved")
-    fast_paths = [
-        node
-        for node in ast.walk(verified_method)
-        if isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Name)
-        and node.func.id == "_npr_ast_nodes_ExprStmt"
-    ]
-    if len(fast_paths) != 1:
+
+    method_source = ast.unparse(verified_method)
+    fast_path_marker = "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)"
+    if method_source.count(fast_path_marker) != 1:
         raise RuntimeError("native parser expression fast path was not preserved")
+    assignment_check = "isinstance(expr, _npr_ast_nodes_Name)"
+    if assignment_check in method_source and method_source.index(fast_path_marker) > method_source.index(assignment_check):
+        raise RuntimeError("native expression fast path follows assignment checks")
 
     print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
     print("FAST-PATHED NATIVE EXPRESSION STATEMENTS", fast_path_count)

From ee5b87c6ba96c514fa453cbce05320f6e1676492 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:27:18 -0500
Subject: [PATCH 225/450] Validate the specific expression fast-path branch

---
 ...ize_full_core_native_parser_expressions.py | 39 +++++++++++++++++--
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index 119cc8ee..80493dac 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -26,6 +26,34 @@ def _is_parse_expr_call(node: ast.expr) -> bool:
     )
 
 
+def _is_expr_stmt_call(node: ast.expr | None) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_npr_ast_nodes_ExprStmt"
+    )
+
+
+def _is_newline_fast_path(node: ast.AST) -> bool:
+    if not isinstance(node, ast.If) or not isinstance(node.test, ast.Call):
+        return False
+    function = node.test.func
+    if not (
+        isinstance(function, ast.Attribute)
+        and isinstance(function.value, ast.Name)
+        and function.value.id == "self"
+        and function.attr == "_check"
+        and len(node.test.args) == 1
+        and isinstance(node.test.args[0], ast.Constant)
+        and node.test.args[0].value == "NEWLINE"
+    ):
+        return False
+    return any(
+        isinstance(statement, ast.Return) and _is_expr_stmt_call(statement.value)
+        for statement in node.body
+    )
+
+
 class _AnnotateExpressionResults(ast.NodeTransformer):
     def __init__(self) -> None:
         self.count = 0
@@ -142,12 +170,15 @@ def main() -> int:
     if len(typed) != annotator.count:
         raise RuntimeError("native parser expression annotations were not preserved")
 
+    fast_paths = [node for node in verified_method.body if _is_newline_fast_path(node)]
+    if len(fast_paths) != 1:
+        raise RuntimeError(
+            "native parser expression fast path was not preserved uniquely"
+        )
     method_source = ast.unparse(verified_method)
-    fast_path_marker = "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)"
-    if method_source.count(fast_path_marker) != 1:
-        raise RuntimeError("native parser expression fast path was not preserved")
+    fast_path_source = ast.unparse(fast_paths[0])
     assignment_check = "isinstance(expr, _npr_ast_nodes_Name)"
-    if assignment_check in method_source and method_source.index(fast_path_marker) > method_source.index(assignment_check):
+    if assignment_check in method_source and method_source.index(fast_path_source) > method_source.index(assignment_check):
         raise RuntimeError("native expression fast path follows assignment checks")
 
     print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)

From aed4a4c6b50abc979670969eb3b483e310103dda Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:29:56 -0500
Subject: [PATCH 226/450] Validate expression fast-path ordering structurally

---
 ...ize_full_core_native_parser_expressions.py | 22 ++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index 80493dac..d15d420b 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -175,11 +175,23 @@ def main() -> int:
         raise RuntimeError(
             "native parser expression fast path was not preserved uniquely"
         )
-    method_source = ast.unparse(verified_method)
-    fast_path_source = ast.unparse(fast_paths[0])
-    assignment_check = "isinstance(expr, _npr_ast_nodes_Name)"
-    if assignment_check in method_source and method_source.index(fast_path_source) > method_source.index(assignment_check):
-        raise RuntimeError("native expression fast path follows assignment checks")
+    main_expr_assignments = [
+        node
+        for node in verified_method.body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "expr"
+        and node.value is not None
+        and _is_parse_expr_call(node.value)
+    ]
+    if len(main_expr_assignments) != 1:
+        raise RuntimeError("native parser main expression assignment is not unique")
+    expression_index = verified_method.body.index(main_expr_assignments[0])
+    fast_path_index = verified_method.body.index(fast_paths[0])
+    if fast_path_index != expression_index + 1:
+        raise RuntimeError(
+            "native expression fast path does not immediately follow parsing"
+        )
 
     print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
     print("FAST-PATHED NATIVE EXPRESSION STATEMENTS", fast_path_count)

From 0f54c66d44a5a43f722e122282ab1833d62c5832 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:38:24 -0500
Subject: [PATCH 227/450] Preserve expression AST nodes through ExprStmt fields

---
 ...ize_full_core_native_parser_expressions.py | 61 ++++++++++++++++++-
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index d15d420b..fcc0398d 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -4,8 +4,9 @@
 that follows ``expr = self._parse_expr()`` in the embedded parser: it substitutes
 a static type token for the returned AST object. A newline means the statement is
 unambiguously an expression statement, so return it immediately before reaching
-those assignment-target checks. Remaining expression locals keep an explicit
-``dict`` annotation matching the parser nodes' native dict-backed representation.
+those assignment-target checks. The embedded ``ExprStmt.expr`` dataclass field is
+also typed as ``dict`` so the compiler stores the real dict-backed AST node rather
+than the abstract expression type token.
 """
 from __future__ import annotations
 
@@ -78,7 +79,7 @@ def visit_Assign(self, node: ast.Assign) -> ast.AST:
         )
 
 
-def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
+def _parser_class(module: ast.Module) -> ast.ClassDef:
     parser_class = next(
         (
             node
@@ -89,6 +90,11 @@ def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
     )
     if parser_class is None:
         raise RuntimeError("embedded native Parser class is missing")
+    return parser_class
+
+
+def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
+    parser_class = _parser_class(module)
     method = next(
         (
             node
@@ -102,6 +108,36 @@ def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
     return method
 
 
+def _normalize_expr_stmt_field(module: ast.Module) -> int:
+    classes = [
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "_npr_ast_nodes_ExprStmt"
+    ]
+    if len(classes) != 1:
+        raise RuntimeError(
+            "embedded native ExprStmt class expected one definition, "
+            f"found {len(classes)}"
+        )
+    fields = [
+        node
+        for node in classes[0].body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "expr"
+    ]
+    if len(fields) != 1:
+        raise RuntimeError(
+            "embedded native ExprStmt.expr expected one field, "
+            f"found {len(fields)}"
+        )
+    fields[0].annotation = ast.copy_location(
+        ast.Name(id="dict", ctx=ast.Load()),
+        fields[0].annotation,
+    )
+    return 1
+
+
 def _install_expression_statement_fast_path(method: ast.FunctionDef) -> int:
     replacement: list[ast.stmt] = []
     inserted = 0
@@ -128,6 +164,7 @@ def _install_expression_statement_fast_path(method: ast.FunctionDef) -> int:
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
+    expr_stmt_field_count = _normalize_expr_stmt_field(module)
     method = _parse_stmt_method(module)
     annotator = _AnnotateExpressionResults()
     annotator.visit(method)
@@ -170,6 +207,23 @@ def main() -> int:
     if len(typed) != annotator.count:
         raise RuntimeError("native parser expression annotations were not preserved")
 
+    expr_stmt_class = next(
+        node
+        for node in verified.body
+        if isinstance(node, ast.ClassDef) and node.name == "_npr_ast_nodes_ExprStmt"
+    )
+    expr_fields = [
+        node
+        for node in expr_stmt_class.body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "expr"
+        and isinstance(node.annotation, ast.Name)
+        and node.annotation.id == "dict"
+    ]
+    if len(expr_fields) != expr_stmt_field_count:
+        raise RuntimeError("native ExprStmt.expr dict annotation was not preserved")
+
     fast_paths = [node for node in verified_method.body if _is_newline_fast_path(node)]
     if len(fast_paths) != 1:
         raise RuntimeError(
@@ -193,6 +247,7 @@ def main() -> int:
             "native expression fast path does not immediately follow parsing"
         )
 
+    print("TYPED NATIVE EXPRSTMT FIELD", expr_stmt_field_count)
     print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
     print("FAST-PATHED NATIVE EXPRESSION STATEMENTS", fast_path_count)
     return 0

From 8d100730b0ecc34c19951976abde27b6279284d7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:38:50 -0500
Subject: [PATCH 228/450] Test ExprStmt field normalization

---
 ...ize_full_core_native_parser_expressions.py | 31 +++++++++++++++++--
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
index ae92bfc5..c9390996 100644
--- a/tests/test_normalize_full_core_native_parser_expressions.py
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -6,7 +6,11 @@
 from tools import normalize_full_core_native_parser_expressions as normalizer
 
 
-SOURCE = '''class _npr_parser_Parser:
+SOURCE = '''class _npr_ast_nodes_ExprStmt:
+    expr: "Expr"
+    pos: object
+
+class _npr_parser_Parser:
     def _parse_stmt(self):
         pos = self._peek().pos
         expr = self._parse_expr()
@@ -23,7 +27,7 @@ def another_method(self):
 '''
 
 
-def test_types_results_and_fast_paths_expression_statements(
+def test_types_results_field_and_fast_paths_expression_statements(
     tmp_path: Path, monkeypatch
 ) -> None:
     path = tmp_path / "native_ast.py"
@@ -33,6 +37,8 @@ def test_types_results_and_fast_paths_expression_statements(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
+    assert "class _npr_ast_nodes_ExprStmt:" in source
+    assert "expr: dict" in source
     assert "expr: dict = self._parse_expr()" in source
     assert "value: dict = self._parse_expr()" in source
     assert "untouched = self._parse_expr()" in source
@@ -48,7 +54,10 @@ def test_types_results_and_fast_paths_expression_statements(
 
 def test_fails_closed_without_parser_method(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"
-    path.write_text("class Other:\n    pass\n", encoding="utf-8")
+    path.write_text(
+        'class _npr_ast_nodes_ExprStmt:\n    expr: "Expr"\n',
+        encoding="utf-8",
+    )
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
@@ -59,6 +68,22 @@ def test_fails_closed_without_parser_method(tmp_path: Path, monkeypatch) -> None
         raise AssertionError("normalizer accepted a missing embedded parser")
 
 
+def test_fails_closed_without_expr_stmt_field(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace('    expr: "Expr"\n', "    value: object\n"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "ExprStmt.expr expected one field" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing ExprStmt.expr field")
+
+
 def test_fails_closed_without_main_expr_assignment(
     tmp_path: Path, monkeypatch
 ) -> None:

From 77e633308ccee9ce8f8a4a914ec3736ac687c7e4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:45:09 -0500
Subject: [PATCH 229/450] Pass expression AST nodes positionally

---
 ...ormalize_full_core_native_parser_expressions.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index fcc0398d..94060967 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -5,8 +5,8 @@
 a static type token for the returned AST object. A newline means the statement is
 unambiguously an expression statement, so return it immediately before reaching
 those assignment-target checks. The embedded ``ExprStmt.expr`` dataclass field is
-also typed as ``dict`` so the compiler stores the real dict-backed AST node rather
-than the abstract expression type token.
+also typed as ``dict`` and constructed positionally so the compiler forwards the
+real dict-backed AST node rather than a keyword argument's static type token.
 """
 from __future__ import annotations
 
@@ -154,7 +154,7 @@ def _install_expression_statement_fast_path(method: ast.FunctionDef) -> int:
         fast_path = ast.parse(
             "if self._check('NEWLINE'):\n"
             "    self._eat()\n"
-            "    return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)\n"
+            "    return _npr_ast_nodes_ExprStmt(expr, pos)\n"
         ).body[0]
         replacement.append(ast.copy_location(fast_path, statement))
         inserted += 1
@@ -229,6 +229,14 @@ def main() -> int:
         raise RuntimeError(
             "native parser expression fast path was not preserved uniquely"
         )
+    fast_return = next(
+        statement
+        for statement in fast_paths[0].body
+        if isinstance(statement, ast.Return) and _is_expr_stmt_call(statement.value)
+    )
+    assert isinstance(fast_return.value, ast.Call)
+    if fast_return.value.keywords or len(fast_return.value.args) != 2:
+        raise RuntimeError("native expression fast path is not positional")
     main_expr_assignments = [
         node
         for node in verified_method.body

From d525d5db1d360ffdaa653c6fbc20d2d9bf52acd5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:45:30 -0500
Subject: [PATCH 230/450] Require positional ExprStmt fast path

---
 tests/test_normalize_full_core_native_parser_expressions.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
index c9390996..209f9ff9 100644
--- a/tests/test_normalize_full_core_native_parser_expressions.py
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -45,7 +45,8 @@ def test_types_results_field_and_fast_paths_expression_statements(
     assert "other = self._peek()" in source
     assert "if self._check('NEWLINE'):" in source
     assert "self._eat()" in source
-    assert "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)" in source
+    assert "return _npr_ast_nodes_ExprStmt(expr, pos)" in source
+    assert "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)" not in source
     assert source.index("if self._check('NEWLINE'):") < source.index(
         "if isinstance(expr, Name):"
     )

From e969c78d8d6063e03c9a5bb035ab4d8d36e97b7f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:54:33 -0500
Subject: [PATCH 231/450] Box native expression AST results before construction

---
 ...ize_full_core_native_parser_expressions.py | 108 +++++++++++-------
 1 file changed, 64 insertions(+), 44 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_expressions.py b/tools/normalize_full_core_native_parser_expressions.py
index 94060967..6d2e7693 100644
--- a/tools/normalize_full_core_native_parser_expressions.py
+++ b/tools/normalize_full_core_native_parser_expressions.py
@@ -1,12 +1,12 @@
 """Preserve parsed AST values and fast-path native expression statements.
 
 The pinned compiler cannot safely compile the heterogeneous ``isinstance`` chain
-that follows ``expr = self._parse_expr()`` in the embedded parser: it substitutes
-a static type token for the returned AST object. A newline means the statement is
-unambiguously an expression statement, so return it immediately before reaching
-those assignment-target checks. The embedded ``ExprStmt.expr`` dataclass field is
-also typed as ``dict`` and constructed positionally so the compiler forwards the
-real dict-backed AST node rather than a keyword argument's static type token.
+that follows ``expr = self._parse_expr()`` in the embedded parser. It also lowers
+a direct reference to that opaque local into the static dict type token ``0x7e``.
+Box the returned node directly in a typed one-item list, fast-path newline-terminated
+expression statements with a runtime ``box[0]`` load, then restore ``expr`` only
+for the remaining assignment-target parsing. ``ExprStmt.expr`` is typed as ``dict``
+to match the parser nodes' native dict-backed representation.
 """
 from __future__ import annotations
 
@@ -15,6 +15,7 @@
 
 
 PATH = Path("src/portapy/core/native_ast.py")
+_EXPR_BOX_NAME = "__pyinbin_native_expr_values"
 
 
 def _is_parse_expr_call(node: ast.expr) -> bool:
@@ -35,6 +36,16 @@ def _is_expr_stmt_call(node: ast.expr | None) -> bool:
     )
 
 
+def _is_box_subscript(node: ast.expr | None) -> bool:
+    return (
+        isinstance(node, ast.Subscript)
+        and isinstance(node.value, ast.Name)
+        and node.value.id == _EXPR_BOX_NAME
+        and isinstance(node.slice, ast.Constant)
+        and node.slice.value == 0
+    )
+
+
 def _is_newline_fast_path(node: ast.AST) -> bool:
     if not isinstance(node, ast.If) or not isinstance(node.test, ast.Call):
         return False
@@ -55,7 +66,7 @@ def _is_newline_fast_path(node: ast.AST) -> bool:
     )
 
 
-class _AnnotateExpressionResults(ast.NodeTransformer):
+class _AnnotateRemainingExpressionResults(ast.NodeTransformer):
     def __init__(self) -> None:
         self.count = 0
 
@@ -142,21 +153,23 @@ def _install_expression_statement_fast_path(method: ast.FunctionDef) -> int:
     replacement: list[ast.stmt] = []
     inserted = 0
     for statement in method.body:
-        replacement.append(statement)
         if not (
-            isinstance(statement, ast.AnnAssign)
-            and isinstance(statement.target, ast.Name)
-            and statement.target.id == "expr"
-            and statement.value is not None
+            isinstance(statement, ast.Assign)
+            and len(statement.targets) == 1
+            and isinstance(statement.targets[0], ast.Name)
+            and statement.targets[0].id == "expr"
             and _is_parse_expr_call(statement.value)
         ):
+            replacement.append(statement)
             continue
-        fast_path = ast.parse(
+        block = ast.parse(
+            f"{_EXPR_BOX_NAME}: list[dict] = [self._parse_expr()]\n"
             "if self._check('NEWLINE'):\n"
             "    self._eat()\n"
-            "    return _npr_ast_nodes_ExprStmt(expr, pos)\n"
-        ).body[0]
-        replacement.append(ast.copy_location(fast_path, statement))
+            f"    return _npr_ast_nodes_ExprStmt({_EXPR_BOX_NAME}[0], pos)\n"
+            f"expr: dict = {_EXPR_BOX_NAME}[0]\n"
+        ).body
+        replacement.extend(ast.copy_location(item, statement) for item in block)
         inserted += 1
     method.body = replacement
     return inserted
@@ -166,16 +179,14 @@ def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     expr_stmt_field_count = _normalize_expr_stmt_field(module)
     method = _parse_stmt_method(module)
-    annotator = _AnnotateExpressionResults()
-    annotator.visit(method)
-    if annotator.count < 1:
-        raise RuntimeError("native Parser._parse_stmt had no expression results to type")
     fast_path_count = _install_expression_statement_fast_path(method)
     if fast_path_count != 1:
         raise RuntimeError(
             "native Parser._parse_stmt expression fast path expected one insertion, "
             f"found {fast_path_count}"
         )
+    annotator = _AnnotateRemainingExpressionResults()
+    annotator.visit(method)
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -224,40 +235,49 @@ def main() -> int:
     if len(expr_fields) != expr_stmt_field_count:
         raise RuntimeError("native ExprStmt.expr dict annotation was not preserved")
 
+    boxes = [
+        node
+        for node in verified_method.body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == _EXPR_BOX_NAME
+        and isinstance(node.value, ast.List)
+        and len(node.value.elts) == 1
+        and _is_parse_expr_call(node.value.elts[0])
+    ]
     fast_paths = [node for node in verified_method.body if _is_newline_fast_path(node)]
-    if len(fast_paths) != 1:
-        raise RuntimeError(
-            "native parser expression fast path was not preserved uniquely"
-        )
-    fast_return = next(
-        statement
-        for statement in fast_paths[0].body
-        if isinstance(statement, ast.Return) and _is_expr_stmt_call(statement.value)
-    )
-    assert isinstance(fast_return.value, ast.Call)
-    if fast_return.value.keywords or len(fast_return.value.args) != 2:
-        raise RuntimeError("native expression fast path is not positional")
-    main_expr_assignments = [
+    restored = [
         node
         for node in verified_method.body
         if isinstance(node, ast.AnnAssign)
         and isinstance(node.target, ast.Name)
         and node.target.id == "expr"
-        and node.value is not None
-        and _is_parse_expr_call(node.value)
+        and _is_box_subscript(node.value)
     ]
-    if len(main_expr_assignments) != 1:
-        raise RuntimeError("native parser main expression assignment is not unique")
-    expression_index = verified_method.body.index(main_expr_assignments[0])
+    if len(boxes) != 1 or len(fast_paths) != 1 or len(restored) != 1:
+        raise RuntimeError("native expression box sequence was not preserved uniquely")
+    box_index = verified_method.body.index(boxes[0])
     fast_path_index = verified_method.body.index(fast_paths[0])
-    if fast_path_index != expression_index + 1:
-        raise RuntimeError(
-            "native expression fast path does not immediately follow parsing"
-        )
+    restored_index = verified_method.body.index(restored[0])
+    if (fast_path_index, restored_index) != (box_index + 1, box_index + 2):
+        raise RuntimeError("native expression box sequence is not contiguous")
+
+    fast_return = next(
+        statement
+        for statement in fast_paths[0].body
+        if isinstance(statement, ast.Return) and _is_expr_stmt_call(statement.value)
+    )
+    assert isinstance(fast_return.value, ast.Call)
+    if (
+        fast_return.value.keywords
+        or len(fast_return.value.args) != 2
+        or not _is_box_subscript(fast_return.value.args[0])
+    ):
+        raise RuntimeError("native expression fast path does not load the boxed node")
 
     print("TYPED NATIVE EXPRSTMT FIELD", expr_stmt_field_count)
-    print("TYPED NATIVE PARSER EXPRESSION RESULTS", annotator.count)
-    print("FAST-PATHED NATIVE EXPRESSION STATEMENTS", fast_path_count)
+    print("BOXED NATIVE PARSER EXPRESSION RESULT", fast_path_count)
+    print("TYPED REMAINING PARSER EXPRESSION RESULTS", annotator.count)
     return 0
 
 

From 63439923de3a9441a83b85f415564348ad856a61 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 06:55:00 -0500
Subject: [PATCH 232/450] Test boxed native expression fast path

---
 ...t_normalize_full_core_native_parser_expressions.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_core_native_parser_expressions.py b/tests/test_normalize_full_core_native_parser_expressions.py
index 209f9ff9..dcfcfcfd 100644
--- a/tests/test_normalize_full_core_native_parser_expressions.py
+++ b/tests/test_normalize_full_core_native_parser_expressions.py
@@ -27,7 +27,7 @@ def another_method(self):
 '''
 
 
-def test_types_results_field_and_fast_paths_expression_statements(
+def test_boxes_results_field_and_fast_paths_expression_statements(
     tmp_path: Path, monkeypatch
 ) -> None:
     path = tmp_path / "native_ast.py"
@@ -39,14 +39,17 @@ def test_types_results_field_and_fast_paths_expression_statements(
     source = path.read_text(encoding="utf-8")
     assert "class _npr_ast_nodes_ExprStmt:" in source
     assert "expr: dict" in source
-    assert "expr: dict = self._parse_expr()" in source
+    assert (
+        "__pyinbin_native_expr_values: list[dict] = [self._parse_expr()]"
+        in source
+    )
+    assert "return _npr_ast_nodes_ExprStmt(__pyinbin_native_expr_values[0], pos)" in source
+    assert "expr: dict = __pyinbin_native_expr_values[0]" in source
     assert "value: dict = self._parse_expr()" in source
     assert "untouched = self._parse_expr()" in source
     assert "other = self._peek()" in source
     assert "if self._check('NEWLINE'):" in source
     assert "self._eat()" in source
-    assert "return _npr_ast_nodes_ExprStmt(expr, pos)" in source
-    assert "return _npr_ast_nodes_ExprStmt(expr=expr, pos=pos)" not in source
     assert source.index("if self._check('NEWLINE'):") < source.index(
         "if isinstance(expr, Name):"
     )

From 1ef2e8d23b62626b1a3585a865cf34cea22c18dd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:01:34 -0500
Subject: [PATCH 233/450] Install compiler-safe ExprStmt initializer

---
 ...rmalize_full_core_expr_stmt_initializer.py | 136 ++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 tools/normalize_full_core_expr_stmt_initializer.py

diff --git a/tools/normalize_full_core_expr_stmt_initializer.py b/tools/normalize_full_core_expr_stmt_initializer.py
new file mode 100644
index 00000000..64ec8e52
--- /dev/null
+++ b/tools/normalize_full_core_expr_stmt_initializer.py
@@ -0,0 +1,136 @@
+"""Install a compiler-safe initializer for the embedded native ExprStmt node.
+
+The pinned compiler's synthesized dataclass initializer stores the static ``dict``
+type token (0x7e) into ``ExprStmt.expr`` instead of the constructor argument. An
+explicit initializer boxes both dict-backed parameters in a typed list and copies
+runtime element loads into the instance fields, bypassing that synthesis bug.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_CLASS_NAME = "_npr_ast_nodes_ExprStmt"
+
+
+def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
+    classes = [
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
+    ]
+    if len(classes) != 1:
+        raise RuntimeError(
+            f"embedded native ExprStmt expected one class, found {len(classes)}"
+        )
+    return classes[0]
+
+
+def _install_initializer(class_node: ast.ClassDef) -> int:
+    existing = [
+        node
+        for node in class_node.body
+        if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+    ]
+    if existing:
+        raise RuntimeError(
+            "embedded native ExprStmt unexpectedly already has an initializer"
+        )
+
+    initializer = ast.parse(
+        "def __init__(self, expr: dict, pos: dict) -> None:\n"
+        "    values: list[dict] = [expr, pos]\n"
+        "    self.expr = values[0]\n"
+        "    self.pos = values[1]\n"
+    ).body[0]
+    class_node.body.append(initializer)
+    return 1
+
+
+def _is_self_field_assignment(
+    node: ast.stmt,
+    field: str,
+    index: int,
+) -> bool:
+    if not (
+        isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and isinstance(node.targets[0], ast.Attribute)
+        and isinstance(node.targets[0].value, ast.Name)
+        and node.targets[0].value.id == "self"
+        and node.targets[0].attr == field
+        and isinstance(node.value, ast.Subscript)
+        and isinstance(node.value.value, ast.Name)
+        and node.value.value.id == "values"
+        and isinstance(node.value.slice, ast.Constant)
+        and node.value.slice.value == index
+    ):
+        return False
+    return True
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    class_node = _expr_stmt_class(module)
+    installed = _install_initializer(class_node)
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    verified_class = _expr_stmt_class(verified)
+    initializers = [
+        node
+        for node in verified_class.body
+        if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+    ]
+    if len(initializers) != installed:
+        raise RuntimeError("native ExprStmt initializer was not preserved uniquely")
+
+    initializer = initializers[0]
+    parameter_names = [argument.arg for argument in initializer.args.args]
+    if parameter_names != ["self", "expr", "pos"]:
+        raise RuntimeError(
+            f"native ExprStmt initializer parameters changed: {parameter_names}"
+        )
+    expr_annotation = initializer.args.args[1].annotation
+    pos_annotation = initializer.args.args[2].annotation
+    if not (
+        isinstance(expr_annotation, ast.Name)
+        and expr_annotation.id == "dict"
+        and isinstance(pos_annotation, ast.Name)
+        and pos_annotation.id == "dict"
+    ):
+        raise RuntimeError("native ExprStmt initializer lost dict parameter types")
+
+    boxes = [
+        node
+        for node in initializer.body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "values"
+        and isinstance(node.value, ast.List)
+        and len(node.value.elts) == 2
+        and all(isinstance(value, ast.Name) for value in node.value.elts)
+        and [value.id for value in node.value.elts] == ["expr", "pos"]
+    ]
+    if len(boxes) != 1:
+        raise RuntimeError("native ExprStmt initializer parameter box is missing")
+    if not any(
+        _is_self_field_assignment(node, "expr", 0) for node in initializer.body
+    ):
+        raise RuntimeError("native ExprStmt initializer does not copy expr")
+    if not any(
+        _is_self_field_assignment(node, "pos", 1) for node in initializer.body
+    ):
+        raise RuntimeError("native ExprStmt initializer does not copy pos")
+
+    print("INSTALLED NATIVE EXPRSTMT INITIALIZER", installed)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 8ba3b607ffe37a91d9dd634daf8b743875e981a1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:02:09 -0500
Subject: [PATCH 234/450] Run compiler-safe ExprStmt initializer normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index d1e61e87..5d0c0606 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -12,6 +12,9 @@
 )
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
+from tools.normalize_full_core_expr_stmt_initializer import (
+    main as normalize_expr_stmt_initializer,
+)
 from tools.normalize_full_core_extended_semantics_compat import (
     main as normalize_extended_semantics,
 )
@@ -137,6 +140,7 @@ def main() -> int:
     normalize_keyword_calls()
     combine_native_parser()
     normalize_native_parser_expressions()
+    normalize_expr_stmt_initializer()
     normalize_boolops()
     normalize_closures()
     normalize_pattern_slices()

From ec9ed23b69376224acf27c9aa3ca7ac2611ac908 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:02:28 -0500
Subject: [PATCH 235/450] Test compiler-safe ExprStmt initializer

---
 ...rmalize_full_core_expr_stmt_initializer.py | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 tests/test_normalize_full_core_expr_stmt_initializer.py

diff --git a/tests/test_normalize_full_core_expr_stmt_initializer.py b/tests/test_normalize_full_core_expr_stmt_initializer.py
new file mode 100644
index 00000000..6552e292
--- /dev/null
+++ b/tests/test_normalize_full_core_expr_stmt_initializer.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_expr_stmt_initializer as normalizer
+
+
+SOURCE = '''@dataclass
+class _npr_ast_nodes_ExprStmt:
+    expr: dict
+    pos: object
+
+class Other:
+    pass
+'''
+
+
+def test_installs_boxed_explicit_initializer(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "def __init__(self, expr: dict, pos: dict) -> None:" in source
+    assert "values: list[dict] = [expr, pos]" in source
+    assert "self.expr = values[0]" in source
+    assert "self.pos = values[1]" in source
+    ast.parse(source)
+
+
+def test_fails_closed_without_expr_stmt_class(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text("class Other:\n    pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "expected one class" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing ExprStmt class")
+
+
+def test_fails_closed_with_existing_initializer(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace(
+            "    pos: object\n",
+            "    pos: object\n\n    def __init__(self):\n        pass\n",
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "already has an initializer" in str(error)
+    else:
+        raise AssertionError("normalizer replaced an existing initializer")

From d954031f2c3afea22a4b62098b22e0fe42372c02 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:04:59 -0500
Subject: [PATCH 236/450] Use direct ExprStmt initializer assignments

---
 ...rmalize_full_core_expr_stmt_initializer.py | 43 ++++++-------------
 1 file changed, 13 insertions(+), 30 deletions(-)

diff --git a/tools/normalize_full_core_expr_stmt_initializer.py b/tools/normalize_full_core_expr_stmt_initializer.py
index 64ec8e52..7658b7ff 100644
--- a/tools/normalize_full_core_expr_stmt_initializer.py
+++ b/tools/normalize_full_core_expr_stmt_initializer.py
@@ -2,8 +2,8 @@
 
 The pinned compiler's synthesized dataclass initializer stores the static ``dict``
 type token (0x7e) into ``ExprStmt.expr`` instead of the constructor argument. An
-explicit initializer boxes both dict-backed parameters in a typed list and copies
-runtime element loads into the instance fields, bypassing that synthesis bug.
+explicit initializer keeps ordinary parameter slots and copies their runtime values
+directly into the instance fields, bypassing dataclass synthesis entirely.
 """
 from __future__ import annotations
 
@@ -41,9 +41,8 @@ def _install_initializer(class_node: ast.ClassDef) -> int:
 
     initializer = ast.parse(
         "def __init__(self, expr: dict, pos: dict) -> None:\n"
-        "    values: list[dict] = [expr, pos]\n"
-        "    self.expr = values[0]\n"
-        "    self.pos = values[1]\n"
+        "    self.expr = expr\n"
+        "    self.pos = pos\n"
     ).body[0]
     class_node.body.append(initializer)
     return 1
@@ -52,23 +51,18 @@ def _install_initializer(class_node: ast.ClassDef) -> int:
 def _is_self_field_assignment(
     node: ast.stmt,
     field: str,
-    index: int,
+    source_name: str,
 ) -> bool:
-    if not (
+    return (
         isinstance(node, ast.Assign)
         and len(node.targets) == 1
         and isinstance(node.targets[0], ast.Attribute)
         and isinstance(node.targets[0].value, ast.Name)
         and node.targets[0].value.id == "self"
         and node.targets[0].attr == field
-        and isinstance(node.value, ast.Subscript)
-        and isinstance(node.value.value, ast.Name)
-        and node.value.value.id == "values"
-        and isinstance(node.value.slice, ast.Constant)
-        and node.value.slice.value == index
-    ):
-        return False
-    return True
+        and isinstance(node.value, ast.Name)
+        and node.value.id == source_name
+    )
 
 
 def main() -> int:
@@ -106,25 +100,14 @@ def main() -> int:
     ):
         raise RuntimeError("native ExprStmt initializer lost dict parameter types")
 
-    boxes = [
-        node
-        for node in initializer.body
-        if isinstance(node, ast.AnnAssign)
-        and isinstance(node.target, ast.Name)
-        and node.target.id == "values"
-        and isinstance(node.value, ast.List)
-        and len(node.value.elts) == 2
-        and all(isinstance(value, ast.Name) for value in node.value.elts)
-        and [value.id for value in node.value.elts] == ["expr", "pos"]
-    ]
-    if len(boxes) != 1:
-        raise RuntimeError("native ExprStmt initializer parameter box is missing")
     if not any(
-        _is_self_field_assignment(node, "expr", 0) for node in initializer.body
+        _is_self_field_assignment(node, "expr", "expr")
+        for node in initializer.body
     ):
         raise RuntimeError("native ExprStmt initializer does not copy expr")
     if not any(
-        _is_self_field_assignment(node, "pos", 1) for node in initializer.body
+        _is_self_field_assignment(node, "pos", "pos")
+        for node in initializer.body
     ):
         raise RuntimeError("native ExprStmt initializer does not copy pos")
 

From 1e64c2b3f31ee7359e3d264e88139ff4e861607f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:05:25 -0500
Subject: [PATCH 237/450] Test direct ExprStmt initializer assignments

---
 tests/test_normalize_full_core_expr_stmt_initializer.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_core_expr_stmt_initializer.py b/tests/test_normalize_full_core_expr_stmt_initializer.py
index 6552e292..720cf543 100644
--- a/tests/test_normalize_full_core_expr_stmt_initializer.py
+++ b/tests/test_normalize_full_core_expr_stmt_initializer.py
@@ -16,7 +16,7 @@ class Other:
 '''
 
 
-def test_installs_boxed_explicit_initializer(tmp_path: Path, monkeypatch) -> None:
+def test_installs_direct_explicit_initializer(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
@@ -25,9 +25,9 @@ def test_installs_boxed_explicit_initializer(tmp_path: Path, monkeypatch) -> Non
 
     source = path.read_text(encoding="utf-8")
     assert "def __init__(self, expr: dict, pos: dict) -> None:" in source
-    assert "values: list[dict] = [expr, pos]" in source
-    assert "self.expr = values[0]" in source
-    assert "self.pos = values[1]" in source
+    assert "self.expr = expr" in source
+    assert "self.pos = pos" in source
+    assert "values: list[dict]" not in source
     ast.parse(source)
 
 

From c2c108c63e1695e1000ee845b2ff6258e3801e17 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:12:14 -0500
Subject: [PATCH 238/450] Fix ExprStmt initializer assembly parameter load

---
 .../normalize_full_core_expr_stmt_assembly.py | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 tools/normalize_full_core_expr_stmt_assembly.py

diff --git a/tools/normalize_full_core_expr_stmt_assembly.py b/tools/normalize_full_core_expr_stmt_assembly.py
new file mode 100644
index 00000000..5ef2fa44
--- /dev/null
+++ b/tools/normalize_full_core_expr_stmt_assembly.py
@@ -0,0 +1,54 @@
+"""Repair the pinned compiler's ExprStmt initializer parameter load.
+
+The source-level explicit initializer is compiled consistently on Linux and Windows,
+but asmpython replaces the dict-typed ``expr`` parameter with its static type token
+(126 / 0x7e). The real parameter is already spilled at ``[rbp-16]`` on both ABIs,
+so replace only the one bad load inside the uniquely named initializer block.
+"""
+from __future__ import annotations
+
+
+_FUNCTION = "_npr_ast_nodes_ExprStmt____init__"
+_BAD_LOAD = "    mov rax, 126"
+_GOOD_LOAD = "    mov rax, [rbp-16]"
+
+
+def fix_expr_stmt_initializer_assembly(
+    source: str,
+    *,
+    target: str,
+) -> tuple[str, int]:
+    if target not in {"linux", "windows"}:
+        raise ValueError(f"unsupported ExprStmt assembly target: {target}")
+
+    start_marker = f"{_FUNCTION}:\n"
+    start = source.find(start_marker)
+    if start < 0:
+        raise RuntimeError("native ExprStmt initializer assembly label is missing")
+    next_function = source.find("\n_npr_ast_nodes_Pass____init__:\n", start)
+    if next_function < 0:
+        raise RuntimeError("native ExprStmt initializer assembly boundary is missing")
+
+    block = source[start:next_function]
+    expected_spills = (
+        ("    mov [rbp-8], rdi", "    mov [rbp-16], rsi", "    mov [rbp-24], rdx")
+        if target == "linux"
+        else ("    mov [rbp-8], rcx", "    mov [rbp-16], rdx", "    mov [rbp-24], r8")
+    )
+    missing = [spill for spill in expected_spills if spill not in block]
+    if missing:
+        raise RuntimeError(
+            f"native ExprStmt initializer parameter spills changed: {missing}"
+        )
+
+    count = block.count(_BAD_LOAD)
+    if count != 1:
+        raise RuntimeError(
+            "native ExprStmt initializer expected one static dict-token load, "
+            f"found {count}"
+        )
+    fixed_block = block.replace(_BAD_LOAD, _GOOD_LOAD, 1)
+    if _BAD_LOAD in fixed_block or fixed_block.count(_GOOD_LOAD) < 1:
+        raise RuntimeError("native ExprStmt initializer assembly repair failed")
+
+    return source[:start] + fixed_block + source[next_function:], count

From 6c45c9a2aa3ae8bcb29942c540881b78319d82c7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:12:51 -0500
Subject: [PATCH 239/450] Repair ExprStmt parameter load in generated assembly

---
 tools/build_native_full_runtime.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/tools/build_native_full_runtime.py b/tools/build_native_full_runtime.py
index c3f872e4..b3f3c586 100644
--- a/tools/build_native_full_runtime.py
+++ b/tools/build_native_full_runtime.py
@@ -19,6 +19,9 @@
 from tools.elf_runtime_abi import fix_linux_runtime_abi
 from tools.nasm_direct_float_abi import append_direct_float_abi
 from tools.native_surface import public_exports
+from tools.normalize_full_core_expr_stmt_assembly import (
+    fix_expr_stmt_initializer_assembly,
+)
 from tools.normalize_full_core_validation import main as normalize_full_runtime
 from tools.python_surface import PYTHON_MODULE_EXPORTS
 
@@ -101,8 +104,15 @@ def transform(
         finally:
             base_build.append_float_abi = original_float
 
+        source = assembly.read_text(encoding="utf-8")
+        source, expr_stmt_count = fix_expr_stmt_initializer_assembly(
+            source,
+            target=target,
+        )
+        assembly.write_text(source, encoding="utf-8")
+        print("FIXED NATIVE EXPRSTMT PARAMETER LOAD", expr_stmt_count)
+
         if target == "linux":
-            source = assembly.read_text(encoding="utf-8")
             marker = "section .rodata"
             count = source.count(marker)
             if count < 1:

From 7e384c2fa582551b0fecd77eddc02211e4b02e5f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:13:12 -0500
Subject: [PATCH 240/450] Test ExprStmt assembly parameter repair

---
 ..._normalize_full_core_expr_stmt_assembly.py | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 tests/test_normalize_full_core_expr_stmt_assembly.py

diff --git a/tests/test_normalize_full_core_expr_stmt_assembly.py b/tests/test_normalize_full_core_expr_stmt_assembly.py
new file mode 100644
index 00000000..3fc081fe
--- /dev/null
+++ b/tests/test_normalize_full_core_expr_stmt_assembly.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from tools.normalize_full_core_expr_stmt_assembly import (
+    fix_expr_stmt_initializer_assembly,
+)
+
+
+LINUX = '''_npr_ast_nodes_ExprStmt____init__:
+    push rbp
+    mov rbp, rsp
+    mov [rbp-8], rdi
+    mov [rbp-16], rsi
+    mov [rbp-24], rdx
+    mov rax, 126
+    push rax
+    ret
+_npr_ast_nodes_Pass____init__:
+    ret
+'''
+
+WINDOWS = '''_npr_ast_nodes_ExprStmt____init__:
+    push rbp
+    mov rbp, rsp
+    mov [rbp-8], rcx
+    mov [rbp-16], rdx
+    mov [rbp-24], r8
+    mov rax, 126
+    push rax
+    ret
+_npr_ast_nodes_Pass____init__:
+    ret
+'''
+
+
+def test_repairs_linux_parameter_load() -> None:
+    source, count = fix_expr_stmt_initializer_assembly(LINUX, target="linux")
+    assert count == 1
+    assert "mov rax, 126" not in source
+    assert "mov rax, [rbp-16]" in source
+
+
+def test_repairs_windows_parameter_load() -> None:
+    source, count = fix_expr_stmt_initializer_assembly(WINDOWS, target="windows")
+    assert count == 1
+    assert "mov rax, 126" not in source
+    assert "mov rax, [rbp-16]" in source
+
+
+def test_fails_closed_when_bad_load_changes() -> None:
+    try:
+        fix_expr_stmt_initializer_assembly(
+            LINUX.replace("mov rax, 126", "mov rax, 125"),
+            target="linux",
+        )
+    except RuntimeError as error:
+        assert "expected one static dict-token load" in str(error)
+    else:
+        raise AssertionError("assembly transform accepted a changed bad load")
+
+
+def test_fails_closed_when_parameter_spill_changes() -> None:
+    try:
+        fix_expr_stmt_initializer_assembly(
+            WINDOWS.replace("mov [rbp-16], rdx", "mov [rbp-32], rdx"),
+            target="windows",
+        )
+    except RuntimeError as error:
+        assert "parameter spills changed" in str(error)
+    else:
+        raise AssertionError("assembly transform accepted changed parameter spills")

From 7a7dbf949545f1e57aabe26ddffe4ea19c1bc206 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:22:48 -0500
Subject: [PATCH 241/450] Make native parser unexpected-token error
 compiler-safe

---
 tools/normalize_full_core_parser_errors.py | 108 +++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 tools/normalize_full_core_parser_errors.py

diff --git a/tools/normalize_full_core_parser_errors.py b/tools/normalize_full_core_parser_errors.py
new file mode 100644
index 00000000..f9e59003
--- /dev/null
+++ b/tools/normalize_full_core_parser_errors.py
@@ -0,0 +1,108 @@
+"""Make the embedded parser's unexpected-token diagnostic compiler-safe.
+
+INDENT/DEDENT token values are integers. The pinned compiler lowers the original
+f-string as raw string concatenation and passes that integer to ``strlen``, causing
+a segfault before PortaPy can report a compile error. The public ABI only promises
+the error category and source coordinates, so use a stable constant message while
+preserving the token position and error code.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_PARSER_CLASS = "_npr_parser_Parser"
+
+
+def _parser_method(module: ast.Module, name: str) -> ast.FunctionDef:
+    classes = [
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == _PARSER_CLASS
+    ]
+    if len(classes) != 1:
+        raise RuntimeError(
+            f"embedded native Parser expected one class, found {len(classes)}"
+        )
+    methods = [
+        node
+        for node in classes[0].body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    ]
+    if len(methods) != 1:
+        raise RuntimeError(
+            f"embedded native Parser.{name} expected one method, found {len(methods)}"
+        )
+    return methods[0]
+
+
+def _is_parse_error_call(node: ast.expr | None) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id in {"ParseError", "_npr_errors_ParseError"}
+        and bool(node.args)
+    )
+
+
+def _contains_unexpected_token_text(node: ast.expr) -> bool:
+    return any(
+        isinstance(item, ast.Constant)
+        and isinstance(item.value, str)
+        and "unexpected token" in item.value
+        for item in ast.walk(node)
+    )
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    method = _parser_method(module, "_parse_primary")
+
+    rewrites = 0
+    for node in ast.walk(method):
+        if not isinstance(node, ast.Raise) or not _is_parse_error_call(node.exc):
+            continue
+        assert isinstance(node.exc, ast.Call)
+        if not _contains_unexpected_token_text(node.exc.args[0]):
+            continue
+        node.exc.args[0] = ast.copy_location(
+            ast.Constant(value="unexpected token"),
+            node.exc.args[0],
+        )
+        rewrites += 1
+
+    if rewrites != 1:
+        raise RuntimeError(
+            "native parser unexpected-token diagnostic expected one rewrite, "
+            f"found {rewrites}"
+        )
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    verified_method = _parser_method(verified, "_parse_primary")
+    messages = [
+        node.exc.args[0]
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Raise)
+        and _is_parse_error_call(node.exc)
+        and isinstance(node.exc, ast.Call)
+        and node.exc.args
+        and isinstance(node.exc.args[0], ast.Constant)
+        and node.exc.args[0].value == "unexpected token"
+    ]
+    if len(messages) != rewrites:
+        raise RuntimeError(
+            "native parser unexpected-token diagnostic was not preserved"
+        )
+
+    print("NORMALIZED NATIVE UNEXPECTED-TOKEN ERROR", rewrites)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 61659cb858959ff465156f797875c01151cf3739 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:23:31 -0500
Subject: [PATCH 242/450] Normalize native parser unexpected-token errors

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5d0c0606..2f04398a 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -29,6 +29,7 @@
 )
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
+from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
@@ -141,6 +142,7 @@ def main() -> int:
     combine_native_parser()
     normalize_native_parser_expressions()
     normalize_expr_stmt_initializer()
+    normalize_parser_errors()
     normalize_boolops()
     normalize_closures()
     normalize_pattern_slices()

From ec8be22f530ed8c63885eac8947ccfe7d6ec6ed6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:23:50 -0500
Subject: [PATCH 243/450] Test compiler-safe native parser error message

---
 .../test_normalize_full_core_parser_errors.py | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 tests/test_normalize_full_core_parser_errors.py

diff --git a/tests/test_normalize_full_core_parser_errors.py b/tests/test_normalize_full_core_parser_errors.py
new file mode 100644
index 00000000..3ab3915e
--- /dev/null
+++ b/tests/test_normalize_full_core_parser_errors.py
@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_parser_errors as normalizer
+
+
+SOURCE = '''class _npr_parser_Parser:
+    def _parse_primary(self):
+        t = self._peek()
+        if t.kind == "INT":
+            return t
+        raise _npr_errors_ParseError(
+            f"unexpected token {t.kind} {t.value!r}",
+            t.pos,
+            ErrorCode.P_UNEXPECTED_TOKEN,
+        )
+'''
+
+
+def test_replaces_dynamic_unexpected_token_message(
+    tmp_path: Path, monkeypatch
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "raise _npr_errors_ParseError('unexpected token'," in source
+    assert "t.pos" in source
+    assert "ErrorCode.P_UNEXPECTED_TOKEN" in source
+    assert "t.value" not in source
+    ast.parse(source)
+
+
+def test_fails_closed_without_target_message(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace("unexpected token", "different diagnostic"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "expected one rewrite" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing target diagnostic")

From 919f4a775a836c9abd5153232ed43912e93a433a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:34:46 -0500
Subject: [PATCH 244/450] Trace Windows boolean conformance failure

---
 tests/native_boolean_expression_host.c | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/tests/native_boolean_expression_host.c b/tests/native_boolean_expression_host.c
index 35daf185..c834fce3 100644
--- a/tests/native_boolean_expression_host.c
+++ b/tests/native_boolean_expression_host.c
@@ -16,6 +16,11 @@
 #define ABI_CALL
 #endif
 
+#define TRACE_STEP(message) do { \
+    fprintf(stderr, "boolean-step: %s\n", (message)); \
+    fflush(stderr); \
+} while (0)
+
 typedef portapy_status (ABI_CALL *initialize_fn)(void);
 typedef portapy_status (ABI_CALL *runtime_create_fn)(const portapy_config *, portapy_runtime *);
 typedef portapy_status (ABI_CALL *runtime_destroy_fn)(portapy_runtime);
@@ -97,9 +102,11 @@ static int expect_data(
 
 int main(int argc, char **argv) {
     if (argc != 2) return 2;
+    TRACE_STEP("load-library");
     void *library = LOAD_LIBRARY(argv[1]);
     if (library == NULL) return 3;
 
+    TRACE_STEP("resolve-symbols");
     RESOLVE(initialize_fn, initialize, "portapy_library_initialize");
     RESOLVE(runtime_create_fn, runtime_create, "portapy_runtime_create");
     RESOLVE(runtime_destroy_fn, runtime_destroy, "portapy_runtime_destroy");
@@ -114,11 +121,13 @@ int main(int argc, char **argv) {
     RESOLVE(value_release_fn, value_release, "portapy_value_release");
     RESOLVE(error_get_info_fn, error_get_info, "portapy_error_get_info");
 
+    TRACE_STEP("initialize");
     if (initialize() != PORTAPY_OK) return 11;
     portapy_config config = {0};
     config.struct_size = sizeof(config);
     config.abi_version = PORTAPY_ABI_VERSION;
     portapy_runtime runtime = PORTAPY_NULL_RUNTIME;
+    TRACE_STEP("runtime-create");
     if (runtime_create(&config, &runtime) != PORTAPY_OK || runtime == 0) return 12;
 
     const char source[] =
@@ -131,6 +140,7 @@ int main(int argc, char **argv) {
         "correct = name == \"Somnia\"\n"
         "selected = empty or name\n"
         "guarded = name and answer\n";
+    TRACE_STEP("exec-boolean-block");
     if (exec_utf8(
             runtime,
             (const uint8_t *)source,
@@ -139,27 +149,42 @@ int main(int argc, char **argv) {
             strlen("boolean_block.py")
         ) != PORTAPY_OK) return 13;
 
+    TRACE_STEP("eval-arithmetic-equality");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "40 + 2 == 42", 1)) return 14;
+    TRACE_STEP("eval-bool-int-equality");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "True == 1", 1)) return 15;
+    TRACE_STEP("eval-string-order");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "\"abc\" < \"abd\"", 1)) return 16;
+    TRACE_STEP("eval-none-identity");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "None is None", 1)) return 17;
+    TRACE_STEP("eval-alias-identity");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "name is alias", 1)) return 18;
+    TRACE_STEP("eval-other-nonidentity");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "name is not other", 1)) return 19;
+    TRACE_STEP("eval-not-empty");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "not empty", 1)) return 20;
+    TRACE_STEP("eval-and-expression");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "answer > 40 and name == \"Somnia\"", 1)) return 21;
 
     portapy_value value = PORTAPY_NULL_VALUE;
+    TRACE_STEP("eval-or-value");
     if (evaluate(eval_utf8, runtime, "empty or name", &value) != PORTAPY_OK) return 22;
     static const uint8_t somnia[] = {'S', 'o', 'm', 'n', 'i', 'a'};
+    TRACE_STEP("read-or-value");
     if (!expect_data(value_get_size, value_copy_data, runtime, value, somnia, sizeof(somnia))) return 23;
+    TRACE_STEP("release-or-value");
     if (value_release(runtime, value) != PORTAPY_OK) return 24;
 
+    TRACE_STEP("eval-and-value");
     if (evaluate(eval_utf8, runtime, "name and answer", &value) != PORTAPY_OK) return 25;
     int64_t integer = 0;
+    TRACE_STEP("read-and-value");
     if (value_as_i64(runtime, value, &integer) != PORTAPY_OK || integer != 42) return 26;
+    TRACE_STEP("release-and-value");
     if (value_release(runtime, value) != PORTAPY_OK) return 27;
 
     const char *global_name = "correct";
+    TRACE_STEP("get-correct-global");
     if (get_global(
             runtime,
             (const uint8_t *)global_name,
@@ -167,26 +192,35 @@ int main(int argc, char **argv) {
             &value
         ) != PORTAPY_OK) return 28;
     int boolean = 0;
+    TRACE_STEP("read-correct-global");
     if (value_as_bool(runtime, value, &boolean) != PORTAPY_OK || boolean != 1) return 29;
+    TRACE_STEP("release-correct-global");
     if (value_release(runtime, value) != PORTAPY_OK) return 30;
 
     global_name = "selected";
+    TRACE_STEP("get-selected-global");
     if (get_global(
             runtime,
             (const uint8_t *)global_name,
             strlen(global_name),
             &value
         ) != PORTAPY_OK) return 31;
+    TRACE_STEP("read-selected-global");
     if (!expect_data(value_get_size, value_copy_data, runtime, value, somnia, sizeof(somnia))) return 32;
+    TRACE_STEP("release-selected-global");
     if (value_release(runtime, value) != PORTAPY_OK) return 33;
 
+    TRACE_STEP("eval-mixed-type-error");
     if (evaluate(eval_utf8, runtime, "\"text\" < 4", &value) != PORTAPY_TYPE_ERROR) return 34;
     if (value != PORTAPY_NULL_VALUE) return 35;
     portapy_error_info info = {0};
     info.struct_size = sizeof(info);
+    TRACE_STEP("read-mixed-type-error");
     if (error_get_info(runtime, &info) != PORTAPY_OK || info.status != PORTAPY_TYPE_ERROR) return 36;
 
+    TRACE_STEP("runtime-destroy");
     if (runtime_destroy(runtime) != PORTAPY_OK) return 37;
+    TRACE_STEP("complete");
     puts("boolean-expressions: ok");
     return 0;
 }

From 2d0b8191f1b34990f8e7003cbc2eb1c9726ba9d2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:43:35 -0500
Subject: [PATCH 245/450] Preflight Windows boolean statements individually

---
 tests/native_boolean_expression_host.c | 73 +++++++++++++++++++-------
 1 file changed, 54 insertions(+), 19 deletions(-)

diff --git a/tests/native_boolean_expression_host.c b/tests/native_boolean_expression_host.c
index c834fce3..3e2034d5 100644
--- a/tests/native_boolean_expression_host.c
+++ b/tests/native_boolean_expression_host.c
@@ -52,6 +52,21 @@ typedef portapy_status (ABI_CALL *error_get_info_fn)(portapy_runtime, portapy_er
         return 10; \
     }
 
+static portapy_status execute(
+    exec_utf8_fn function,
+    portapy_runtime runtime,
+    const char *source,
+    const char *filename
+) {
+    return function(
+        runtime,
+        (const uint8_t *)source,
+        strlen(source),
+        (const uint8_t *)filename,
+        strlen(filename)
+    );
+}
+
 static portapy_status evaluate(
     eval_utf8_fn function,
     portapy_runtime runtime,
@@ -126,6 +141,42 @@ int main(int argc, char **argv) {
     portapy_config config = {0};
     config.struct_size = sizeof(config);
     config.abi_version = PORTAPY_ABI_VERSION;
+
+    portapy_runtime preflight = PORTAPY_NULL_RUNTIME;
+    TRACE_STEP("preflight-runtime-create");
+    if (runtime_create(&config, &preflight) != PORTAPY_OK || preflight == 0) return 38;
+    const char *preflight_sources[] = {
+        "empty = \"\"\n",
+        "name = \"Somnia\"\n",
+        "alias = name\n",
+        "other = \"PortaPy\"\n",
+        "zero = 0\n",
+        "answer = 42\n",
+        "correct = name == \"Somnia\"\n",
+        "selected = empty or name\n",
+        "guarded = name and answer\n"
+    };
+    const char *preflight_steps[] = {
+        "preflight-empty",
+        "preflight-name",
+        "preflight-alias",
+        "preflight-other",
+        "preflight-zero",
+        "preflight-answer",
+        "preflight-correct",
+        "preflight-selected",
+        "preflight-guarded"
+    };
+    const size_t preflight_count = sizeof(preflight_sources) / sizeof(preflight_sources[0]);
+    for (size_t index = 0; index < preflight_count; ++index) {
+        TRACE_STEP(preflight_steps[index]);
+        if (execute(exec_utf8, preflight, preflight_sources[index], "boolean_preflight.py") != PORTAPY_OK) {
+            return (int)(39 + index);
+        }
+    }
+    TRACE_STEP("preflight-runtime-destroy");
+    if (runtime_destroy(preflight) != PORTAPY_OK) return 48;
+
     portapy_runtime runtime = PORTAPY_NULL_RUNTIME;
     TRACE_STEP("runtime-create");
     if (runtime_create(&config, &runtime) != PORTAPY_OK || runtime == 0) return 12;
@@ -141,13 +192,7 @@ int main(int argc, char **argv) {
         "selected = empty or name\n"
         "guarded = name and answer\n";
     TRACE_STEP("exec-boolean-block");
-    if (exec_utf8(
-            runtime,
-            (const uint8_t *)source,
-            sizeof(source) - 1,
-            (const uint8_t *)"boolean_block.py",
-            strlen("boolean_block.py")
-        ) != PORTAPY_OK) return 13;
+    if (execute(exec_utf8, runtime, source, "boolean_block.py") != PORTAPY_OK) return 13;
 
     TRACE_STEP("eval-arithmetic-equality");
     if (!expect_bool(eval_utf8, value_as_bool, value_release, runtime, "40 + 2 == 42", 1)) return 14;
@@ -185,12 +230,7 @@ int main(int argc, char **argv) {
 
     const char *global_name = "correct";
     TRACE_STEP("get-correct-global");
-    if (get_global(
-            runtime,
-            (const uint8_t *)global_name,
-            strlen(global_name),
-            &value
-        ) != PORTAPY_OK) return 28;
+    if (get_global(runtime, (const uint8_t *)global_name, strlen(global_name), &value) != PORTAPY_OK) return 28;
     int boolean = 0;
     TRACE_STEP("read-correct-global");
     if (value_as_bool(runtime, value, &boolean) != PORTAPY_OK || boolean != 1) return 29;
@@ -199,12 +239,7 @@ int main(int argc, char **argv) {
 
     global_name = "selected";
     TRACE_STEP("get-selected-global");
-    if (get_global(
-            runtime,
-            (const uint8_t *)global_name,
-            strlen(global_name),
-            &value
-        ) != PORTAPY_OK) return 31;
+    if (get_global(runtime, (const uint8_t *)global_name, strlen(global_name), &value) != PORTAPY_OK) return 31;
     TRACE_STEP("read-selected-global");
     if (!expect_data(value_get_size, value_copy_data, runtime, value, somnia, sizeof(somnia))) return 32;
     TRACE_STEP("release-selected-global");

From 8b42fb916255d92b75003ebfcd65a1576ecc6e82 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 07:44:25 -0500
Subject: [PATCH 246/450] Trace native control-flow conformance failure

---
 tests/native_control_flow_host.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/native_control_flow_host.c b/tests/native_control_flow_host.c
index acba2a7e..5a13e8dd 100644
--- a/tests/native_control_flow_host.c
+++ b/tests/native_control_flow_host.c
@@ -16,6 +16,11 @@
 #define ABI_CALL
 #endif
 
+#define TRACE_STEP(message) do { \
+    fprintf(stderr, "control-step: %s\n", (message)); \
+    fflush(stderr); \
+} while (0)
+
 typedef portapy_status (ABI_CALL *initialize_fn)(void);
 typedef portapy_status (ABI_CALL *runtime_create_fn)(const portapy_config *, portapy_runtime *);
 typedef portapy_status (ABI_CALL *runtime_destroy_fn)(portapy_runtime);
@@ -68,9 +73,11 @@ static int expect_text(
 
 int main(int argc, char **argv) {
     if (argc != 2) return 2;
+    TRACE_STEP("load-library");
     void *library = LOAD_LIBRARY(argv[1]);
     if (library == NULL) return 3;
 
+    TRACE_STEP("resolve-symbols");
     RESOLVE(initialize_fn, initialize, "portapy_library_initialize");
     RESOLVE(runtime_create_fn, runtime_create, "portapy_runtime_create");
     RESOLVE(runtime_destroy_fn, runtime_destroy, "portapy_runtime_destroy");
@@ -83,11 +90,13 @@ int main(int argc, char **argv) {
     RESOLVE(value_release_fn, value_release, "portapy_value_release");
     RESOLVE(error_get_info_fn, error_get_info, "portapy_error_get_info");
 
+    TRACE_STEP("initialize");
     if (initialize() != PORTAPY_OK) return 11;
     portapy_config config = {0};
     config.struct_size = sizeof(config);
     config.abi_version = PORTAPY_ABI_VERSION;
     portapy_runtime runtime = PORTAPY_NULL_RUNTIME;
+    TRACE_STEP("runtime-create");
     if (runtime_create(&config, &runtime) != PORTAPY_OK || runtime == 0) return 12;
 
     const char source[] =
@@ -111,6 +120,7 @@ int main(int argc, char **argv) {
         "finished = count == 5 and total == 8\n"
         "42 == 42\n"
         "pass\n";
+    TRACE_STEP("exec-control-block");
     if (exec_utf8(
             runtime,
             (const uint8_t *)source,
@@ -120,29 +130,45 @@ int main(int argc, char **argv) {
         ) != PORTAPY_OK) return 13;
 
     portapy_value value = PORTAPY_NULL_VALUE;
+    TRACE_STEP("get-choice");
     if (!global_value(get_global, runtime, "choice", &value)) return 14;
+    TRACE_STEP("read-choice");
     if (!expect_text(value_get_size, value_copy_data, runtime, value, "matched")) return 15;
+    TRACE_STEP("release-choice");
     if (value_release(runtime, value) != PORTAPY_OK) return 16;
 
+    TRACE_STEP("get-nested");
     if (!global_value(get_global, runtime, "nested", &value)) return 17;
     int boolean = 0;
+    TRACE_STEP("read-nested");
     if (value_as_bool(runtime, value, &boolean) != PORTAPY_OK || boolean != 1) return 18;
+    TRACE_STEP("release-nested");
     if (value_release(runtime, value) != PORTAPY_OK) return 19;
 
+    TRACE_STEP("get-count");
     if (!global_value(get_global, runtime, "count", &value)) return 20;
     int64_t integer = 0;
+    TRACE_STEP("read-count");
     if (value_as_i64(runtime, value, &integer) != PORTAPY_OK || integer != 5) return 21;
+    TRACE_STEP("release-count");
     if (value_release(runtime, value) != PORTAPY_OK) return 22;
 
+    TRACE_STEP("get-total");
     if (!global_value(get_global, runtime, "total", &value)) return 23;
+    TRACE_STEP("read-total");
     if (value_as_i64(runtime, value, &integer) != PORTAPY_OK || integer != 8) return 24;
+    TRACE_STEP("release-total");
     if (value_release(runtime, value) != PORTAPY_OK) return 25;
 
+    TRACE_STEP("get-finished");
     if (!global_value(get_global, runtime, "finished", &value)) return 26;
+    TRACE_STEP("read-finished");
     if (value_as_bool(runtime, value, &boolean) != PORTAPY_OK || boolean != 1) return 27;
+    TRACE_STEP("release-finished");
     if (value_release(runtime, value) != PORTAPY_OK) return 28;
 
     const char invalid[] = "value = 1\n  unexpected = 2\n";
+    TRACE_STEP("exec-invalid-source");
     if (exec_utf8(
             runtime,
             (const uint8_t *)invalid,
@@ -152,10 +178,14 @@ int main(int argc, char **argv) {
         ) != PORTAPY_COMPILE_ERROR) return 29;
     portapy_error_info info = {0};
     info.struct_size = sizeof(info);
+    TRACE_STEP("read-invalid-error");
     if (error_get_info(runtime, &info) != PORTAPY_OK) return 30;
+    TRACE_STEP("validate-invalid-error");
     if (info.status != PORTAPY_COMPILE_ERROR || info.line != 2) return 31;
 
+    TRACE_STEP("runtime-destroy");
     if (runtime_destroy(runtime) != PORTAPY_OK) return 32;
+    TRACE_STEP("complete");
     puts("control-flow: ok");
     return 0;
 }

From 31a85c3db80f188c37176f32f2b547fb5abbe1d3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 10:55:39 -0500
Subject: [PATCH 247/450] Trace Windows boolean crash address

---
 tests/native_boolean_expression_host.c | 52 ++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/tests/native_boolean_expression_host.c b/tests/native_boolean_expression_host.c
index 3e2034d5..fd71fb30 100644
--- a/tests/native_boolean_expression_host.c
+++ b/tests/native_boolean_expression_host.c
@@ -9,11 +9,62 @@
 #define LOAD_LIBRARY(path) ((void *)LoadLibraryA(path))
 #define LOAD_SYMBOL(lib, name) ((void *)(uintptr_t)GetProcAddress((HMODULE)(lib), (name)))
 #define ABI_CALL __cdecl
+
+static LONG WINAPI portapy_boolean_crash_filter(EXCEPTION_POINTERS *exception) {
+    DWORD code = 0;
+    void *address = NULL;
+    CONTEXT *context = NULL;
+    if (exception != NULL) {
+        context = exception->ContextRecord;
+        if (exception->ExceptionRecord != NULL) {
+            code = exception->ExceptionRecord->ExceptionCode;
+            address = exception->ExceptionRecord->ExceptionAddress;
+        }
+    }
+
+    HMODULE module = NULL;
+    char module_name[MAX_PATH] = {0};
+    unsigned long long offset = 0;
+    if (address != NULL && GetModuleHandleExA(
+            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+            (LPCSTR)address,
+            &module
+        )) {
+        GetModuleFileNameA(module, module_name, (DWORD)sizeof(module_name));
+        offset = (unsigned long long)((uintptr_t)address - (uintptr_t)module);
+    }
+
+    fprintf(
+        stderr,
+        "boolean-crash: code=0x%08lx address=%p module=%s offset=0x%llx\n",
+        (unsigned long)code,
+        address,
+        module_name[0] == '\0' ? "<unknown>" : module_name,
+        offset
+    );
+#if defined(_M_X64) || defined(__x86_64__)
+    if (context != NULL) {
+        fprintf(
+            stderr,
+            "boolean-crash-context: rip=0x%llx rsp=0x%llx rbp=0x%llx\n",
+            (unsigned long long)context->Rip,
+            (unsigned long long)context->Rsp,
+            (unsigned long long)context->Rbp
+        );
+    }
+#endif
+    fflush(stderr);
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+
+#define INSTALL_CRASH_HANDLER() SetUnhandledExceptionFilter(portapy_boolean_crash_filter)
 #else
 #include <dlfcn.h>
 #define LOAD_LIBRARY(path) dlopen((path), RTLD_NOW | RTLD_LOCAL)
 #define LOAD_SYMBOL(lib, name) dlsym((lib), (name))
 #define ABI_CALL
+#define INSTALL_CRASH_HANDLER() ((void)0)
 #endif
 
 #define TRACE_STEP(message) do { \
@@ -117,6 +168,7 @@ static int expect_data(
 
 int main(int argc, char **argv) {
     if (argc != 2) return 2;
+    INSTALL_CRASH_HANDLER();
     TRACE_STEP("load-library");
     void *library = LOAD_LIBRARY(argv[1]);
     if (library == NULL) return 3;

From d32ffca784d9ccd8e2320144d1cbdaee0fc7ead4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 10:57:03 -0500
Subject: [PATCH 248/450] Trace native control-flow crash address

---
 tests/native_control_flow_host.c | 196 +++++++++++++++++++++++++++++--
 1 file changed, 189 insertions(+), 7 deletions(-)

diff --git a/tests/native_control_flow_host.c b/tests/native_control_flow_host.c
index 5a13e8dd..54b0f0dc 100644
--- a/tests/native_control_flow_host.c
+++ b/tests/native_control_flow_host.c
@@ -1,7 +1,9 @@
+#define _GNU_SOURCE
 #include "portapy.h"
 
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #if defined(_WIN32)
@@ -9,11 +11,112 @@
 #define LOAD_LIBRARY(path) ((void *)LoadLibraryA(path))
 #define LOAD_SYMBOL(lib, name) ((void *)(uintptr_t)GetProcAddress((HMODULE)(lib), (name)))
 #define ABI_CALL __cdecl
+
+static LONG WINAPI portapy_control_crash_filter(EXCEPTION_POINTERS *exception) {
+    DWORD code = 0;
+    void *address = NULL;
+    CONTEXT *context = NULL;
+    if (exception != NULL) {
+        context = exception->ContextRecord;
+        if (exception->ExceptionRecord != NULL) {
+            code = exception->ExceptionRecord->ExceptionCode;
+            address = exception->ExceptionRecord->ExceptionAddress;
+        }
+    }
+    HMODULE module = NULL;
+    char module_name[MAX_PATH] = {0};
+    unsigned long long offset = 0;
+    if (address != NULL && GetModuleHandleExA(
+            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+            (LPCSTR)address,
+            &module
+        )) {
+        GetModuleFileNameA(module, module_name, (DWORD)sizeof(module_name));
+        offset = (unsigned long long)((uintptr_t)address - (uintptr_t)module);
+    }
+    fprintf(
+        stderr,
+        "control-crash: code=0x%08lx address=%p module=%s offset=0x%llx\n",
+        (unsigned long)code,
+        address,
+        module_name[0] == '\0' ? "<unknown>" : module_name,
+        offset
+    );
+#if defined(_M_X64) || defined(__x86_64__)
+    if (context != NULL) {
+        fprintf(
+            stderr,
+            "control-crash-context: rip=0x%llx rsp=0x%llx rbp=0x%llx\n",
+            (unsigned long long)context->Rip,
+            (unsigned long long)context->Rsp,
+            (unsigned long long)context->Rbp
+        );
+    }
+#endif
+    fflush(stderr);
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+
+#define INSTALL_CRASH_HANDLER() SetUnhandledExceptionFilter(portapy_control_crash_filter)
 #else
 #include <dlfcn.h>
+#include <execinfo.h>
+#include <signal.h>
+#include <ucontext.h>
 #define LOAD_LIBRARY(path) dlopen((path), RTLD_NOW | RTLD_LOCAL)
 #define LOAD_SYMBOL(lib, name) dlsym((lib), (name))
 #define ABI_CALL
+
+static void portapy_control_signal_handler(
+    int signal_number,
+    siginfo_t *signal_info,
+    void *context_pointer
+) {
+    uintptr_t instruction = 0;
+#if defined(__x86_64__) && defined(REG_RIP)
+    ucontext_t *context = (ucontext_t *)context_pointer;
+    instruction = (uintptr_t)context->uc_mcontext.gregs[REG_RIP];
+#else
+    (void)context_pointer;
+#endif
+    Dl_info module_info = {0};
+    const char *module_name = "<unknown>";
+    uintptr_t offset = 0;
+    if (instruction != 0 && dladdr((void *)instruction, &module_info) != 0) {
+        if (module_info.dli_fname != NULL) module_name = module_info.dli_fname;
+        if (module_info.dli_fbase != NULL) {
+            offset = instruction - (uintptr_t)module_info.dli_fbase;
+        }
+    }
+    fprintf(
+        stderr,
+        "control-crash: signal=%d fault=%p instruction=%p module=%s offset=0x%llx\n",
+        signal_number,
+        signal_info == NULL ? NULL : signal_info->si_addr,
+        (void *)instruction,
+        module_name,
+        (unsigned long long)offset
+    );
+    void *frames[32];
+    int frame_count = backtrace(frames, (int)(sizeof(frames) / sizeof(frames[0])));
+    backtrace_symbols_fd(frames, frame_count, 2);
+    fflush(stderr);
+    _Exit(128 + signal_number);
+}
+
+static void install_control_crash_handler(void) {
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_sigaction = portapy_control_signal_handler;
+    action.sa_flags = SA_SIGINFO | SA_RESETHAND;
+    sigemptyset(&action.sa_mask);
+    sigaction(SIGSEGV, &action, NULL);
+    sigaction(SIGBUS, &action, NULL);
+    sigaction(SIGABRT, &action, NULL);
+}
+
+#define INSTALL_CRASH_HANDLER() install_control_crash_handler()
 #endif
 
 #define TRACE_STEP(message) do { \
@@ -71,8 +174,24 @@ static int expect_text(
     return copied == expected_size && memcmp(buffer, expected, expected_size) == 0;
 }
 
+static portapy_status execute_text(
+    exec_utf8_fn execute,
+    portapy_runtime runtime,
+    const char *source,
+    const char *filename
+) {
+    return execute(
+        runtime,
+        (const uint8_t *)source,
+        strlen(source),
+        (const uint8_t *)filename,
+        strlen(filename)
+    );
+}
+
 int main(int argc, char **argv) {
     if (argc != 2) return 2;
+    INSTALL_CRASH_HANDLER();
     TRACE_STEP("load-library");
     void *library = LOAD_LIBRARY(argv[1]);
     if (library == NULL) return 3;
@@ -95,6 +214,75 @@ int main(int argc, char **argv) {
     portapy_config config = {0};
     config.struct_size = sizeof(config);
     config.abi_version = PORTAPY_ABI_VERSION;
+
+    const char *preflight_sources[] = {
+        "name = \"Somnia\"\n"
+        "choice = \"unset\"\n",
+        "name = \"Somnia\"\n"
+        "choice = \"unset\"\n"
+        "if name == \"Somnia\":\n"
+        "    choice = \"matched\"\n"
+        "    if 2 < 3:\n"
+        "        nested = True\n"
+        "else:\n"
+        "    choice = \"wrong\"\n",
+        "name = \"Somnia\"\n"
+        "choice = \"unset\"\n"
+        "if name == \"Somnia\":\n"
+        "    choice = \"matched\"\n"
+        "    if 2 < 3:\n"
+        "        nested = True\n"
+        "else:\n"
+        "    choice = \"wrong\"\n"
+        "count = 0\n"
+        "total = 0\n"
+        "while count < 6:\n"
+        "    count = count + 1\n"
+        "    if count == 2:\n"
+        "        continue\n"
+        "    if count == 5:\n"
+        "        break\n"
+        "    total = total + count\n",
+        "name = \"Somnia\"\n"
+        "choice = \"unset\"\n"
+        "if name == \"Somnia\":\n"
+        "    choice = \"matched\"\n"
+        "    if 2 < 3:\n"
+        "        nested = True\n"
+        "else:\n"
+        "    choice = \"wrong\"\n"
+        "count = 0\n"
+        "total = 0\n"
+        "while count < 6:\n"
+        "    count = count + 1\n"
+        "    if count == 2:\n"
+        "        continue\n"
+        "    if count == 5:\n"
+        "        break\n"
+        "    total = total + count\n"
+        "finished = count == 5 and total == 8\n"
+        "42 == 42\n"
+        "pass\n"
+    };
+    const char *preflight_steps[] = {
+        "preflight-assignments",
+        "preflight-if",
+        "preflight-while",
+        "preflight-complete"
+    };
+    const size_t preflight_count = sizeof(preflight_sources) / sizeof(preflight_sources[0]);
+    for (size_t index = 0; index < preflight_count; ++index) {
+        portapy_runtime probe = PORTAPY_NULL_RUNTIME;
+        TRACE_STEP(preflight_steps[index]);
+        if (runtime_create(&config, &probe) != PORTAPY_OK || probe == 0) {
+            return (int)(40 + index * 2);
+        }
+        if (execute_text(exec_utf8, probe, preflight_sources[index], "control_preflight.py") != PORTAPY_OK) {
+            return (int)(41 + index * 2);
+        }
+        if (runtime_destroy(probe) != PORTAPY_OK) return (int)(48 + index);
+    }
+
     portapy_runtime runtime = PORTAPY_NULL_RUNTIME;
     TRACE_STEP("runtime-create");
     if (runtime_create(&config, &runtime) != PORTAPY_OK || runtime == 0) return 12;
@@ -121,13 +309,7 @@ int main(int argc, char **argv) {
         "42 == 42\n"
         "pass\n";
     TRACE_STEP("exec-control-block");
-    if (exec_utf8(
-            runtime,
-            (const uint8_t *)source,
-            sizeof(source) - 1,
-            (const uint8_t *)"control_flow.py",
-            strlen("control_flow.py")
-        ) != PORTAPY_OK) return 13;
+    if (execute_text(exec_utf8, runtime, source, "control_flow.py") != PORTAPY_OK) return 13;
 
     portapy_value value = PORTAPY_NULL_VALUE;
     TRACE_STEP("get-choice");

From 0a0204d552debaff94068ac81e5e35212f3e90ad Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:03:39 -0500
Subject: [PATCH 249/450] Trace native function conformance crash

---
 tests/native_function_host.c | 164 +++++++++++++++++++++++++++++++++--
 1 file changed, 159 insertions(+), 5 deletions(-)

diff --git a/tests/native_function_host.c b/tests/native_function_host.c
index 03e3d0d3..0c423dbf 100644
--- a/tests/native_function_host.c
+++ b/tests/native_function_host.c
@@ -1,7 +1,9 @@
+#define _GNU_SOURCE
 #include "portapy.h"
 
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #if defined(_WIN32)
@@ -9,13 +11,107 @@
 #define LOAD_LIBRARY(path) ((void *)LoadLibraryA(path))
 #define LOAD_SYMBOL(lib, name) ((void *)(uintptr_t)GetProcAddress((HMODULE)(lib), (name)))
 #define ABI_CALL __cdecl
+static LONG WINAPI function_crash_filter(EXCEPTION_POINTERS *exception) {
+    DWORD code = 0;
+    void *address = NULL;
+    CONTEXT *context = NULL;
+    if (exception != NULL) {
+        context = exception->ContextRecord;
+        if (exception->ExceptionRecord != NULL) {
+            code = exception->ExceptionRecord->ExceptionCode;
+            address = exception->ExceptionRecord->ExceptionAddress;
+        }
+    }
+    HMODULE module = NULL;
+    char module_name[MAX_PATH] = {0};
+    unsigned long long offset = 0;
+    if (address != NULL && GetModuleHandleExA(
+            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+            (LPCSTR)address,
+            &module
+        )) {
+        GetModuleFileNameA(module, module_name, (DWORD)sizeof(module_name));
+        offset = (unsigned long long)((uintptr_t)address - (uintptr_t)module);
+    }
+    fprintf(stderr,
+        "function-crash: code=0x%08lx address=%p module=%s offset=0x%llx\n",
+        (unsigned long)code,
+        address,
+        module_name[0] == '\0' ? "<unknown>" : module_name,
+        offset
+    );
+#if defined(_M_X64) || defined(__x86_64__)
+    if (context != NULL) {
+        fprintf(stderr,
+            "function-crash-context: rip=0x%llx rsp=0x%llx rbp=0x%llx\n",
+            (unsigned long long)context->Rip,
+            (unsigned long long)context->Rsp,
+            (unsigned long long)context->Rbp
+        );
+    }
+#endif
+    fflush(stderr);
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+#define INSTALL_CRASH_HANDLER() SetUnhandledExceptionFilter(function_crash_filter)
 #else
 #include <dlfcn.h>
+#include <execinfo.h>
+#include <signal.h>
+#include <ucontext.h>
 #define LOAD_LIBRARY(path) dlopen((path), RTLD_NOW | RTLD_LOCAL)
 #define LOAD_SYMBOL(lib, name) dlsym((lib), (name))
 #define ABI_CALL
+static void function_signal_handler(int number, siginfo_t *info, void *context_pointer) {
+    uintptr_t instruction = 0;
+#if defined(__x86_64__) && defined(REG_RIP)
+    ucontext_t *context = (ucontext_t *)context_pointer;
+    instruction = (uintptr_t)context->uc_mcontext.gregs[REG_RIP];
+#else
+    (void)context_pointer;
+#endif
+    Dl_info module_info = {0};
+    const char *module_name = "<unknown>";
+    uintptr_t offset = 0;
+    if (instruction != 0 && dladdr((void *)instruction, &module_info) != 0) {
+        if (module_info.dli_fname != NULL) module_name = module_info.dli_fname;
+        if (module_info.dli_fbase != NULL) {
+            offset = instruction - (uintptr_t)module_info.dli_fbase;
+        }
+    }
+    fprintf(stderr,
+        "function-crash: signal=%d fault=%p instruction=%p module=%s offset=0x%llx\n",
+        number,
+        info == NULL ? NULL : info->si_addr,
+        (void *)instruction,
+        module_name,
+        (unsigned long long)offset
+    );
+    void *frames[32];
+    int count = backtrace(frames, (int)(sizeof(frames) / sizeof(frames[0])));
+    backtrace_symbols_fd(frames, count, 2);
+    fflush(stderr);
+    _Exit(128 + number);
+}
+static void install_function_crash_handler(void) {
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_sigaction = function_signal_handler;
+    action.sa_flags = SA_SIGINFO | SA_RESETHAND;
+    sigemptyset(&action.sa_mask);
+    sigaction(SIGSEGV, &action, NULL);
+    sigaction(SIGBUS, &action, NULL);
+    sigaction(SIGABRT, &action, NULL);
+}
+#define INSTALL_CRASH_HANDLER() install_function_crash_handler()
 #endif
 
+#define TRACE_STEP(message) do { \
+    fprintf(stderr, "function-step: %s\n", (message)); \
+    fflush(stderr); \
+} while (0)
+
 typedef portapy_status (ABI_CALL *initialize_fn)(void);
 typedef portapy_status (ABI_CALL *runtime_create_fn)(const portapy_config *, portapy_runtime *);
 typedef portapy_status (ABI_CALL *runtime_destroy_fn)(portapy_runtime);
@@ -34,11 +130,9 @@ typedef portapy_status (ABI_CALL *release_fn)(portapy_runtime, portapy_value);
 static int execute(exec_fn function, portapy_runtime runtime, const char *source) {
     return function(runtime, (const uint8_t *)source, strlen(source), NULL, 0) == PORTAPY_OK;
 }
-
 static int execute_status(exec_fn function, portapy_runtime runtime, const char *source, portapy_status expected) {
     return function(runtime, (const uint8_t *)source, strlen(source), NULL, 0) == expected;
 }
-
 static int evaluate_i64(eval_fn function, as_i64_fn as_i64, release_fn release, portapy_runtime runtime, const char *source, int64_t expected) {
     portapy_value value = PORTAPY_NULL_VALUE;
     int64_t result = 0;
@@ -46,7 +140,6 @@ static int evaluate_i64(eval_fn function, as_i64_fn as_i64, release_fn release,
     if (as_i64(runtime, value, &result) != PORTAPY_OK || result != expected) return 0;
     return release(runtime, value) == PORTAPY_OK;
 }
-
 static int evaluate_bool(eval_fn function, as_bool_fn as_bool, release_fn release, portapy_runtime runtime, const char *source, int expected) {
     portapy_value value = PORTAPY_NULL_VALUE;
     int result = 0;
@@ -54,7 +147,6 @@ static int evaluate_bool(eval_fn function, as_bool_fn as_bool, release_fn releas
     if (as_bool(runtime, value, &result) != PORTAPY_OK || result != expected) return 0;
     return release(runtime, value) == PORTAPY_OK;
 }
-
 static int evaluate_status(eval_fn function, portapy_runtime runtime, const char *source, portapy_status expected) {
     portapy_value value = PORTAPY_NULL_VALUE;
     return function(runtime, (const uint8_t *)source, strlen(source), NULL, 0, &value) == expected;
@@ -62,9 +154,11 @@ static int evaluate_status(eval_fn function, portapy_runtime runtime, const char
 
 int main(int argc, char **argv) {
     if (argc != 2) return 2;
+    INSTALL_CRASH_HANDLER();
+    TRACE_STEP("load-library");
     void *library = LOAD_LIBRARY(argv[1]);
     if (library == NULL) return 3;
-
+    TRACE_STEP("resolve-symbols");
     RESOLVE(initialize_fn, initialize, "portapy_library_initialize");
     RESOLVE(runtime_create_fn, runtime_create, "portapy_runtime_create");
     RESOLVE(runtime_destroy_fn, runtime_destroy, "portapy_runtime_destroy");
@@ -76,11 +170,13 @@ int main(int argc, char **argv) {
     RESOLVE(as_i64_fn, as_i64, "portapy_value_as_i64");
     RESOLVE(release_fn, release, "portapy_value_release");
 
+    TRACE_STEP("initialize");
     if (initialize() != PORTAPY_OK) return 11;
     portapy_config config = {0};
     config.struct_size = sizeof(config);
     config.abi_version = PORTAPY_ABI_VERSION;
     portapy_runtime runtime = PORTAPY_NULL_RUNTIME;
+    TRACE_STEP("runtime-create");
     if (runtime_create(&config, &runtime) != PORTAPY_OK) return 12;
 
     const char first[] =
@@ -90,22 +186,31 @@ int main(int argc, char **argv) {
         "    total = left + right\n"
         "    return total\n"
         "answer = add(20, 22)\n";
+    TRACE_STEP("exec-first-functions");
     if (!execute(exec_utf8, runtime, first)) return 13;
+    TRACE_STEP("eval-seven");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "seven()", 7)) return 14;
+    TRACE_STEP("eval-answer");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "answer", 42)) return 15;
+    TRACE_STEP("eval-add");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "add(3, 4)", 7)) return 16;
 
     portapy_value callable = PORTAPY_NULL_VALUE;
     portapy_value_kind kind = PORTAPY_VALUE_NONE;
+    TRACE_STEP("get-add-callable");
     if (get_global(runtime, (const uint8_t *)"add", 3, &callable) != PORTAPY_OK) return 17;
+    TRACE_STEP("kind-add-callable");
     if (get_kind(runtime, callable, &kind) != PORTAPY_OK || kind != PORTAPY_VALUE_CALLABLE) return 18;
+    TRACE_STEP("release-add-callable");
     if (release(runtime, callable) != PORTAPY_OK) return 19;
 
     const char nested[] =
         "def double(value):\n"
         "    return value * 2\n"
         "nested_answer = add(double(10), double(11))\n";
+    TRACE_STEP("exec-nested-functions");
     if (!execute(exec_utf8, runtime, nested)) return 20;
+    TRACE_STEP("eval-nested-answer");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "nested_answer", 42)) return 21;
 
     const char control[] =
@@ -126,9 +231,13 @@ int main(int argc, char **argv) {
         "control_zero = classify(0)\n"
         "control_small = classify(3)\n"
         "control_large = classify(5)\n";
+    TRACE_STEP("exec-function-control");
     if (!execute(exec_utf8, runtime, control)) return 22;
+    TRACE_STEP("eval-control-zero");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "control_zero", 100)) return 23;
+    TRACE_STEP("eval-control-small");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "control_small", 4)) return 24;
+    TRACE_STEP("eval-control-large");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "control_large", 8)) return 25;
 
     const char arguments[] =
@@ -138,14 +247,23 @@ int main(int argc, char **argv) {
         "mixed = combine(10, scale=4)\n"
         "reordered = combine(scale=2, left=18, right=3)\n"
         "nested_default = combine(combine(1), scale=2)\n";
+    TRACE_STEP("exec-default-arguments");
     if (!execute(exec_utf8, runtime, arguments)) return 26;
+    TRACE_STEP("eval-defaulted");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "defaulted", 42)) return 27;
+    TRACE_STEP("eval-mixed-keyword");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "mixed", 48)) return 28;
+    TRACE_STEP("eval-reordered-keyword");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "reordered", 42)) return 29;
+    TRACE_STEP("eval-nested-default");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "nested_default", 22)) return 30;
+    TRACE_STEP("error-missing-arguments");
     if (!evaluate_status(eval_utf8, runtime, "combine()", PORTAPY_TYPE_ERROR)) return 31;
+    TRACE_STEP("error-duplicate-argument");
     if (!evaluate_status(eval_utf8, runtime, "combine(1, left=2)", PORTAPY_TYPE_ERROR)) return 32;
+    TRACE_STEP("error-unknown-keyword");
     if (!evaluate_status(eval_utf8, runtime, "combine(1, unknown=2)", PORTAPY_TYPE_ERROR)) return 33;
+    TRACE_STEP("error-positional-after-keyword");
     if (!evaluate_status(eval_utf8, runtime, "combine(left=1, 2)", PORTAPY_COMPILE_ERROR)) return 34;
 
     const char capture[] =
@@ -157,8 +275,11 @@ int main(int argc, char **argv) {
         "explicit_result = captured(7)\n"
         "def stable(value=6):\n"
         "    return value\n";
+    TRACE_STEP("exec-default-capture");
     if (!execute(exec_utf8, runtime, capture)) return 35;
+    TRACE_STEP("eval-captured-result");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "captured_result", 10)) return 36;
+    TRACE_STEP("eval-explicit-result");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "explicit_result", 14)) return 37;
 
     const char redefine[] =
@@ -166,13 +287,17 @@ int main(int argc, char **argv) {
         "def captured(value=seed):\n"
         "    return value + 1\n"
         "seed = 100\n";
+    TRACE_STEP("exec-redefinition");
     if (!execute(exec_utf8, runtime, redefine)) return 38;
+    TRACE_STEP("eval-redefined-captured");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "captured()", 10)) return 39;
 
     const char invalid_redefinition[] =
         "def stable(value=missing_default):\n"
         "    return value + 100\n";
+    TRACE_STEP("exec-invalid-redefinition");
     if (!execute_status(exec_utf8, runtime, invalid_redefinition, PORTAPY_NOT_FOUND)) return 40;
+    TRACE_STEP("eval-stable-after-invalid");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "stable()", 6)) return 41;
 
     const char parameter_kinds[] =
@@ -188,28 +313,50 @@ int main(int argc, char **argv) {
         "marker_mixed = route(18, right=3, scale=2)\n"
         "required_result = required(40, offset=2)\n"
         "marker_captured = marker_capture()\n";
+    TRACE_STEP("exec-parameter-kinds");
     if (!execute(exec_utf8, runtime, parameter_kinds)) return 42;
+    TRACE_STEP("eval-qualified");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "qualified", 48)) return 43;
+    TRACE_STEP("eval-marker-mixed");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "marker_mixed", 42)) return 44;
+    TRACE_STEP("eval-required-result");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "required_result", 42)) return 45;
+    TRACE_STEP("eval-marker-captured");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "marker_captured", 5)) return 46;
+    TRACE_STEP("error-positional-only-keyword");
     if (!evaluate_status(eval_utf8, runtime, "route(left=10)", PORTAPY_TYPE_ERROR)) return 47;
+    TRACE_STEP("error-too-many-positionals");
     if (!evaluate_status(eval_utf8, runtime, "route(10, 2, 4)", PORTAPY_TYPE_ERROR)) return 48;
+    TRACE_STEP("error-required-keyword-only");
     if (!evaluate_status(eval_utf8, runtime, "required(40)", PORTAPY_TYPE_ERROR)) return 49;
+    TRACE_STEP("error-keyword-only-positional");
     if (!evaluate_status(eval_utf8, runtime, "required(40, 2)", PORTAPY_TYPE_ERROR)) return 50;
+    TRACE_STEP("error-invalid-double-star-parameter");
     if (!execute_status(exec_utf8, runtime, "def bad(**):\n    return 1\n", PORTAPY_COMPILE_ERROR)) return 51;
 
+    TRACE_STEP("tuple-index-first");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "(1, 2, 3)[0]", 1)) return 52;
+    TRACE_STEP("tuple-index-negative");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "(1, 2, 3)[-1]", 3)) return 53;
+    TRACE_STEP("tuple-index-nested");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "(1, (2, 3))[1][0]", 2)) return 54;
+    TRACE_STEP("tuple-len-empty");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "len(())", 0)) return 55;
+    TRACE_STEP("tuple-len-three");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "len((1, 2, 3))", 3)) return 56;
+    TRACE_STEP("unicode-len");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "len(\"\xC3\xA9\")", 1)) return 57;
+    TRACE_STEP("tuple-truth-empty");
     if (!evaluate_bool(eval_utf8, as_bool, release, runtime, "not ()", 1)) return 58;
+    TRACE_STEP("tuple-truth-nonempty");
     if (!evaluate_bool(eval_utf8, as_bool, release, runtime, "not (1,)", 0)) return 59;
+    TRACE_STEP("tuple-equality");
     if (!evaluate_bool(eval_utf8, as_bool, release, runtime, "(1, (2, 3)) == (1, (2, 3))", 1)) return 60;
+    TRACE_STEP("tuple-inequality");
     if (!evaluate_bool(eval_utf8, as_bool, release, runtime, "(1, 2) != (1, 3)", 1)) return 61;
+    TRACE_STEP("tuple-oob-error");
     if (!evaluate_status(eval_utf8, runtime, "(1,)[2]", PORTAPY_RUNTIME_ERROR)) return 62;
+    TRACE_STEP("tuple-type-error");
     if (!evaluate_status(eval_utf8, runtime, "(1,)[\"x\"]", PORTAPY_TYPE_ERROR)) return 63;
 
     const char tuples[] =
@@ -219,14 +366,21 @@ int main(int argc, char **argv) {
         "    return 0\n"
         "tuple_answer = summarize((18, 1, 20))\n"
         "tuple_empty = summarize(())\n";
+    TRACE_STEP("exec-tuple-function");
     if (!execute(exec_utf8, runtime, tuples)) return 64;
+    TRACE_STEP("eval-tuple-answer");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "tuple_answer", 41)) return 65;
+    TRACE_STEP("eval-tuple-empty");
     if (!evaluate_i64(eval_utf8, as_i64, release, runtime, "tuple_empty", 0)) return 66;
 
     portapy_value missing = PORTAPY_NULL_VALUE;
+    TRACE_STEP("check-local-total-hidden");
     if (get_global(runtime, (const uint8_t *)"total", 5, &missing) != PORTAPY_NOT_FOUND) return 67;
+    TRACE_STEP("check-local-current-hidden");
     if (get_global(runtime, (const uint8_t *)"current", 7, &missing) != PORTAPY_NOT_FOUND) return 68;
+    TRACE_STEP("runtime-destroy");
     if (runtime_destroy(runtime) != PORTAPY_OK) return 69;
+    TRACE_STEP("complete");
     puts("native-functions: ok");
     return 0;
 }

From 2cdc6d5d74b7fe16ca2c0aa0a834cff29e92ffe3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:10:53 -0500
Subject: [PATCH 250/450] Unpack native MAKE_FUNCTION list specifications

---
 tools/normalize_full_core_make_function.py | 49 ++++++++++++----------
 1 file changed, 27 insertions(+), 22 deletions(-)

diff --git a/tools/normalize_full_core_make_function.py b/tools/normalize_full_core_make_function.py
index dfec6168..63f08bbd 100644
--- a/tools/normalize_full_core_make_function.py
+++ b/tools/normalize_full_core_make_function.py
@@ -1,14 +1,13 @@
 """Normalize MAKE_FUNCTION for the native compiler.
 
-The compiled VM represents user-class values as compact native class values.
-A runtime ``isinstance(nested, CodeObject)`` therefore dereferences that value
-as an object dictionary and crashes.  Give ``nested`` an explicit static
-CodeObject type instead and trust the frontend-produced constant.
-
-The original block also uses list slices and comprehensions while native slice
-objects are intentionally disabled during bootstrap.  Replace those operations
-with index-based loops so defaults, keyword defaults, and closure cells retain
-full semantics without unsupported runtime shapes.
+The compiled VM materializes frontend tuple constants as native list values.  The
+old handler guarded unpacking with ``isinstance(spec, tuple)``, so native function
+specifications were left packed and then mistaken for a CodeObject.  Unpack the
+known 2/3/4-item specification by length and index instead.  The frontend is the
+only producer of MAKE_FUNCTION constants, so any other shape is rejected.
+
+The block also avoids slices and comprehensions because native slice objects are
+intentionally disabled during bootstrap.
 """
 from __future__ import annotations
 
@@ -22,20 +21,25 @@
 
 _REPLACEMENT = '''                elif op is Op.MAKE_FUNCTION:
                      spec = frame.code.constants[instr.arg]
-                     nested: CodeObject = spec
+                     spec_size = len(spec)
                      default_count = 0
                      kw_default_count = 0
                      annotations: dict[str, object] = {}
-                     if isinstance(spec, tuple) and len(spec) == 4:
-                         nested, default_count, kw_default_count, annotations = spec
-                     elif isinstance(spec, tuple) and len(spec) == 2:
-                         nested, default_count = spec
-                     elif isinstance(spec, tuple) and len(spec) == 3:
-                         nested, default_count, kw_default_count = spec
+                     if spec_size == 4:
+                         nested: CodeObject = spec[0]
+                         default_count = spec[1]
+                         kw_default_count = spec[2]
+                         annotations = spec[3]
+                     elif spec_size == 3:
+                         nested: CodeObject = spec[0]
+                         default_count = spec[1]
+                         kw_default_count = spec[2]
+                     elif spec_size == 2:
+                         nested: CodeObject = spec[0]
+                         default_count = spec[1]
                      else:
-                         nested = spec
-                     if nested is None:
                          _raise_typed("TypeError: invalid function constant")
+                         nested: CodeObject = spec[0]
                      count = default_count + kw_default_count
                      if len(frame.stack) < count:
                          _raise_typed("RuntimeError: default stack underflow")
@@ -74,7 +78,6 @@
                      frame.stack.append(function)
 '''
 
-
 _LEGACY_DEFAULTS_SHAPE = (
     "values = frame.stack[-count:] if count else []",
     "defaults = values[:default_count]",
@@ -103,7 +106,6 @@ def main() -> int:
     block = source[start:end]
     required = (
         "spec = frame.code.constants[instr.arg]",
-        "if not isinstance(nested, CodeObject)",
         "count = default_count + kw_default_count",
         "closure = {",
         "function = Function(nested, frame.globals, defaults, kw_defaults, closure, self)",
@@ -122,8 +124,9 @@ def main() -> int:
 
     installed = source[start:start + len(_REPLACEMENT)]
     validation = (
-        "nested: CodeObject = spec",
-        "if nested is None:",
+        "spec_size = len(spec)",
+        "if spec_size == 4:",
+        "nested: CodeObject = spec[0]",
         "while default_index < default_count:",
         "while kw_index < kw_default_count:",
         "for name in nested.free_names:",
@@ -133,7 +136,9 @@ def main() -> int:
     if absent:
         raise RuntimeError(f"native MAKE_FUNCTION validation failed: {absent}")
     forbidden = (
+        "isinstance(spec, tuple)",
         "isinstance(nested, CodeObject)",
+        "nested: CodeObject = spec\n",
         "frame.stack[-count:]",
         "values[:default_count]",
     )

From 1af4bea1df36ac9bbfd73d8506e7d465dba038eb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:11:29 -0500
Subject: [PATCH 251/450] Test native MAKE_FUNCTION list unpacking

---
 tests/test_normalize_full_core_make_function.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_core_make_function.py b/tests/test_normalize_full_core_make_function.py
index 60eff17e..792a7ab1 100644
--- a/tests/test_normalize_full_core_make_function.py
+++ b/tests/test_normalize_full_core_make_function.py
@@ -71,7 +71,7 @@
 '''
 
 
-def test_removes_runtime_class_introspection_and_slices(
+def test_unpacks_native_list_spec_and_removes_slices(
     tmp_path: Path, monkeypatch,
 ) -> None:
     path = tmp_path / "vm.py"
@@ -81,11 +81,16 @@ def test_removes_runtime_class_introspection_and_slices(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "nested: CodeObject = spec" in source
-    assert "if nested is None:" in source
+    assert "spec_size = len(spec)" in source
+    assert "if spec_size == 4:" in source
+    assert "nested: CodeObject = spec[0]" in source
+    assert "default_count = spec[1]" in source
+    assert "kw_default_count = spec[2]" in source
+    assert "annotations = spec[3]" in source
     assert "while default_index < default_count:" in source
     assert "while kw_index < kw_default_count:" in source
     assert "for name in nested.free_names:" in source
+    assert "isinstance(spec, tuple)" not in source
     assert "isinstance(nested, CodeObject)" not in source
     assert "frame.stack[-count:]" not in source
     assert "values[:default_count]" not in source
@@ -101,7 +106,7 @@ def test_accepts_native_semantics_intermediate_shape(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "nested: CodeObject = spec" in source
+    assert "nested: CodeObject = spec[0]" in source
     assert "discarded_default = frame.stack.pop()" in source
     assert "_full_core_probe_pop_tail(frame.stack, count)" not in source
     assert "_full_core_probe_copy_range(values, 0, default_count)" not in source

From 1b17c878d1956eadd96dc6a3aa9976492cc498a8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:18:58 -0500
Subject: [PATCH 252/450] Add native-safe frontend name index normalizer

---
 tools/normalize_full_core_name_index.py | 59 +++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 tools/normalize_full_core_name_index.py

diff --git a/tools/normalize_full_core_name_index.py b/tools/normalize_full_core_name_index.py
new file mode 100644
index 00000000..59f76e66
--- /dev/null
+++ b/tools/normalize_full_core_name_index.py
@@ -0,0 +1,59 @@
+"""Replace exception-driven frontend name lookup with a native-safe loop.
+
+The native compiler leaves the caught ValueError in its global exception state
+when ``list.index`` misses.  `_Lowerer.name_index` then returns a valid index,
+but the surrounding source execution is still reported as a type error.  An
+explicit loop has the same deduplication semantics without raising.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/frontend.py")
+
+_OLD = '''    def name_index(self, value: str) -> int:
+        try:
+            return self.names.index(value)
+        except ValueError:
+            self.names.append(value)
+            return len(self.names) - 1
+'''
+
+_NEW = '''    def name_index(self, value: str) -> int:
+        index = 0
+        while index < len(self.names):
+            if self.names[index] == value:
+                return index
+            index += 1
+        self.names.append(value)
+        return len(self.names) - 1
+'''
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    count = source.count(_OLD)
+    if count != 1:
+        raise RuntimeError(
+            f"native frontend name_index expected one exception lookup, found {count}"
+        )
+    source = source.replace(_OLD, _NEW, 1)
+    PATH.write_text(source, encoding="utf-8")
+
+    if ".names.index(" in source:
+        raise RuntimeError("native frontend still contains exception-driven name lookup")
+    required = (
+        "while index < len(self.names):",
+        "if self.names[index] == value:",
+        "self.names.append(value)",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native frontend name_index validation failed: {missing}")
+    print("NORMALIZED NATIVE FRONTEND NAME INDEX", count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 0468abb775ac28502fa767dac3f5dd3d0087bf8a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:19:40 -0500
Subject: [PATCH 253/450] Apply native-safe frontend name lookup

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 2f04398a..a0fbd0f6 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -23,6 +23,7 @@
 )
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
 from tools.normalize_full_core_make_function import main as normalize_make_function
+from tools.normalize_full_core_name_index import main as normalize_name_index
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_parser_expressions import (
     main as normalize_native_parser_expressions,
@@ -121,6 +122,7 @@ def main() -> int:
     normalize_lambdas()
     normalize_native_semantics()
     normalize_opcode_maps()
+    normalize_name_index()
     normalize_reference_runtime()
 
     materialize_reference_entry()

From 2e124713d809cc0661bab16d936de92775f31870 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:19:58 -0500
Subject: [PATCH 254/450] Test native-safe frontend name lookup

---
 tests/test_normalize_full_core_name_index.py | 51 ++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 tests/test_normalize_full_core_name_index.py

diff --git a/tests/test_normalize_full_core_name_index.py b/tests/test_normalize_full_core_name_index.py
new file mode 100644
index 00000000..183befec
--- /dev/null
+++ b/tests/test_normalize_full_core_name_index.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_name_index as normalizer
+
+
+SOURCE = '''class _Lowerer:
+    def name_index(self, value: str) -> int:
+        try:
+            return self.names.index(value)
+        except ValueError:
+            self.names.append(value)
+            return len(self.names) - 1
+'''
+
+
+def test_replaces_exception_lookup_with_direct_loop(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "while index < len(self.names):" in source
+    assert "if self.names[index] == value:" in source
+    assert "self.names.append(value)" in source
+    assert ".names.index(" not in source
+    namespace: dict[str, object] = {}
+    exec(source, namespace)
+    lowerer = namespace["_Lowerer"]()
+    lowerer.names = ["alpha"]
+    assert lowerer.name_index("alpha") == 0
+    assert lowerer.name_index("beta") == 1
+    assert lowerer.names == ["alpha", "beta"]
+
+
+def test_fails_closed_when_shape_changes(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text("class _Lowerer:\n    pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "expected one exception lookup" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing name_index implementation")

From 7a3010b8ee93430ac9855a66a03855cea9341b89 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:22:51 -0500
Subject: [PATCH 255/450] Canonicalize native function specifications

---
 tools/normalize_full_core_function_specs.py | 57 +++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tools/normalize_full_core_function_specs.py

diff --git a/tools/normalize_full_core_function_specs.py b/tools/normalize_full_core_function_specs.py
new file mode 100644
index 00000000..38215939
--- /dev/null
+++ b/tools/normalize_full_core_function_specs.py
@@ -0,0 +1,57 @@
+"""Canonicalize every frontend MAKE_FUNCTION constant to four fields.
+
+Normal function definitions already emit ``(code, defaults, kw_defaults,
+annotations)``. Lambdas historically emitted only three fields. The native VM
+cannot safely inspect the runtime container shape because tuple constants are
+materialized as native lists and the pinned compiler lowers ``len(spec)`` to
+``strlen``. Give every producer the same fixed layout instead.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/frontend.py")
+
+_OLD_LAMBDA = (
+    "            self.emit(Op.MAKE_FUNCTION, "
+    "self.constant((nested.finish(), len(node.args.defaults), 0)))"
+)
+_NEW_LAMBDA = (
+    "            self.emit(Op.MAKE_FUNCTION, "
+    "self.constant((nested.finish(), len(node.args.defaults), 0, {})))"
+)
+_NORMAL_FUNCTION_MARKER = (
+    "self.constant((nested.finish(), len(node.args.defaults), "
+    "kw_default_count, annotations))"
+)
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    lambda_count = source.count(_OLD_LAMBDA)
+    if lambda_count != 1:
+        raise RuntimeError(
+            "native frontend lambda function spec expected one three-field "
+            f"producer, found {lambda_count}"
+        )
+    normal_count = source.count(_NORMAL_FUNCTION_MARKER)
+    if normal_count != 1:
+        raise RuntimeError(
+            "native frontend function spec expected one four-field producer, "
+            f"found {normal_count}"
+        )
+
+    source = source.replace(_OLD_LAMBDA, _NEW_LAMBDA, 1)
+    PATH.write_text(source, encoding="utf-8")
+
+    if _OLD_LAMBDA in source:
+        raise RuntimeError("native frontend still emits a three-field lambda spec")
+    if source.count(_NEW_LAMBDA) != 1 or source.count(_NORMAL_FUNCTION_MARKER) != 1:
+        raise RuntimeError("native frontend four-field function specs were not preserved")
+    print("CANONICALIZED NATIVE FUNCTION SPECS", lambda_count + normal_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 16fa96fefe4697cd38308c1fba0045b9aa27cbac Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:23:21 -0500
Subject: [PATCH 256/450] Use canonical native MAKE_FUNCTION layout

---
 tools/normalize_full_core_make_function.py | 39 ++++++++--------------
 1 file changed, 13 insertions(+), 26 deletions(-)

diff --git a/tools/normalize_full_core_make_function.py b/tools/normalize_full_core_make_function.py
index 63f08bbd..70ccda14 100644
--- a/tools/normalize_full_core_make_function.py
+++ b/tools/normalize_full_core_make_function.py
@@ -1,10 +1,9 @@
 """Normalize MAKE_FUNCTION for the native compiler.
 
-The compiled VM materializes frontend tuple constants as native list values.  The
-old handler guarded unpacking with ``isinstance(spec, tuple)``, so native function
-specifications were left packed and then mistaken for a CodeObject.  Unpack the
-known 2/3/4-item specification by length and index instead.  The frontend is the
-only producer of MAKE_FUNCTION constants, so any other shape is rejected.
+The frontend is normalized to emit one canonical four-field native list for
+all functions and lambdas: ``[code, default_count, kw_default_count,
+annotations]``. Unpack those fields directly. Runtime tuple/list introspection
+is unsafe here because the pinned compiler lowers ``len(spec)`` to ``strlen``.
 
 The block also avoids slices and comprehensions because native slice objects are
 intentionally disabled during bootstrap.
@@ -21,25 +20,10 @@
 
 _REPLACEMENT = '''                elif op is Op.MAKE_FUNCTION:
                      spec = frame.code.constants[instr.arg]
-                     spec_size = len(spec)
-                     default_count = 0
-                     kw_default_count = 0
-                     annotations: dict[str, object] = {}
-                     if spec_size == 4:
-                         nested: CodeObject = spec[0]
-                         default_count = spec[1]
-                         kw_default_count = spec[2]
-                         annotations = spec[3]
-                     elif spec_size == 3:
-                         nested: CodeObject = spec[0]
-                         default_count = spec[1]
-                         kw_default_count = spec[2]
-                     elif spec_size == 2:
-                         nested: CodeObject = spec[0]
-                         default_count = spec[1]
-                     else:
-                         _raise_typed("TypeError: invalid function constant")
-                         nested: CodeObject = spec[0]
+                     nested: CodeObject = spec[0]
+                     default_count = spec[1]
+                     kw_default_count = spec[2]
+                     annotations: dict[str, object] = spec[3]
                      count = default_count + kw_default_count
                      if len(frame.stack) < count:
                          _raise_typed("RuntimeError: default stack underflow")
@@ -124,9 +108,10 @@ def main() -> int:
 
     installed = source[start:start + len(_REPLACEMENT)]
     validation = (
-        "spec_size = len(spec)",
-        "if spec_size == 4:",
         "nested: CodeObject = spec[0]",
+        "default_count = spec[1]",
+        "kw_default_count = spec[2]",
+        "annotations: dict[str, object] = spec[3]",
         "while default_index < default_count:",
         "while kw_index < kw_default_count:",
         "for name in nested.free_names:",
@@ -136,6 +121,8 @@ def main() -> int:
     if absent:
         raise RuntimeError(f"native MAKE_FUNCTION validation failed: {absent}")
     forbidden = (
+        "len(spec)",
+        "spec_size",
         "isinstance(spec, tuple)",
         "isinstance(nested, CodeObject)",
         "nested: CodeObject = spec\n",

From 5713ff2d6dc5e134c6424f65f55d2b81c8dec7c8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:23:51 -0500
Subject: [PATCH 257/450] Test canonical native MAKE_FUNCTION layout

---
 tests/test_normalize_full_core_make_function.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_core_make_function.py b/tests/test_normalize_full_core_make_function.py
index 792a7ab1..85cefce9 100644
--- a/tests/test_normalize_full_core_make_function.py
+++ b/tests/test_normalize_full_core_make_function.py
@@ -71,7 +71,7 @@
 '''
 
 
-def test_unpacks_native_list_spec_and_removes_slices(
+def test_unpacks_canonical_four_field_spec_without_introspection(
     tmp_path: Path, monkeypatch,
 ) -> None:
     path = tmp_path / "vm.py"
@@ -81,15 +81,15 @@ def test_unpacks_native_list_spec_and_removes_slices(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "spec_size = len(spec)" in source
-    assert "if spec_size == 4:" in source
     assert "nested: CodeObject = spec[0]" in source
     assert "default_count = spec[1]" in source
     assert "kw_default_count = spec[2]" in source
-    assert "annotations = spec[3]" in source
+    assert "annotations: dict[str, object] = spec[3]" in source
     assert "while default_index < default_count:" in source
     assert "while kw_index < kw_default_count:" in source
     assert "for name in nested.free_names:" in source
+    assert "len(spec)" not in source
+    assert "spec_size" not in source
     assert "isinstance(spec, tuple)" not in source
     assert "isinstance(nested, CodeObject)" not in source
     assert "frame.stack[-count:]" not in source
@@ -107,6 +107,7 @@ def test_accepts_native_semantics_intermediate_shape(
 
     source = path.read_text(encoding="utf-8")
     assert "nested: CodeObject = spec[0]" in source
+    assert "annotations: dict[str, object] = spec[3]" in source
     assert "discarded_default = frame.stack.pop()" in source
     assert "_full_core_probe_pop_tail(frame.stack, count)" not in source
     assert "_full_core_probe_copy_range(values, 0, default_count)" not in source

From 037e299b0b3d15e065ca15ce18a4502986282de2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:24:07 -0500
Subject: [PATCH 258/450] Test canonical native function specifications

---
 ...test_normalize_full_core_function_specs.py | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 tests/test_normalize_full_core_function_specs.py

diff --git a/tests/test_normalize_full_core_function_specs.py b/tests/test_normalize_full_core_function_specs.py
new file mode 100644
index 00000000..d401bb08
--- /dev/null
+++ b/tests/test_normalize_full_core_function_specs.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_function_specs as normalizer
+
+
+SOURCE = '''def lower_function(node):
+    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), kw_default_count, annotations)))
+
+def lower_lambda(node):
+    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
+'''
+
+
+def test_canonicalizes_lambda_to_four_fields(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "(nested.finish(), len(node.args.defaults), 0, {})" in source
+    assert "(nested.finish(), len(node.args.defaults), 0))" not in source
+    assert "kw_default_count, annotations" in source
+
+
+def test_fails_closed_without_lambda_producer(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(SOURCE.replace("def lower_lambda", "def other_lambda").replace(
+        "    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))\n",
+        "    pass\n",
+    ), encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "lambda function spec" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing lambda function spec")

From 2174e1153fb6729bea0c2cc48d7d4da9581de547 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:24:37 -0500
Subject: [PATCH 259/450] Wire canonical native function specifications

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index a0fbd0f6..8b7de685 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -18,6 +18,7 @@
 from tools.normalize_full_core_extended_semantics_compat import (
     main as normalize_extended_semantics,
 )
+from tools.normalize_full_core_function_specs import main as normalize_function_specs
 from tools.normalize_full_core_keyword_calls import (
     main as normalize_keyword_calls,
 )
@@ -120,6 +121,7 @@ def main() -> int:
     # These passes prepare the source modules imported by the generated entry.
     normalize_probe()
     normalize_lambdas()
+    normalize_function_specs()
     normalize_native_semantics()
     normalize_opcode_maps()
     normalize_name_index()

From aefee028de527972eafeffd41bf5396ccf677b76 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:26:11 -0500
Subject: [PATCH 260/450] Make function-spec rewrite indentation independent

---
 tools/normalize_full_core_function_specs.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_function_specs.py b/tools/normalize_full_core_function_specs.py
index 38215939..82e43866 100644
--- a/tools/normalize_full_core_function_specs.py
+++ b/tools/normalize_full_core_function_specs.py
@@ -14,11 +14,11 @@
 PATH = Path("src/portapy/core/frontend.py")
 
 _OLD_LAMBDA = (
-    "            self.emit(Op.MAKE_FUNCTION, "
+    "self.emit(Op.MAKE_FUNCTION, "
     "self.constant((nested.finish(), len(node.args.defaults), 0)))"
 )
 _NEW_LAMBDA = (
-    "            self.emit(Op.MAKE_FUNCTION, "
+    "self.emit(Op.MAKE_FUNCTION, "
     "self.constant((nested.finish(), len(node.args.defaults), 0, {})))"
 )
 _NORMAL_FUNCTION_MARKER = (

From ca5f35c056d17da80b6c11f67bc8238669d218bc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:32:11 -0500
Subject: [PATCH 261/450] Count native function defaults explicitly

---
 tools/normalize_full_core_function_specs.py | 103 +++++++++++++-------
 1 file changed, 69 insertions(+), 34 deletions(-)

diff --git a/tools/normalize_full_core_function_specs.py b/tools/normalize_full_core_function_specs.py
index 82e43866..ccc58c9c 100644
--- a/tools/normalize_full_core_function_specs.py
+++ b/tools/normalize_full_core_function_specs.py
@@ -1,10 +1,10 @@
-"""Canonicalize every frontend MAKE_FUNCTION constant to four fields.
+"""Canonicalize frontend MAKE_FUNCTION constants to four native-safe fields.
 
-Normal function definitions already emit ``(code, defaults, kw_defaults,
-annotations)``. Lambdas historically emitted only three fields. The native VM
-cannot safely inspect the runtime container shape because tuple constants are
-materialized as native lists and the pinned compiler lowers ``len(spec)`` to
-``strlen``. Give every producer the same fixed layout instead.
+The pinned compiler cannot safely lower ``len(node.args.defaults)`` because the
+opaque AST attribute is mistaken for text and measured with ``strlen``. Count
+default expressions while emitting them, and give every function/lambda the
+same fixed specification layout:
+``[code, default_count, kw_default_count, annotations]``.
 """
 from __future__ import annotations
 
@@ -13,43 +13,78 @@
 
 PATH = Path("src/portapy/core/frontend.py")
 
-_OLD_LAMBDA = (
-    "self.emit(Op.MAKE_FUNCTION, "
-    "self.constant((nested.finish(), len(node.args.defaults), 0)))"
-)
-_NEW_LAMBDA = (
-    "self.emit(Op.MAKE_FUNCTION, "
-    "self.constant((nested.finish(), len(node.args.defaults), 0, {})))"
-)
-_NORMAL_FUNCTION_MARKER = (
+_LAMBDA_OLD = '''            for default in node.args.defaults:
+                self.expr(default)
+            self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
+'''
+_LAMBDA_NEW = '''            lambda_default_count = 0
+            for default in node.args.defaults:
+                self.expr(default)
+                lambda_default_count += 1
+            self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), lambda_default_count, 0, {})))
+'''
+_FUNCTION_DEFAULTS_OLD = '''            for default in node.args.defaults:
+                self.expr(default)
+            kw_default_count = 0
+'''
+_FUNCTION_DEFAULTS_NEW = '''            default_count = 0
+            for default in node.args.defaults:
+                self.expr(default)
+                default_count += 1
+            kw_default_count = 0
+'''
+_FUNCTION_SPEC_OLD = (
     "self.constant((nested.finish(), len(node.args.defaults), "
     "kw_default_count, annotations))"
 )
+_FUNCTION_SPEC_NEW = (
+    "self.constant((nested.finish(), default_count, "
+    "kw_default_count, annotations))"
+)
+
+
+def _replace_one(source: str, old: str, new: str, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(f"native frontend {label} expected one source shape, found {count}")
+    return source.replace(old, new, 1)
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    lambda_count = source.count(_OLD_LAMBDA)
-    if lambda_count != 1:
-        raise RuntimeError(
-            "native frontend lambda function spec expected one three-field "
-            f"producer, found {lambda_count}"
-        )
-    normal_count = source.count(_NORMAL_FUNCTION_MARKER)
-    if normal_count != 1:
-        raise RuntimeError(
-            "native frontend function spec expected one four-field producer, "
-            f"found {normal_count}"
-        )
-
-    source = source.replace(_OLD_LAMBDA, _NEW_LAMBDA, 1)
+    source = _replace_one(source, _LAMBDA_OLD, _LAMBDA_NEW, "lambda defaults")
+    source = _replace_one(
+        source,
+        _FUNCTION_DEFAULTS_OLD,
+        _FUNCTION_DEFAULTS_NEW,
+        "function defaults",
+    )
+    source = _replace_one(
+        source,
+        _FUNCTION_SPEC_OLD,
+        _FUNCTION_SPEC_NEW,
+        "function specification",
+    )
     PATH.write_text(source, encoding="utf-8")
 
-    if _OLD_LAMBDA in source:
-        raise RuntimeError("native frontend still emits a three-field lambda spec")
-    if source.count(_NEW_LAMBDA) != 1 or source.count(_NORMAL_FUNCTION_MARKER) != 1:
-        raise RuntimeError("native frontend four-field function specs were not preserved")
-    print("CANONICALIZED NATIVE FUNCTION SPECS", lambda_count + normal_count)
+    forbidden = (
+        "self.constant((nested.finish(), len(node.args.defaults)",
+        _LAMBDA_OLD,
+        _FUNCTION_DEFAULTS_OLD,
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
+        raise RuntimeError(f"native frontend unsafe function specs remain: {remaining}")
+    required = (
+        "lambda_default_count += 1",
+        "(nested.finish(), lambda_default_count, 0, {})",
+        "default_count += 1",
+        "(nested.finish(), default_count, kw_default_count, annotations)",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native frontend function spec validation failed: {missing}")
+    print("CANONICALIZED NATIVE FUNCTION SPECS", 2)
     return 0
 
 

From 770ff72dd293207306b0e052c09ed43790df7f89 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 11:32:39 -0500
Subject: [PATCH 262/450] Test explicit native function default counts

---
 ...test_normalize_full_core_function_specs.py | 53 +++++++++++++------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/tests/test_normalize_full_core_function_specs.py b/tests/test_normalize_full_core_function_specs.py
index d401bb08..b2046c90 100644
--- a/tests/test_normalize_full_core_function_specs.py
+++ b/tests/test_normalize_full_core_function_specs.py
@@ -5,15 +5,26 @@
 from tools import normalize_full_core_function_specs as normalizer
 
 
-SOURCE = '''def lower_function(node):
-    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), kw_default_count, annotations)))
+SOURCE = '''class Lowerer:
+    def lower_lambda(self, node):
+            for default in node.args.defaults:
+                self.expr(default)
+            self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
 
-def lower_lambda(node):
-    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
+    def lower_function(self, node):
+            for default in node.args.defaults:
+                self.expr(default)
+            kw_default_count = 0
+            self.emit(
+                Op.MAKE_FUNCTION,
+                self.constant((nested.finish(), len(node.args.defaults), kw_default_count, annotations)),
+            )
 '''
 
 
-def test_canonicalizes_lambda_to_four_fields(tmp_path: Path, monkeypatch) -> None:
+def test_counts_defaults_and_canonicalizes_four_fields(
+    tmp_path: Path, monkeypatch,
+) -> None:
     path = tmp_path / "frontend.py"
     path.write_text(SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
@@ -21,22 +32,34 @@ def test_canonicalizes_lambda_to_four_fields(tmp_path: Path, monkeypatch) -> Non
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "(nested.finish(), len(node.args.defaults), 0, {})" in source
-    assert "(nested.finish(), len(node.args.defaults), 0))" not in source
-    assert "kw_default_count, annotations" in source
+    assert "lambda_default_count = 0" in source
+    assert "lambda_default_count += 1" in source
+    assert "(nested.finish(), lambda_default_count, 0, {})" in source
+    assert "default_count = 0" in source
+    assert "default_count += 1" in source
+    assert "(nested.finish(), default_count, kw_default_count, annotations)" in source
+    assert "len(node.args.defaults)" not in source
 
 
-def test_fails_closed_without_lambda_producer(tmp_path: Path, monkeypatch) -> None:
+def test_fails_closed_without_lambda_defaults_shape(
+    tmp_path: Path, monkeypatch,
+) -> None:
     path = tmp_path / "frontend.py"
-    path.write_text(SOURCE.replace("def lower_lambda", "def other_lambda").replace(
-        "    self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))\n",
-        "    pass\n",
-    ), encoding="utf-8")
+    path.write_text(
+        SOURCE.replace(
+            '''            for default in node.args.defaults:
+                self.expr(default)
+            self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
+''',
+            "            pass\n",
+        ),
+        encoding="utf-8",
+    )
     monkeypatch.setattr(normalizer, "PATH", path)
 
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "lambda function spec" in str(error)
+        assert "lambda defaults" in str(error)
     else:
-        raise AssertionError("normalizer accepted a missing lambda function spec")
+        raise AssertionError("normalizer accepted a missing lambda defaults producer")

From 48a82a509624177ed48dea0312a00aba244a2667 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:13:08 -0500
Subject: [PATCH 263/450] Normalize native function argument binding

---
 tools/normalize_full_core_function_binding.py | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 tools/normalize_full_core_function_binding.py

diff --git a/tools/normalize_full_core_function_binding.py b/tools/normalize_full_core_function_binding.py
new file mode 100644
index 00000000..65db563d
--- /dev/null
+++ b/tools/normalize_full_core_function_binding.py
@@ -0,0 +1,85 @@
+"""Replace host-style function argument binding with compiler-safe loops.
+
+The pinned native compiler lowers ``dict(zip(names, positional))`` by replacing
+``zip(...)`` with a null value and then dereferencing it as a list.  This
+crashes as soon as an interpreted function is called.  Dict comprehensions
+used for ``**kwargs`` have the same unsafe lowering shape, so normalize both
+operations into explicit loops before native semantic rewriting.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+
+_POSITIONAL_OLD = '''            positional = list(args[:total])
+            locals_ = dict(zip(target.code.arg_names, positional))
+'''
+
+_POSITIONAL_NEW = '''            positional = list(args[:total])
+            locals_: dict[str, object] = {}
+            bind_index = 0
+            while bind_index < len(positional) and bind_index < len(target.code.arg_names):
+                locals_[target.code.arg_names[bind_index]] = positional[bind_index]
+                bind_index += 1
+'''
+
+_KWARGS_OLD = '''            if target.code.kwarg_name:
+                locals_[target.code.kwarg_name] = {
+                    name: value for name, value in kwargs.items()
+                    if name in target.code.posonly_names or (
+                        name not in target.code.arg_names and name not in target.code.kwonly_names
+                    )
+                }
+'''
+
+_KWARGS_NEW = '''            if target.code.kwarg_name:
+                extra_kwargs: dict[str, object] = {}
+                for name in kwargs:
+                    if name in target.code.posonly_names or (
+                        name not in target.code.arg_names and name not in target.code.kwonly_names
+                    ):
+                        extra_kwargs[name] = kwargs[name]
+                locals_[target.code.kwarg_name] = extra_kwargs
+'''
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    positional_count = source.count(_POSITIONAL_OLD)
+    kwargs_count = source.count(_KWARGS_OLD)
+    if positional_count != 1:
+        raise RuntimeError(
+            "native function positional binding source shape changed: "
+            f"expected 1, found {positional_count}"
+        )
+    if kwargs_count != 1:
+        raise RuntimeError(
+            "native function kwargs binding source shape changed: "
+            f"expected 1, found {kwargs_count}"
+        )
+
+    source = source.replace(_POSITIONAL_OLD, _POSITIONAL_NEW, 1)
+    source = source.replace(_KWARGS_OLD, _KWARGS_NEW, 1)
+    PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        "locals_: dict[str, object] = {}",
+        "while bind_index < len(positional)",
+        "extra_kwargs: dict[str, object] = {}",
+        "extra_kwargs[name] = kwargs[name]",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native function binding validation failed: {missing}")
+    forbidden = ("dict(zip(", "for name, value in kwargs.items()")
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
+        raise RuntimeError(f"unsafe native function binding remains: {remaining}")
+    print("NORMALIZED NATIVE FUNCTION BINDING", positional_count, kwargs_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 8d9aa7b25e057aa33b7361f3c3c49f385fa3c9df Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:13:29 -0500
Subject: [PATCH 264/450] Test native function binding normalization

---
 ...st_normalize_full_core_function_binding.py | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 tests/test_normalize_full_core_function_binding.py

diff --git a/tests/test_normalize_full_core_function_binding.py b/tests/test_normalize_full_core_function_binding.py
new file mode 100644
index 00000000..2778bd39
--- /dev/null
+++ b/tests/test_normalize_full_core_function_binding.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_function_binding as normalizer
+
+
+_SOURCE = '''class VirtualMachine:
+    def _call(self, target, args, kwargs=None):
+            positional = list(args[:total])
+            locals_ = dict(zip(target.code.arg_names, positional))
+            if target.code.kwarg_name:
+                locals_[target.code.kwarg_name] = {
+                    name: value for name, value in kwargs.items()
+                    if name in target.code.posonly_names or (
+                        name not in target.code.arg_names and name not in target.code.kwonly_names
+                    )
+                }
+            return locals_
+'''
+
+
+def test_replaces_zip_and_kwargs_comprehension(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "dict(zip(" not in source
+    assert "for name, value in kwargs.items()" not in source
+    assert "while bind_index < len(positional)" in source
+    assert "locals_[target.code.arg_names[bind_index]] = positional[bind_index]" in source
+    assert "extra_kwargs[name] = kwargs[name]" in source
+
+
+def test_fails_closed_when_binding_shape_changes(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text("class VirtualMachine: pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "source shape changed" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unknown function binding shape")

From 2581994990907121124b7fc2f477af49376d997f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:13:59 -0500
Subject: [PATCH 265/450] Run native function binding normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 8b7de685..b4f68fe7 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -18,6 +18,9 @@
 from tools.normalize_full_core_extended_semantics_compat import (
     main as normalize_extended_semantics,
 )
+from tools.normalize_full_core_function_binding import (
+    main as normalize_function_binding,
+)
 from tools.normalize_full_core_function_specs import main as normalize_function_specs
 from tools.normalize_full_core_keyword_calls import (
     main as normalize_keyword_calls,
@@ -122,6 +125,7 @@ def main() -> int:
     normalize_probe()
     normalize_lambdas()
     normalize_function_specs()
+    normalize_function_binding()
     normalize_native_semantics()
     normalize_opcode_maps()
     normalize_name_index()

From 5ef9f53812a9972c16453613f8b93c75b43f6447 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:17:00 -0500
Subject: [PATCH 266/450] Narrow function binding validation

---
 tools/normalize_full_core_function_binding.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/tools/normalize_full_core_function_binding.py b/tools/normalize_full_core_function_binding.py
index 65db563d..53a612e2 100644
--- a/tools/normalize_full_core_function_binding.py
+++ b/tools/normalize_full_core_function_binding.py
@@ -73,10 +73,8 @@ def main() -> int:
     missing = [marker for marker in required if marker not in source]
     if missing:
         raise RuntimeError(f"native function binding validation failed: {missing}")
-    forbidden = ("dict(zip(", "for name, value in kwargs.items()")
-    remaining = [marker for marker in forbidden if marker in source]
-    if remaining:
-        raise RuntimeError(f"unsafe native function binding remains: {remaining}")
+    if _POSITIONAL_OLD in source or _KWARGS_OLD in source:
+        raise RuntimeError("unsafe native function binding source block remains")
     print("NORMALIZED NATIVE FUNCTION BINDING", positional_count, kwargs_count)
     return 0
 

From 25653de536478ac2798b6640dfdf98724a6fe79b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:21:29 -0500
Subject: [PATCH 267/450] Make function binding normalization idempotent

---
 tools/normalize_full_core_function_binding.py | 47 +++++++++++--------
 1 file changed, 28 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_function_binding.py b/tools/normalize_full_core_function_binding.py
index 53a612e2..f795bb3e 100644
--- a/tools/normalize_full_core_function_binding.py
+++ b/tools/normalize_full_core_function_binding.py
@@ -1,10 +1,10 @@
 """Replace host-style function argument binding with compiler-safe loops.
 
 The pinned native compiler lowers ``dict(zip(names, positional))`` by replacing
-``zip(...)`` with a null value and then dereferencing it as a list.  This
-crashes as soon as an interpreted function is called.  Dict comprehensions
-used for ``**kwargs`` have the same unsafe lowering shape, so normalize both
-operations into explicit loops before native semantic rewriting.
+``zip(...)`` with a null value and then dereferencing it as a list. This crashes
+as soon as an interpreted function is called. Dict comprehensions used for
+``**kwargs`` have the same unsafe lowering shape, so normalize both operations
+into explicit loops before native semantic rewriting.
 """
 from __future__ import annotations
 
@@ -45,23 +45,32 @@
 '''
 
 
+def _state(source: str, old: str, new: str, label: str) -> str:
+    old_count = source.count(old)
+    new_count = source.count(new)
+    if old_count == 1 and new_count == 0:
+        return "original"
+    if old_count == 0 and new_count == 1:
+        return "normalized"
+    raise RuntimeError(
+        f"native function {label} binding source shape changed: "
+        f"old={old_count}, normalized={new_count}"
+    )
+
+
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    positional_count = source.count(_POSITIONAL_OLD)
-    kwargs_count = source.count(_KWARGS_OLD)
-    if positional_count != 1:
-        raise RuntimeError(
-            "native function positional binding source shape changed: "
-            f"expected 1, found {positional_count}"
-        )
-    if kwargs_count != 1:
-        raise RuntimeError(
-            "native function kwargs binding source shape changed: "
-            f"expected 1, found {kwargs_count}"
-        )
-
-    source = source.replace(_POSITIONAL_OLD, _POSITIONAL_NEW, 1)
-    source = source.replace(_KWARGS_OLD, _KWARGS_NEW, 1)
+    positional_state = _state(source, _POSITIONAL_OLD, _POSITIONAL_NEW, "positional")
+    kwargs_state = _state(source, _KWARGS_OLD, _KWARGS_NEW, "kwargs")
+
+    positional_count = 0
+    kwargs_count = 0
+    if positional_state == "original":
+        source = source.replace(_POSITIONAL_OLD, _POSITIONAL_NEW, 1)
+        positional_count = 1
+    if kwargs_state == "original":
+        source = source.replace(_KWARGS_OLD, _KWARGS_NEW, 1)
+        kwargs_count = 1
     PATH.write_text(source, encoding="utf-8")
 
     required = (

From f5ffbad51c768aab9e6be4649a3b9c7767243752 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:21:44 -0500
Subject: [PATCH 268/450] Test idempotent function binding normalization

---
 tests/test_normalize_full_core_function_binding.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/test_normalize_full_core_function_binding.py b/tests/test_normalize_full_core_function_binding.py
index 2778bd39..954b6286 100644
--- a/tests/test_normalize_full_core_function_binding.py
+++ b/tests/test_normalize_full_core_function_binding.py
@@ -35,6 +35,17 @@ def test_replaces_zip_and_kwargs_comprehension(tmp_path: Path, monkeypatch) -> N
     assert "extra_kwargs[name] = kwargs[name]" in source
 
 
+def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    first = path.read_text(encoding="utf-8")
+    assert normalizer.main() == 0
+    assert path.read_text(encoding="utf-8") == first
+
+
 def test_fails_closed_when_binding_shape_changes(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "vm.py"
     path.write_text("class VirtualMachine: pass\n", encoding="utf-8")

From 604c95c29b0acece6ac63af2054c7dcd8b217757 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:22:43 -0500
Subject: [PATCH 269/450] Order function binding before native semantics

---
 .github/workflows/native-full-core-probe.yml | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 4115e262..4ccefc7b 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -32,6 +32,7 @@ jobs:
         run: |
           python tools/normalize_full_core_probe.py
           python tools/normalize_full_core_lambdas.py
+          python tools/normalize_full_core_function_binding.py
           python tools/normalize_full_core_native_semantics.py
           python tools/normalize_full_core_opcode_maps.py
           python tools/normalize_full_core_validation.py
@@ -168,6 +169,8 @@ jobs:
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/normalize_full_core_lambdas.py
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          python tools/normalize_full_core_function_binding.py
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/normalize_full_core_native_semantics.py
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/normalize_full_core_opcode_maps.py
@@ -260,14 +263,14 @@ jobs:
             '```text'
           )
           if (Test-Path dist/windows-full-core-build.log) {
-            $lines += Get-Content dist/windows-full-core-build.log -Tail 180
+            $lines += Get-Content dist/windows-full-core-build.log | Select-Object -Last 180
           } else {
             $lines += 'No compiler log was produced.'
           }
           $lines += '```'
-          $path = "$env:RUNNER_TEMP\portapy-full-core-windows.md"
-          $lines | Set-Content -Encoding utf8 $path
-          gh pr comment "${{ github.event.pull_request.number }}" --body-file $path
+          $lines | Set-Content -Encoding utf8 $env:TEMP/portapy-full-core-windows.md
+          gh pr comment "${{ github.event.pull_request.number }}" `
+            --body-file $env:TEMP/portapy-full-core-windows.md
       - uses: actions/upload-artifact@v4
         if: always()
         with:

From 99730816d654c9617635fdbf9fd8d56a2633b351 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:27:47 -0500
Subject: [PATCH 270/450] Type native function argument names

---
 tools/normalize_full_core_function_binding.py | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_core_function_binding.py b/tools/normalize_full_core_function_binding.py
index f795bb3e..76034691 100644
--- a/tools/normalize_full_core_function_binding.py
+++ b/tools/normalize_full_core_function_binding.py
@@ -1,10 +1,10 @@
 """Replace host-style function argument binding with compiler-safe loops.
 
 The pinned native compiler lowers ``dict(zip(names, positional))`` by replacing
-``zip(...)`` with a null value and then dereferencing it as a list. This crashes
-as soon as an interpreted function is called. Dict comprehensions used for
-``**kwargs`` have the same unsafe lowering shape, so normalize both operations
-into explicit loops before native semantic rewriting.
+``zip(...)`` with a null value and then dereferencing it as a list. It also
+mis-infers an inline ``target.code.arg_names[index]`` access as an opaque value,
+which produces an invalid dictionary key. Normalize both argument binding and
+``**kwargs`` collection into explicitly typed loops.
 """
 from __future__ import annotations
 
@@ -18,10 +18,12 @@
 '''
 
 _POSITIONAL_NEW = '''            positional = list(args[:total])
+            argument_names: list[str] = target.code.arg_names
             locals_: dict[str, object] = {}
             bind_index = 0
-            while bind_index < len(positional) and bind_index < len(target.code.arg_names):
-                locals_[target.code.arg_names[bind_index]] = positional[bind_index]
+            while bind_index < len(positional) and bind_index < len(argument_names):
+                argument_name: str = argument_names[bind_index]
+                locals_[argument_name] = positional[bind_index]
                 bind_index += 1
 '''
 
@@ -74,8 +76,9 @@ def main() -> int:
     PATH.write_text(source, encoding="utf-8")
 
     required = (
-        "locals_: dict[str, object] = {}",
-        "while bind_index < len(positional)",
+        "argument_names: list[str] = target.code.arg_names",
+        "argument_name: str = argument_names[bind_index]",
+        "locals_[argument_name] = positional[bind_index]",
         "extra_kwargs: dict[str, object] = {}",
         "extra_kwargs[name] = kwargs[name]",
     )

From 1a11002d4890111d706b244eb70bd89fb85ccca7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:28:06 -0500
Subject: [PATCH 271/450] Test typed native function names

---
 tests/test_normalize_full_core_function_binding.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_function_binding.py b/tests/test_normalize_full_core_function_binding.py
index 954b6286..0f228479 100644
--- a/tests/test_normalize_full_core_function_binding.py
+++ b/tests/test_normalize_full_core_function_binding.py
@@ -30,8 +30,9 @@ def test_replaces_zip_and_kwargs_comprehension(tmp_path: Path, monkeypatch) -> N
     source = path.read_text(encoding="utf-8")
     assert "dict(zip(" not in source
     assert "for name, value in kwargs.items()" not in source
-    assert "while bind_index < len(positional)" in source
-    assert "locals_[target.code.arg_names[bind_index]] = positional[bind_index]" in source
+    assert "argument_names: list[str] = target.code.arg_names" in source
+    assert "argument_name: str = argument_names[bind_index]" in source
+    assert "locals_[argument_name] = positional[bind_index]" in source
     assert "extra_kwargs[name] = kwargs[name]" in source
 
 

From 9b0a9d483db74472a57a2ab1eb5ac20e14ae5280 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:38:06 -0500
Subject: [PATCH 272/450] Normalize native function parameter names

---
 ...lize_full_core_function_parameter_names.py | 106 ++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 tools/normalize_full_core_function_parameter_names.py

diff --git a/tools/normalize_full_core_function_parameter_names.py b/tools/normalize_full_core_function_parameter_names.py
new file mode 100644
index 00000000..6dbee6f6
--- /dev/null
+++ b/tools/normalize_full_core_function_parameter_names.py
@@ -0,0 +1,106 @@
+"""Preserve function parameter names through native frontend lowering.
+
+The pinned compiler treats ``arg.arg`` inside comprehensions as an opaque
+attribute and materializes null list elements. Those nulls become
+``CodeObject.arg_names`` entries and later crash dictionary hashing during
+function argument binding. Replace all parameter-name comprehensions and
+conditional attribute expressions with explicitly typed string loops.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/frontend.py")
+
+_ARGUMENTS_OLD = '''            function_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                function_arguments.append(argument)
+            nested = _Lowerer(node.name, [arg.arg for arg in function_arguments])
+'''
+
+_ARGUMENTS_NEW = '''            function_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                function_arguments.append(argument)
+            function_argument_names: list[str] = []
+            for argument in function_arguments:
+                function_argument_name: str = argument.arg
+                function_argument_names.append(function_argument_name)
+            nested = _Lowerer(node.name, function_argument_names)
+'''
+
+_SPECIAL_OLD = '''            nested.posonly_names = [arg.arg for arg in node.args.posonlyargs]
+            nested.kwonly_names = [arg.arg for arg in node.args.kwonlyargs]
+            nested.vararg_name = node.args.vararg.arg if node.args.vararg else None
+            nested.kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
+'''
+
+_SPECIAL_NEW = '''            positional_only_names: list[str] = []
+            for argument in node.args.posonlyargs:
+                positional_only_name: str = argument.arg
+                positional_only_names.append(positional_only_name)
+            nested.posonly_names = positional_only_names
+            keyword_only_names: list[str] = []
+            for argument in node.args.kwonlyargs:
+                keyword_only_name: str = argument.arg
+                keyword_only_names.append(keyword_only_name)
+            nested.kwonly_names = keyword_only_names
+            if node.args.vararg is not None:
+                variadic_positional_name: str = node.args.vararg.arg
+                nested.vararg_name = variadic_positional_name
+            else:
+                nested.vararg_name = None
+            if node.args.kwarg is not None:
+                variadic_keyword_name: str = node.args.kwarg.arg
+                nested.kwarg_name = variadic_keyword_name
+            else:
+                nested.kwarg_name = None
+'''
+
+
+def _state(source: str, old: str, new: str, label: str) -> str:
+    old_count = source.count(old)
+    new_count = source.count(new)
+    if old_count == 1 and new_count == 0:
+        return "original"
+    if old_count == 0 and new_count == 1:
+        return "normalized"
+    raise RuntimeError(
+        f"native function {label} parameter source shape changed: "
+        f"old={old_count}, normalized={new_count}"
+    )
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    argument_state = _state(source, _ARGUMENTS_OLD, _ARGUMENTS_NEW, "regular")
+    special_state = _state(source, _SPECIAL_OLD, _SPECIAL_NEW, "special")
+    argument_count = 0
+    special_count = 0
+    if argument_state == "original":
+        source = source.replace(_ARGUMENTS_OLD, _ARGUMENTS_NEW, 1)
+        argument_count = 1
+    if special_state == "original":
+        source = source.replace(_SPECIAL_OLD, _SPECIAL_NEW, 1)
+        special_count = 1
+    PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        "function_argument_name: str = argument.arg",
+        "nested = _Lowerer(node.name, function_argument_names)",
+        "positional_only_name: str = argument.arg",
+        "keyword_only_name: str = argument.arg",
+        "variadic_positional_name: str = node.args.vararg.arg",
+        "variadic_keyword_name: str = node.args.kwarg.arg",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native function parameter validation failed: {missing}")
+    if _ARGUMENTS_OLD in source or _SPECIAL_OLD in source:
+        raise RuntimeError("unsafe native function parameter extraction remains")
+    print("NORMALIZED NATIVE FUNCTION PARAMETER NAMES", argument_count, special_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e1b34965f12a9fe9a099e01689e60d9b642ce0bd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:38:26 -0500
Subject: [PATCH 273/450] Test native function parameter normalization

---
 ...lize_full_core_function_parameter_names.py | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 tests/test_normalize_full_core_function_parameter_names.py

diff --git a/tests/test_normalize_full_core_function_parameter_names.py b/tests/test_normalize_full_core_function_parameter_names.py
new file mode 100644
index 00000000..5559c627
--- /dev/null
+++ b/tests/test_normalize_full_core_function_parameter_names.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_function_parameter_names as normalizer
+
+
+_SOURCE = '''class _Lowerer:
+    def stmt(self, node):
+            function_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                function_arguments.append(argument)
+            nested = _Lowerer(node.name, [arg.arg for arg in function_arguments])
+            nested.posonly_names = [arg.arg for arg in node.args.posonlyargs]
+            nested.kwonly_names = [arg.arg for arg in node.args.kwonlyargs]
+            nested.vararg_name = node.args.vararg.arg if node.args.vararg else None
+            nested.kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
+'''
+
+
+def test_replaces_opaque_parameter_extraction(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "[arg.arg for arg in function_arguments]" not in source
+    assert "[arg.arg for arg in node.args.posonlyargs]" not in source
+    assert "[arg.arg for arg in node.args.kwonlyargs]" not in source
+    assert "function_argument_name: str = argument.arg" in source
+    assert "positional_only_name: str = argument.arg" in source
+    assert "keyword_only_name: str = argument.arg" in source
+    assert "variadic_positional_name: str = node.args.vararg.arg" in source
+    assert "variadic_keyword_name: str = node.args.kwarg.arg" in source
+
+
+def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    first = path.read_text(encoding="utf-8")
+    assert normalizer.main() == 0
+    assert path.read_text(encoding="utf-8") == first
+
+
+def test_fails_closed_for_unknown_shape(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "frontend.py"
+    path.write_text("class _Lowerer: pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "source shape changed" in str(error)
+    else:
+        raise AssertionError("normalizer accepted unknown parameter extraction")

From 0b47001dc33dc694a1caab69bcce20b590c77f63 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:39:08 -0500
Subject: [PATCH 274/450] Normalize native function parameter names

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index b4f68fe7..e36a7559 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -21,6 +21,9 @@
 from tools.normalize_full_core_function_binding import (
     main as normalize_function_binding,
 )
+from tools.normalize_full_core_function_parameter_names import (
+    main as normalize_function_parameter_names,
+)
 from tools.normalize_full_core_function_specs import main as normalize_function_specs
 from tools.normalize_full_core_keyword_calls import (
     main as normalize_keyword_calls,
@@ -127,6 +130,7 @@ def main() -> int:
     normalize_function_specs()
     normalize_function_binding()
     normalize_native_semantics()
+    normalize_function_parameter_names()
     normalize_opcode_maps()
     normalize_name_index()
     normalize_reference_runtime()

From 23b7f3854bd97103a990d761e6f0482b142149fc Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:40:13 -0500
Subject: [PATCH 275/450] Use canonical full-core normalization pipeline

---
 .github/workflows/native-full-core-probe.yml | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 4ccefc7b..9e9d09ff 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -30,11 +30,6 @@ jobs:
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
       - name: Normalize probe source
         run: |
-          python tools/normalize_full_core_probe.py
-          python tools/normalize_full_core_lambdas.py
-          python tools/normalize_full_core_function_binding.py
-          python tools/normalize_full_core_native_semantics.py
-          python tools/normalize_full_core_opcode_maps.py
           python tools/normalize_full_core_validation.py
           mkdir -p dist/debug-tree
           python - <<'PY'
@@ -165,16 +160,6 @@ jobs:
       - name: Normalize probe source
         shell: powershell
         run: |
-          python tools/normalize_full_core_probe.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_lambdas.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_function_binding.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_native_semantics.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_opcode_maps.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/normalize_full_core_validation.py
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
       - name: Compile full frontend and VM probe

From 0f251c2b6135c1dfc57858c3e7b0a8befbc99191 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:45:13 -0500
Subject: [PATCH 276/450] Normalize lambda and function parameter names

---
 ...lize_full_core_function_parameter_names.py | 102 ++++++++++++++----
 1 file changed, 82 insertions(+), 20 deletions(-)

diff --git a/tools/normalize_full_core_function_parameter_names.py b/tools/normalize_full_core_function_parameter_names.py
index 6dbee6f6..7999bfd3 100644
--- a/tools/normalize_full_core_function_parameter_names.py
+++ b/tools/normalize_full_core_function_parameter_names.py
@@ -1,10 +1,11 @@
-"""Preserve function parameter names through native frontend lowering.
+"""Preserve function and lambda parameter names through native lowering.
 
 The pinned compiler treats ``arg.arg`` inside comprehensions as an opaque
 attribute and materializes null list elements. Those nulls become
 ``CodeObject.arg_names`` entries and later crash dictionary hashing during
-function argument binding. Replace all parameter-name comprehensions and
-conditional attribute expressions with explicitly typed string loops.
+function argument binding. Replace every function/lambda parameter-name
+comprehension and conditional attribute expression with explicitly typed
+string loops.
 """
 from __future__ import annotations
 
@@ -13,13 +14,13 @@
 
 PATH = Path("src/portapy/core/frontend.py")
 
-_ARGUMENTS_OLD = '''            function_arguments = list(node.args.posonlyargs)
+_FUNCTION_ARGUMENTS_OLD = '''            function_arguments = list(node.args.posonlyargs)
             for argument in node.args.args:
                 function_arguments.append(argument)
             nested = _Lowerer(node.name, [arg.arg for arg in function_arguments])
 '''
 
-_ARGUMENTS_NEW = '''            function_arguments = list(node.args.posonlyargs)
+_FUNCTION_ARGUMENTS_NEW = '''            function_arguments = list(node.args.posonlyargs)
             for argument in node.args.args:
                 function_arguments.append(argument)
             function_argument_names: list[str] = []
@@ -29,6 +30,22 @@
             nested = _Lowerer(node.name, function_argument_names)
 '''
 
+_LAMBDA_ARGUMENTS_OLD = '''            lambda_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                lambda_arguments.append(argument)
+            nested = _Lowerer("<lambda>", [arg.arg for arg in lambda_arguments])
+'''
+
+_LAMBDA_ARGUMENTS_NEW = '''            lambda_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                lambda_arguments.append(argument)
+            lambda_argument_names: list[str] = []
+            for argument in lambda_arguments:
+                lambda_argument_name: str = argument.arg
+                lambda_argument_names.append(lambda_argument_name)
+            nested = _Lowerer("<lambda>", lambda_argument_names)
+'''
+
 _SPECIAL_OLD = '''            nested.posonly_names = [arg.arg for arg in node.args.posonlyargs]
             nested.kwonly_names = [arg.arg for arg in node.args.kwonlyargs]
             nested.vararg_name = node.args.vararg.arg if node.args.vararg else None
@@ -58,36 +75,68 @@
 '''
 
 
-def _state(source: str, old: str, new: str, label: str) -> str:
+def _state(
+    source: str,
+    old: str,
+    new: str,
+    label: str,
+    expected: int,
+) -> str:
     old_count = source.count(old)
     new_count = source.count(new)
-    if old_count == 1 and new_count == 0:
+    if old_count == expected and new_count == 0:
         return "original"
-    if old_count == 0 and new_count == 1:
+    if old_count == 0 and new_count == expected:
         return "normalized"
     raise RuntimeError(
-        f"native function {label} parameter source shape changed: "
-        f"old={old_count}, normalized={new_count}"
+        f"native {label} parameter source shape changed: "
+        f"old={old_count}, normalized={new_count}, expected={expected}"
     )
 
 
 def main() -> int:
     source = PATH.read_text(encoding="utf-8")
-    argument_state = _state(source, _ARGUMENTS_OLD, _ARGUMENTS_NEW, "regular")
-    special_state = _state(source, _SPECIAL_OLD, _SPECIAL_NEW, "special")
-    argument_count = 0
+    function_state = _state(
+        source,
+        _FUNCTION_ARGUMENTS_OLD,
+        _FUNCTION_ARGUMENTS_NEW,
+        "function regular",
+        1,
+    )
+    lambda_state = _state(
+        source,
+        _LAMBDA_ARGUMENTS_OLD,
+        _LAMBDA_ARGUMENTS_NEW,
+        "lambda regular",
+        1,
+    )
+    special_state = _state(
+        source,
+        _SPECIAL_OLD,
+        _SPECIAL_NEW,
+        "function/lambda special",
+        2,
+    )
+
+    function_count = 0
+    lambda_count = 0
     special_count = 0
-    if argument_state == "original":
-        source = source.replace(_ARGUMENTS_OLD, _ARGUMENTS_NEW, 1)
-        argument_count = 1
+    if function_state == "original":
+        source = source.replace(_FUNCTION_ARGUMENTS_OLD, _FUNCTION_ARGUMENTS_NEW, 1)
+        function_count = 1
+    if lambda_state == "original":
+        source = source.replace(_LAMBDA_ARGUMENTS_OLD, _LAMBDA_ARGUMENTS_NEW, 1)
+        lambda_count = 1
     if special_state == "original":
-        source = source.replace(_SPECIAL_OLD, _SPECIAL_NEW, 1)
-        special_count = 1
+        source = source.replace(_SPECIAL_OLD, _SPECIAL_NEW)
+        special_count = 2
     PATH.write_text(source, encoding="utf-8")
 
     required = (
         "function_argument_name: str = argument.arg",
         "nested = _Lowerer(node.name, function_argument_names)",
+        "lambda_argument_name: str = argument.arg",
+        'nested = _Lowerer("<lambda>", lambda_argument_names)',
         "positional_only_name: str = argument.arg",
         "keyword_only_name: str = argument.arg",
         "variadic_positional_name: str = node.args.vararg.arg",
@@ -96,9 +145,22 @@ def main() -> int:
     missing = [marker for marker in required if marker not in source]
     if missing:
         raise RuntimeError(f"native function parameter validation failed: {missing}")
-    if _ARGUMENTS_OLD in source or _SPECIAL_OLD in source:
+    forbidden = (
+        _FUNCTION_ARGUMENTS_OLD,
+        _LAMBDA_ARGUMENTS_OLD,
+        _SPECIAL_OLD,
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
         raise RuntimeError("unsafe native function parameter extraction remains")
-    print("NORMALIZED NATIVE FUNCTION PARAMETER NAMES", argument_count, special_count)
+    if source.count(_SPECIAL_NEW) != 2:
+        raise RuntimeError("native special parameter normalization lost a site")
+    print(
+        "NORMALIZED NATIVE FUNCTION PARAMETER NAMES",
+        function_count,
+        lambda_count,
+        special_count,
+    )
     return 0
 
 

From eefb198aef9f27cfd1b20a73524579865db38558 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:45:39 -0500
Subject: [PATCH 277/450] Test lambda and function parameter normalization

---
 ...lize_full_core_function_parameter_names.py | 29 ++++++++++++-------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/tests/test_normalize_full_core_function_parameter_names.py b/tests/test_normalize_full_core_function_parameter_names.py
index 5559c627..1cc242ec 100644
--- a/tests/test_normalize_full_core_function_parameter_names.py
+++ b/tests/test_normalize_full_core_function_parameter_names.py
@@ -5,17 +5,24 @@
 from tools import normalize_full_core_function_parameter_names as normalizer
 
 
+_SPECIAL = '''            nested.posonly_names = [arg.arg for arg in node.args.posonlyargs]
+            nested.kwonly_names = [arg.arg for arg in node.args.kwonlyargs]
+            nested.vararg_name = node.args.vararg.arg if node.args.vararg else None
+            nested.kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
+'''
+
 _SOURCE = '''class _Lowerer:
-    def stmt(self, node):
+    def expr(self, node):
+            lambda_arguments = list(node.args.posonlyargs)
+            for argument in node.args.args:
+                lambda_arguments.append(argument)
+            nested = _Lowerer("<lambda>", [arg.arg for arg in lambda_arguments])
+''' + _SPECIAL + '''    def stmt(self, node):
             function_arguments = list(node.args.posonlyargs)
             for argument in node.args.args:
                 function_arguments.append(argument)
             nested = _Lowerer(node.name, [arg.arg for arg in function_arguments])
-            nested.posonly_names = [arg.arg for arg in node.args.posonlyargs]
-            nested.kwonly_names = [arg.arg for arg in node.args.kwonlyargs]
-            nested.vararg_name = node.args.vararg.arg if node.args.vararg else None
-            nested.kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
-'''
+''' + _SPECIAL
 
 
 def test_replaces_opaque_parameter_extraction(tmp_path: Path, monkeypatch) -> None:
@@ -27,13 +34,15 @@ def test_replaces_opaque_parameter_extraction(tmp_path: Path, monkeypatch) -> No
 
     source = path.read_text(encoding="utf-8")
     assert "[arg.arg for arg in function_arguments]" not in source
+    assert "[arg.arg for arg in lambda_arguments]" not in source
     assert "[arg.arg for arg in node.args.posonlyargs]" not in source
     assert "[arg.arg for arg in node.args.kwonlyargs]" not in source
     assert "function_argument_name: str = argument.arg" in source
-    assert "positional_only_name: str = argument.arg" in source
-    assert "keyword_only_name: str = argument.arg" in source
-    assert "variadic_positional_name: str = node.args.vararg.arg" in source
-    assert "variadic_keyword_name: str = node.args.kwarg.arg" in source
+    assert "lambda_argument_name: str = argument.arg" in source
+    assert source.count("positional_only_name: str = argument.arg") == 2
+    assert source.count("keyword_only_name: str = argument.arg") == 2
+    assert source.count("variadic_positional_name: str = node.args.vararg.arg") == 2
+    assert source.count("variadic_keyword_name: str = node.args.kwarg.arg") == 2
 
 
 def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:

From fa793553cf47cc15461ce74362984efc3e369d5c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:03:11 -0500
Subject: [PATCH 278/450] Read native parameter names dynamically

---
 ...lize_full_core_function_parameter_names.py | 48 +++++++++++--------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/tools/normalize_full_core_function_parameter_names.py b/tools/normalize_full_core_function_parameter_names.py
index 7999bfd3..396d3cd2 100644
--- a/tools/normalize_full_core_function_parameter_names.py
+++ b/tools/normalize_full_core_function_parameter_names.py
@@ -1,11 +1,11 @@
 """Preserve function and lambda parameter names through native lowering.
 
-The pinned compiler treats ``arg.arg`` inside comprehensions as an opaque
-attribute and materializes null list elements. Those nulls become
-``CodeObject.arg_names`` entries and later crash dictionary hashing during
-function argument binding. Replace every function/lambda parameter-name
-comprehension and conditional attribute expression with explicitly typed
-string loops.
+The pinned compiler treats ``arg.arg`` on AST nodes as a statically opaque
+attribute and materializes null list elements, even when the read is moved out
+of a comprehension. Those nulls become ``CodeObject.arg_names`` entries and
+later crash dictionary hashing during function argument binding. Read the
+fields through dynamic ``getattr`` so the dict-backed native AST object is
+consulted at runtime and real string pointers are retained.
 """
 from __future__ import annotations
 
@@ -25,7 +25,7 @@
                 function_arguments.append(argument)
             function_argument_names: list[str] = []
             for argument in function_arguments:
-                function_argument_name: str = argument.arg
+                function_argument_name: str = getattr(argument, "arg")
                 function_argument_names.append(function_argument_name)
             nested = _Lowerer(node.name, function_argument_names)
 '''
@@ -41,7 +41,7 @@
                 lambda_arguments.append(argument)
             lambda_argument_names: list[str] = []
             for argument in lambda_arguments:
-                lambda_argument_name: str = argument.arg
+                lambda_argument_name: str = getattr(argument, "arg")
                 lambda_argument_names.append(lambda_argument_name)
             nested = _Lowerer("<lambda>", lambda_argument_names)
 '''
@@ -54,21 +54,23 @@
 
 _SPECIAL_NEW = '''            positional_only_names: list[str] = []
             for argument in node.args.posonlyargs:
-                positional_only_name: str = argument.arg
+                positional_only_name: str = getattr(argument, "arg")
                 positional_only_names.append(positional_only_name)
             nested.posonly_names = positional_only_names
             keyword_only_names: list[str] = []
             for argument in node.args.kwonlyargs:
-                keyword_only_name: str = argument.arg
+                keyword_only_name: str = getattr(argument, "arg")
                 keyword_only_names.append(keyword_only_name)
             nested.kwonly_names = keyword_only_names
-            if node.args.vararg is not None:
-                variadic_positional_name: str = node.args.vararg.arg
+            variadic_positional = getattr(node.args, "vararg")
+            if variadic_positional is not None:
+                variadic_positional_name: str = getattr(variadic_positional, "arg")
                 nested.vararg_name = variadic_positional_name
             else:
                 nested.vararg_name = None
-            if node.args.kwarg is not None:
-                variadic_keyword_name: str = node.args.kwarg.arg
+            variadic_keyword = getattr(node.args, "kwarg")
+            if variadic_keyword is not None:
+                variadic_keyword_name: str = getattr(variadic_keyword, "arg")
                 nested.kwarg_name = variadic_keyword_name
             else:
                 nested.kwarg_name = None
@@ -133,14 +135,16 @@ def main() -> int:
     PATH.write_text(source, encoding="utf-8")
 
     required = (
-        "function_argument_name: str = argument.arg",
+        'function_argument_name: str = getattr(argument, "arg")',
         "nested = _Lowerer(node.name, function_argument_names)",
-        "lambda_argument_name: str = argument.arg",
+        'lambda_argument_name: str = getattr(argument, "arg")',
         'nested = _Lowerer("<lambda>", lambda_argument_names)',
-        "positional_only_name: str = argument.arg",
-        "keyword_only_name: str = argument.arg",
-        "variadic_positional_name: str = node.args.vararg.arg",
-        "variadic_keyword_name: str = node.args.kwarg.arg",
+        'positional_only_name: str = getattr(argument, "arg")',
+        'keyword_only_name: str = getattr(argument, "arg")',
+        'variadic_positional = getattr(node.args, "vararg")',
+        'variadic_positional_name: str = getattr(variadic_positional, "arg")',
+        'variadic_keyword = getattr(node.args, "kwarg")',
+        'variadic_keyword_name: str = getattr(variadic_keyword, "arg")',
     )
     missing = [marker for marker in required if marker not in source]
     if missing:
@@ -149,6 +153,10 @@ def main() -> int:
         _FUNCTION_ARGUMENTS_OLD,
         _LAMBDA_ARGUMENTS_OLD,
         _SPECIAL_OLD,
+        "function_argument_name: str = argument.arg",
+        "lambda_argument_name: str = argument.arg",
+        "positional_only_name: str = argument.arg",
+        "keyword_only_name: str = argument.arg",
     )
     remaining = [marker for marker in forbidden if marker in source]
     if remaining:

From 651bb34ba9d81a22e5833c8bbd6c2cd2bc94cae0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:03:35 -0500
Subject: [PATCH 279/450] Test dynamic native parameter lookup

---
 ...rmalize_full_core_function_parameter_names.py | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/tests/test_normalize_full_core_function_parameter_names.py b/tests/test_normalize_full_core_function_parameter_names.py
index 1cc242ec..28038c11 100644
--- a/tests/test_normalize_full_core_function_parameter_names.py
+++ b/tests/test_normalize_full_core_function_parameter_names.py
@@ -37,12 +37,16 @@ def test_replaces_opaque_parameter_extraction(tmp_path: Path, monkeypatch) -> No
     assert "[arg.arg for arg in lambda_arguments]" not in source
     assert "[arg.arg for arg in node.args.posonlyargs]" not in source
     assert "[arg.arg for arg in node.args.kwonlyargs]" not in source
-    assert "function_argument_name: str = argument.arg" in source
-    assert "lambda_argument_name: str = argument.arg" in source
-    assert source.count("positional_only_name: str = argument.arg") == 2
-    assert source.count("keyword_only_name: str = argument.arg") == 2
-    assert source.count("variadic_positional_name: str = node.args.vararg.arg") == 2
-    assert source.count("variadic_keyword_name: str = node.args.kwarg.arg") == 2
+    assert 'function_argument_name: str = getattr(argument, "arg")' in source
+    assert 'lambda_argument_name: str = getattr(argument, "arg")' in source
+    assert source.count('positional_only_name: str = getattr(argument, "arg")') == 2
+    assert source.count('keyword_only_name: str = getattr(argument, "arg")') == 2
+    assert source.count('variadic_positional = getattr(node.args, "vararg")') == 2
+    assert source.count('variadic_positional_name: str = getattr(variadic_positional, "arg")') == 2
+    assert source.count('variadic_keyword = getattr(node.args, "kwarg")') == 2
+    assert source.count('variadic_keyword_name: str = getattr(variadic_keyword, "arg")') == 2
+    assert "function_argument_name: str = argument.arg" not in source
+    assert "lambda_argument_name: str = argument.arg" not in source
 
 
 def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:

From 633bbb7fdcbd3c4b5900bac4579e4d9b8f2dd3aa Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:06:56 -0500
Subject: [PATCH 280/450] Fix CI to validate the current PortaPy branch

---
 .github/workflows/ci.yml | 54 ++++++++++++++++------------------------
 1 file changed, 22 insertions(+), 32 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 85a7e41f..1b96f57f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,21 +1,24 @@
 name: CI
 
 on:
-  pull_request_target:
-    types: [labeled]
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
   workflow_dispatch:
 
+concurrency:
+  group: ci-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 
 jobs:
   hosted:
-    if: github.event_name == 'workflow_dispatch' || (github.event.pull_request.number == 46 && github.event.label.name == 'enhancement')
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
-        with:
-          ref: c4444ae53c1c9b07a0d58d53dad8270af8a049df
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
@@ -26,22 +29,17 @@ jobs:
         run: cc -std=c11 -Wall -Wextra -Werror -Iinclude -fsyntax-only examples/embed.c
 
   native:
-    if: github.event_name == 'workflow_dispatch' || (github.event.pull_request.number == 46 && github.event.label.name == 'enhancement')
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: ubuntu-24.04
             target: linux
-            library: dist/libportapy.so
           - os: windows-2025
             target: windows
-            library: dist/portapy.dll
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
-        with:
-          ref: c4444ae53c1c9b07a0d58d53dad8270af8a049df
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
@@ -58,10 +56,11 @@ jobs:
         if: matrix.target == 'windows'
         shell: powershell
         run: |
-          choco install nasm mingw -y --no-progress
+          & .\tools\install_windows_toolchain.ps1
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          & .\tools\install_pinned_asmpython.ps1
       - name: Build Linux standalone library
         if: matrix.target == 'linux'
         shell: bash
@@ -93,34 +92,25 @@ jobs:
             echo 'text relocations are forbidden'
             exit 1
           fi
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_full_runtime_host.c -ldl \
-            -o dist/native_full_runtime_host
-          env -i PATH="$PATH" HOME="$HOME" \
-            ./dist/native_full_runtime_host ./dist/libportapy.so \
-            | tee dist/native-output.txt
-          grep -qx 'native-full-runtime: ok' dist/native-output.txt
-          python tests/native_traceback_adapter_probe.py dist/libportapy.so
+          python tools/run_native_release_conformance.py \
+            dist/libportapy.so \
+            --output-dir dist/conformance-linux
       - name: Verify Windows standalone library
         if: matrix.target == 'windows'
         shell: powershell
         run: |
           $imports = (& objdump -p dist/portapy.dll | Out-String)
-          if ($imports -match '(?i)python3|python\.dll') {
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          if ($imports -match 'DLL Name:\s*(python|libpython)[^\s]*\.dll') {
             throw 'CPython linkage is forbidden'
           }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_full_runtime_host.c `
-            -o dist/native_full_runtime_host.exe
+          python tools/run_native_release_conformance.py `
+            dist/portapy.dll `
+            --compiler gcc `
+            --output-dir dist/conformance-windows
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_full_runtime_host.exe dist/portapy.dll
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-full-runtime: ok') {
-            throw "unexpected output: $output"
-          }
-          python tests/native_traceback_adapter_probe.py dist/portapy.dll
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: portapy-3.14-${{ matrix.target }}
+          name: portapy-ci-${{ matrix.target }}
           path: dist

From 59b858606be37a02da8b29bca202062bec50642b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:07:01 -0500
Subject: [PATCH 281/450] Remove obsolete hard-coded branch verifier

---
 .../workflows/verify-portapy-3.14-branch.yml  | 200 ------------------
 1 file changed, 200 deletions(-)
 delete mode 100644 .github/workflows/verify-portapy-3.14-branch.yml

diff --git a/.github/workflows/verify-portapy-3.14-branch.yml b/.github/workflows/verify-portapy-3.14-branch.yml
deleted file mode 100644
index 6239594e..00000000
--- a/.github/workflows/verify-portapy-3.14-branch.yml
+++ /dev/null
@@ -1,200 +0,0 @@
-name: Verify PortaPy 3.14 branch
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_run:
-    workflows: [Native shared-library probe]
-    types: [completed]
-  issue_comment:
-    types: [created]
-  schedule:
-    - cron: '*/5 * * * *'
-  workflow_dispatch:
-
-concurrency:
-  group: verify-portapy-3.14-branch
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  announce:
-    if: github.event_name != 'issue_comment' || (github.event.issue.number == 46 && contains(github.event.comment.body, '/verify-portapy-3.14'))
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Publish verification start
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERIFY_SHA: be5417cce8509adc3ba9d2fd9444fc716a591785
-          VERIFY_RUN_ID: ${{ github.run_id }}
-        run: |
-          gh pr view 46 --repo "${{ github.repository }}" --json body --jq .body > /tmp/body.md
-          python - <<'PY'
-          import os
-          from pathlib import Path
-          path = Path('/tmp/body.md')
-          body = path.read_text(encoding='utf-8')
-          start = '<!-- portapy-main-verification -->'
-          end = '<!-- /portapy-main-verification -->'
-          block = f'''{start}
-          ### Main-hosted exact branch verification
-
-          - Tested commit: `{os.environ["VERIFY_SHA"]}`
-          - Run: `{os.environ["VERIFY_RUN_ID"]}`
-          - Status: **in progress**
-          {end}'''
-          if start in body and end in body:
-              before, rest = body.split(start, 1)
-              _, after = rest.split(end, 1)
-              body = before.rstrip() + '\n\n' + block + after
-          else:
-              body = body.rstrip() + '\n\n' + block + '\n'
-          path.write_text(body, encoding='utf-8')
-          PY
-          gh pr edit 46 --repo "${{ github.repository }}" --body-file /tmp/body.md
-
-  hosted:
-    needs: announce
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: be5417cce8509adc3ba9d2fd9444fc716a591785
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - run: python -m pip install -e '.[test]'
-      - name: Run hosted suite
-        run: python -m pytest
-
-  native:
-    needs: announce
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-24.04
-            target: linux
-            library: dist/libportapy.so
-          - os: windows-2025
-            target: windows
-            library: dist/portapy.dll
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: be5417cce8509adc3ba9d2fd9444fc716a591785
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install Linux dependencies
-        if: matrix.target == 'linux'
-        shell: bash
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Install Windows dependencies
-        if: matrix.target == 'windows'
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build Linux library
-        if: matrix.target == 'linux'
-        shell: bash
-        run: |
-          mkdir -p dist
-          python tools/build_native_typed.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-verify-linux
-      - name: Build Windows library
-        if: matrix.target == 'windows'
-        shell: powershell
-        run: |
-          New-Item -ItemType Directory -Force dist | Out-Null
-          python tools/build_native_typed.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-verify-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Verify Linux standalone library
-        if: matrix.target == 'linux'
-        shell: bash
-        run: |
-          if readelf -dW dist/libportapy.so | grep -Ei 'libpython|python3'; then exit 1; fi
-          if readelf -dW dist/libportapy.so | grep -q TEXTREL; then exit 1; fi
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_full_runtime_host.c -ldl \
-            -o dist/native_full_runtime_host
-          env -i PATH="$PATH" HOME="$HOME" \
-            ./dist/native_full_runtime_host ./dist/libportapy.so \
-            | tee dist/native-output.txt
-          grep -qx 'native-full-runtime: ok' dist/native-output.txt
-          python tests/native_traceback_adapter_probe.py dist/libportapy.so
-      - name: Verify Windows standalone library
-        if: matrix.target == 'windows'
-        shell: powershell
-        run: |
-          $imports = (& objdump -p dist/portapy.dll | Out-String)
-          if ($imports -match '(?i)python3|python\.dll') { throw 'CPython linkage is forbidden' }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_full_runtime_host.c `
-            -o dist/native_full_runtime_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_full_runtime_host.exe dist/portapy.dll
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-full-runtime: ok') { throw "unexpected output: $output" }
-          python tests/native_traceback_adapter_probe.py dist/portapy.dll
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: portapy-3.14-${{ matrix.target }}
-          path: dist
-
-  report:
-    if: always()
-    needs: [hosted, native]
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Publish results
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERIFY_SHA: be5417cce8509adc3ba9d2fd9444fc716a591785
-          VERIFY_RUN_ID: ${{ github.run_id }}
-          HOSTED_RESULT: ${{ needs.hosted.result }}
-          NATIVE_RESULT: ${{ needs.native.result }}
-        run: |
-          gh pr view 46 --repo "${{ github.repository }}" --json body --jq .body > /tmp/body.md
-          python - <<'PY'
-          import os
-          from pathlib import Path
-          path = Path('/tmp/body.md')
-          body = path.read_text(encoding='utf-8')
-          start = '<!-- portapy-main-verification -->'
-          end = '<!-- /portapy-main-verification -->'
-          block = f'''{start}
-          ### Main-hosted exact branch verification
-
-          - Tested commit: `{os.environ["VERIFY_SHA"]}`
-          - Run: `{os.environ["VERIFY_RUN_ID"]}`
-          - Hosted suite: **{os.environ["HOSTED_RESULT"]}**
-          - Linux/Windows native matrix: **{os.environ["NATIVE_RESULT"]}**
-          {end}'''
-          if start in body and end in body:
-              before, rest = body.split(start, 1)
-              _, after = rest.split(end, 1)
-              body = before.rstrip() + '\n\n' + block + after
-          else:
-              body = body.rstrip() + '\n\n' + block + '\n'
-          path.write_text(body, encoding='utf-8')
-          PY
-          gh pr edit 46 --repo "${{ github.repository }}" --body-file /tmp/body.md

From 445a28596ea01d6326cab64b77792593472a4f58 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:10:20 -0500
Subject: [PATCH 282/450] Add one-shot release branch synchronizer

---
 .github/workflows/sync-release-branch.yml | 26 +++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .github/workflows/sync-release-branch.yml

diff --git a/.github/workflows/sync-release-branch.yml b/.github/workflows/sync-release-branch.yml
new file mode 100644
index 00000000..7d3dc791
--- /dev/null
+++ b/.github/workflows/sync-release-branch.yml
@@ -0,0 +1,26 @@
+name: Sync release branch with main
+
+on:
+  push:
+    branches: [release/full-runtime-promotion]
+    paths:
+      - .github/workflows/sync-release-branch.yml
+
+permissions:
+  contents: write
+
+jobs:
+  sync:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: release/full-runtime-promotion
+          fetch-depth: 0
+      - name: Merge current main into release branch
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+          git fetch origin main
+          git merge --no-edit -X ours origin/main
+          git push origin HEAD:release/full-runtime-promotion

From 537bf067e8a06eff7f07862e456d0ec818649b68 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:11:59 -0500
Subject: [PATCH 283/450] Remove one-shot release branch synchronizer

---
 .github/workflows/sync-release-branch.yml | 26 -----------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 .github/workflows/sync-release-branch.yml

diff --git a/.github/workflows/sync-release-branch.yml b/.github/workflows/sync-release-branch.yml
deleted file mode 100644
index 7d3dc791..00000000
--- a/.github/workflows/sync-release-branch.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: Sync release branch with main
-
-on:
-  push:
-    branches: [release/full-runtime-promotion]
-    paths:
-      - .github/workflows/sync-release-branch.yml
-
-permissions:
-  contents: write
-
-jobs:
-  sync:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: release/full-runtime-promotion
-          fetch-depth: 0
-      - name: Merge current main into release branch
-        run: |
-          git config user.name github-actions[bot]
-          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-          git fetch origin main
-          git merge --no-edit -X ours origin/main
-          git push origin HEAD:release/full-runtime-promotion

From 77e7cb3e69bab6ed3bbbea61034bb5e214af6c17 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:15:18 -0500
Subject: [PATCH 284/450] Preserve hosted pytest diagnostics in CI

---
 .github/workflows/ci.yml | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1b96f57f..a8113873 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,9 +24,17 @@ jobs:
           python-version: '3.12'
       - run: python -m pip install -e '.[test]'
       - name: Run complete hosted suite
-        run: python -m pytest
+        shell: bash
+        run: |
+          set -o pipefail
+          python -m pytest -x -vv 2>&1 | tee hosted-pytest.log
       - name: Check public C example
         run: cc -std=c11 -Wall -Wextra -Werror -Iinclude -fsyntax-only examples/embed.c
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: portapy-hosted-pytest
+          path: hosted-pytest.log
 
   native:
     strategy:

From 418119dd00a8f616037e91ad9459b245b3e75e09 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:17:02 -0500
Subject: [PATCH 285/450] Propagate native callable return kinds

---
 ...rmalize_full_reference_expression_kinds.py | 155 +++++++++++++++++-
 1 file changed, 147 insertions(+), 8 deletions(-)

diff --git a/tools/normalize_full_reference_expression_kinds.py b/tools/normalize_full_reference_expression_kinds.py
index a001f4ff..4d4ad40f 100644
--- a/tools/normalize_full_reference_expression_kinds.py
+++ b/tools/normalize_full_reference_expression_kinds.py
@@ -1,11 +1,10 @@
 """Install source-kind inference that respects expression structure.
 
 The native ABI keeps a lightweight source-derived kind ledger because raw native
-values cannot always distinguish ``None``, ``False``, and integer zero.  The
-original classifier checked literal prefixes before comparisons, so
-``\"a\" < \"b\"`` was exposed as a string even though the VM correctly returned a
-boolean.  It also treated every ``and``/``or`` expression as boolean even though
-Python returns one of the operands.
+values cannot always distinguish ``None``, ``False``, and integer zero.  This
+pass fixes comparison and boolean-expression precedence and records return kinds
+for source-defined callables, allowing ``seven()`` and similar function results
+to cross the ABI as integers instead of the previous hardcoded ``OBJECT`` kind.
 """
 from __future__ import annotations
 
@@ -16,6 +15,107 @@
 PATH = Path("src/portapy/native_full_reference_entry.py")
 
 _REPLACEMENT = r'''
+_native_callable_return_kinds: dict[str, int] = {}
+
+
+def _native_callable_key(runtime: int, name: str) -> str:
+    return str(runtime) + ":" + name
+
+
+def _native_set_callable_return_kind(runtime: int, name: str, kind: int) -> None:
+    _native_callable_return_kinds[_native_callable_key(runtime, name)] = kind
+
+
+def _native_callable_return_kind(runtime: int, name: str) -> int:
+    return _native_callable_return_kinds.get(
+        _native_callable_key(runtime, name),
+        PORTAPY_VALUE_OBJECT,
+    )
+
+
+def _native_merge_callable_return_kind(runtime: int, name: str, kind: int) -> None:
+    key = _native_callable_key(runtime, name)
+    existing = _native_callable_return_kinds.get(key, -1)
+    if existing < 0 or existing == PORTAPY_VALUE_NONE:
+        _native_callable_return_kinds[key] = kind
+    elif kind != PORTAPY_VALUE_NONE and existing != kind:
+        _native_callable_return_kinds[key] = PORTAPY_VALUE_OBJECT
+
+
+def _native_definition_name(text: str, prefix: str) -> str:
+    start = len(prefix)
+    end = text.find("(", start)
+    if end < 0:
+        end = text.find(":", start)
+    if end < 0:
+        end = len(text)
+    return text[start:end].strip()
+
+
+def _native_record_callable_return_kinds(runtime: int, source: str) -> None:
+    function_names: list[str] = []
+    function_indents: list[int] = []
+    depth = 0
+    line = ""
+    index = 0
+    while index <= len(source):
+        char = source[index] if index < len(source) else "\n"
+        if char != "\n":
+            line += char
+        else:
+            indentation = 0
+            while indentation < len(line):
+                indent_char = line[indentation]
+                if indent_char != " " and indent_char != "\t":
+                    break
+                indentation += 1
+            text = line.strip()
+            if len(text) > 0:
+                while depth > 0 and indentation <= function_indents[depth - 1]:
+                    depth -= 1
+                function_name = ""
+                if text.startswith("def "):
+                    function_name = _native_definition_name(text, "def ")
+                elif text.startswith("async def "):
+                    function_name = _native_definition_name(text, "async def ")
+                if _native_is_identifier(function_name):
+                    _native_set_global_kind(runtime, function_name, PORTAPY_VALUE_CALLABLE)
+                    _native_set_callable_return_kind(
+                        runtime,
+                        function_name,
+                        PORTAPY_VALUE_NONE,
+                    )
+                    if depth < len(function_names):
+                        function_names[depth] = function_name
+                        function_indents[depth] = indentation
+                    else:
+                        function_names.append(function_name)
+                        function_indents.append(indentation)
+                    depth += 1
+                elif text.startswith("class ") and indentation == 0:
+                    class_name = _native_definition_name(text, "class ")
+                    if _native_is_identifier(class_name):
+                        _native_set_global_kind(runtime, class_name, PORTAPY_VALUE_CALLABLE)
+                        _native_set_callable_return_kind(
+                            runtime,
+                            class_name,
+                            PORTAPY_VALUE_OBJECT,
+                        )
+                elif depth > 0 and (text == "return" or text.startswith("return ")):
+                    expression = text[6:].strip()
+                    if len(expression) == 0:
+                        return_kind = PORTAPY_VALUE_NONE
+                    else:
+                        return_kind = _native_expression_kind(runtime, expression)
+                    _native_merge_callable_return_kind(
+                        runtime,
+                        function_names[depth - 1],
+                        return_kind,
+                    )
+            line = ""
+        index += 1
+
+
 def _native_has_top_level_comparison(text: str) -> bool:
     depth = 0
     quote = ""
@@ -156,7 +256,7 @@ def _native_expression_kind(runtime: int, expression: str) -> int:
         if _native_is_identifier(callee):
             callee_kind = _native_global_kind(runtime, callee)
             if callee_kind == PORTAPY_VALUE_CALLABLE:
-                return PORTAPY_VALUE_OBJECT
+                return _native_callable_return_kind(runtime, callee)
     if _native_expression_has_kind(runtime, text, PORTAPY_VALUE_FLOAT):
         return PORTAPY_VALUE_FLOAT
     if "/" in text and "//" not in text:
@@ -186,6 +286,9 @@ def main() -> int:
         for node in module.body
         if isinstance(node, ast.FunctionDef)
         and node.name in {
+            "_native_callable_key",
+            "_native_callable_return_kind",
+            "_native_record_callable_return_kinds",
             "_native_has_top_level_comparison",
             "_native_top_level_bool_rhs",
         }
@@ -199,6 +302,30 @@ def main() -> int:
     replacement = ast.parse(_REPLACEMENT).body
     index = matches[0]
     module.body[index:index + 1] = replacement
+
+    source_scanner = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.FunctionDef)
+            and node.name == "_native_record_source_kinds"
+        ),
+        None,
+    )
+    if source_scanner is None:
+        raise RuntimeError("native source-kind scanner is missing")
+    scanner_call = ast.Expr(
+        value=ast.Call(
+            func=ast.Name(id="_native_record_callable_return_kinds", ctx=ast.Load()),
+            args=[
+                ast.Name(id="runtime", ctx=ast.Load()),
+                ast.Name(id="source", ctx=ast.Load()),
+            ],
+            keywords=[],
+        )
+    )
+    source_scanner.body.insert(0, scanner_call)
+
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
@@ -210,9 +337,16 @@ def main() -> int:
         if isinstance(node, ast.FunctionDef)
     }
     required = {
+        "_native_callable_key",
+        "_native_set_callable_return_kind",
+        "_native_callable_return_kind",
+        "_native_merge_callable_return_kind",
+        "_native_definition_name",
+        "_native_record_callable_return_kinds",
         "_native_has_top_level_comparison",
         "_native_top_level_bool_rhs",
         "_native_expression_kind",
+        "_native_record_source_kinds",
     }
     missing = sorted(required - functions.keys())
     if missing:
@@ -221,10 +355,15 @@ def main() -> int:
             + ", ".join(missing)
         )
     expression_text = ast.unparse(functions["_native_expression_kind"])
-    if expression_text.find("_native_has_top_level_comparison(text)") < 0:
+    if "_native_has_top_level_comparison(text)" not in expression_text:
         raise RuntimeError("native comparison kind inference was not installed")
-    if expression_text.find("_native_top_level_bool_rhs(text)") < 0:
+    if "_native_top_level_bool_rhs(text)" not in expression_text:
         raise RuntimeError("native boolean-operand kind inference was not installed")
+    if "_native_callable_return_kind(runtime, callee)" not in expression_text:
+        raise RuntimeError("native callable return-kind inference was not installed")
+    scanner_text = ast.unparse(functions["_native_record_source_kinds"])
+    if scanner_text.count("_native_record_callable_return_kinds(runtime, source)") != 1:
+        raise RuntimeError("native callable return scanner was not installed")
     print("NORMALIZED NATIVE EXPRESSION VALUE KINDS", len(replacement))
     return 0
 

From 475ca39a6aa47c3cffb761f705506d62da41be5d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:17:31 -0500
Subject: [PATCH 286/450] Test native callable return kind propagation

---
 ...rmalize_full_reference_expression_kinds.py | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/tests/test_normalize_full_reference_expression_kinds.py b/tests/test_normalize_full_reference_expression_kinds.py
index 74517ee7..0ec0090c 100644
--- a/tests/test_normalize_full_reference_expression_kinds.py
+++ b/tests/test_normalize_full_reference_expression_kinds.py
@@ -72,3 +72,51 @@ def test_boolops_keep_operand_kinds(tmp_path: Path, monkeypatch) -> None:
     assert infer(7, "name and answer") == 2
     assert infer(7, 'answer > 40 and name == "Somnia"') == 1
     assert infer(7, "not empty") == 1
+
+
+def test_source_functions_propagate_return_kinds(tmp_path: Path, monkeypatch) -> None:
+    namespace = _normalized_helpers(tmp_path, monkeypatch)
+    infer = namespace["_native_expression_kind"]
+    record = namespace["_native_record_source_kinds"]
+    global_kind = namespace["_native_global_kind"]
+
+    source = '''def seven():
+    return 7
+def label():
+    return "ready"
+def make_items():
+    return [1, 2]
+class Box:
+    pass
+answer = seven()
+text = label()
+items = make_items()
+box = Box()
+'''
+    record(9, source)
+
+    assert infer(9, "seven()") == 2
+    assert infer(9, "label()") == 4
+    assert infer(9, "make_items()") == 10
+    assert infer(9, "Box()") == 7
+    assert global_kind(9, "answer") == 2
+    assert global_kind(9, "text") == 4
+    assert global_kind(9, "items") == 10
+    assert global_kind(9, "box") == 7
+
+
+def test_nested_function_return_is_callable(tmp_path: Path, monkeypatch) -> None:
+    namespace = _normalized_helpers(tmp_path, monkeypatch)
+    infer = namespace["_native_expression_kind"]
+    record = namespace["_native_record_source_kinds"]
+
+    source = '''def outer(base):
+    def inner(value):
+        return base + value
+    return inner
+fn = outer(19)
+'''
+    record(11, source)
+
+    assert infer(11, "outer(19)") == 6
+    assert infer(11, "fn") == 6

From fe9764bfc60de8959341281b009a09520847edbd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:18:44 -0500
Subject: [PATCH 287/450] Make full-core normalization failures actionable

---
 tools/normalize_full_core_validation.py | 199 +++++++++++-------------
 1 file changed, 89 insertions(+), 110 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index e36a7559..707fdf56 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -2,39 +2,27 @@
 from __future__ import annotations
 
 from pathlib import Path
+import traceback
+from typing import Callable
 
 from tools.combine_full_core_native_parser import main as combine_native_parser
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
 from tools.normalize_full_core_boolops import main as normalize_boolops
 from tools.normalize_full_core_builtins import main as normalize_builtins
-from tools.normalize_full_core_calls_closures import (
-    main as normalize_calls_closures,
-)
+from tools.normalize_full_core_calls_closures import main as normalize_calls_closures
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
-from tools.normalize_full_core_expr_stmt_initializer import (
-    main as normalize_expr_stmt_initializer,
-)
-from tools.normalize_full_core_extended_semantics_compat import (
-    main as normalize_extended_semantics,
-)
-from tools.normalize_full_core_function_binding import (
-    main as normalize_function_binding,
-)
-from tools.normalize_full_core_function_parameter_names import (
-    main as normalize_function_parameter_names,
-)
+from tools.normalize_full_core_expr_stmt_initializer import main as normalize_expr_stmt_initializer
+from tools.normalize_full_core_extended_semantics_compat import main as normalize_extended_semantics
+from tools.normalize_full_core_function_binding import main as normalize_function_binding
+from tools.normalize_full_core_function_parameter_names import main as normalize_function_parameter_names
 from tools.normalize_full_core_function_specs import main as normalize_function_specs
-from tools.normalize_full_core_keyword_calls import (
-    main as normalize_keyword_calls,
-)
+from tools.normalize_full_core_keyword_calls import main as normalize_keyword_calls
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_name_index import main as normalize_name_index
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
-from tools.normalize_full_core_native_parser_expressions import (
-    main as normalize_native_parser_expressions,
-)
+from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
@@ -44,51 +32,24 @@
 from tools.normalize_full_core_string_addition import main as normalize_string_addition
 from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
-from tools.normalize_full_reference_abi_helpers import (
-    main as normalize_reference_abi_helpers,
-)
-from tools.normalize_full_reference_bytes_literals import (
-    main as normalize_reference_bytes_literals,
-)
-from tools.normalize_full_reference_data_access import (
-    main as normalize_reference_data_access,
-)
-from tools.normalize_full_reference_data_builders import (
-    main as normalize_reference_data_builders,
-)
-from tools.normalize_full_reference_error_locations import (
-    main as normalize_reference_error_locations,
-)
-from tools.normalize_full_reference_error_text import (
-    main as normalize_reference_error_text,
-)
-from tools.normalize_full_reference_errors import (
-    main as normalize_reference_errors,
-)
-from tools.normalize_full_reference_expression_kinds import (
-    main as normalize_reference_expression_kinds,
-)
-from tools.normalize_full_reference_float_bits import (
-    main as normalize_reference_float_bits,
-)
-from tools.normalize_full_reference_nested_kinds import (
-    main as normalize_reference_nested_kinds,
-)
-from tools.normalize_full_reference_runtime import (
-    main as normalize_reference_runtime,
-)
-from tools.normalize_full_reference_source_preprocess import (
-    main as normalize_reference_source_preprocess,
-)
-from tools.normalize_full_reference_type_errors import (
-    main as normalize_reference_type_errors,
-)
-from tools.normalize_full_reference_value_kinds import (
-    main as normalize_reference_value_kinds,
-)
+from tools.normalize_full_reference_abi_helpers import main as normalize_reference_abi_helpers
+from tools.normalize_full_reference_bytes_literals import main as normalize_reference_bytes_literals
+from tools.normalize_full_reference_data_access import main as normalize_reference_data_access
+from tools.normalize_full_reference_data_builders import main as normalize_reference_data_builders
+from tools.normalize_full_reference_error_locations import main as normalize_reference_error_locations
+from tools.normalize_full_reference_error_text import main as normalize_reference_error_text
+from tools.normalize_full_reference_errors import main as normalize_reference_errors
+from tools.normalize_full_reference_expression_kinds import main as normalize_reference_expression_kinds
+from tools.normalize_full_reference_float_bits import main as normalize_reference_float_bits
+from tools.normalize_full_reference_nested_kinds import main as normalize_reference_nested_kinds
+from tools.normalize_full_reference_runtime import main as normalize_reference_runtime
+from tools.normalize_full_reference_source_preprocess import main as normalize_reference_source_preprocess
+from tools.normalize_full_reference_type_errors import main as normalize_reference_type_errors
+from tools.normalize_full_reference_value_kinds import main as normalize_reference_value_kinds
 
 
 BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
+DIAGNOSTIC_PATH = Path("dist/full-core-normalization-error.txt")
 
 
 def _normalize_nested_code_introspection() -> None:
@@ -109,7 +70,7 @@ def _normalize_nested_code_introspection() -> None:
             f"expected one nested-code introspection helper, found {count}"
         )
     BYTECODE_PATH.write_text(source.replace(old, new, 1), encoding="utf-8")
-    print("DISABLED HOST-ONLY NESTED CODE INTROSPECTION", count)
+    print("DISABLED HOST-ONLY NESTED CODE INTROSPECTION", count, flush=True)
 
 
 def _normalize_opcode_validation() -> None:
@@ -120,55 +81,73 @@ def _normalize_opcode_validation() -> None:
     if count != 1:
         raise RuntimeError(f"expected one opcode host-type check, found {count}")
     BYTECODE_PATH.write_text(source.replace(old, new, 1), encoding="utf-8")
-    print("REMOVED HOST OPCODE TYPE IDENTITY", count)
+    print("REMOVED HOST OPCODE TYPE IDENTITY", count, flush=True)
 
 
-def main() -> int:
-    # These passes prepare the source modules imported by the generated entry.
-    normalize_probe()
-    normalize_lambdas()
-    normalize_function_specs()
-    normalize_function_binding()
-    normalize_native_semantics()
-    normalize_function_parameter_names()
-    normalize_opcode_maps()
-    normalize_name_index()
-    normalize_reference_runtime()
+def _run_step(name: str, callback: Callable[[], object]) -> None:
+    print(f"FULL-CORE NORMALIZE START: {name}", flush=True)
+    try:
+        result = callback()
+        if result not in (None, 0):
+            raise RuntimeError(f"normalizer returned non-zero result {result!r}")
+    except BaseException:
+        diagnostic = f"failed step: {name}\n\n{traceback.format_exc()}"
+        DIAGNOSTIC_PATH.parent.mkdir(parents=True, exist_ok=True)
+        DIAGNOSTIC_PATH.write_text(diagnostic, encoding="utf-8")
+        print(diagnostic, flush=True)
+        raise
+    print(f"FULL-CORE NORMALIZE OK: {name}", flush=True)
+
 
-    materialize_reference_entry()
-    normalize_reference_abi_helpers()
-    normalize_reference_float_bits()
-    normalize_reference_errors()
-    normalize_reference_error_text()
-    normalize_reference_error_locations()
-    normalize_reference_value_kinds()
-    normalize_reference_expression_kinds()
-    normalize_reference_nested_kinds()
-    normalize_reference_source_preprocess()
-    normalize_reference_data_builders()
-    normalize_reference_data_access()
-    normalize_reference_bytes_literals()
-    normalize_native_parser()
-    normalize_calls_closures()
-    normalize_keyword_calls()
-    combine_native_parser()
-    normalize_native_parser_expressions()
-    normalize_expr_stmt_initializer()
-    normalize_parser_errors()
-    normalize_boolops()
-    normalize_closures()
-    normalize_pattern_slices()
-    normalize_extended_semantics()
-    normalize_pop_top()
-    normalize_make_function()
-    normalize_collections()
-    normalize_builtins()
-    normalize_tracebacks()
-    _normalize_nested_code_introspection()
-    _normalize_opcode_validation()
-    normalize_truthiness()
-    normalize_string_addition()
-    normalize_reference_type_errors()
+def main() -> int:
+    steps: tuple[tuple[str, Callable[[], object]], ...] = (
+        ("probe", normalize_probe),
+        ("lambdas", normalize_lambdas),
+        ("function_specs", normalize_function_specs),
+        ("function_binding", normalize_function_binding),
+        ("native_semantics", normalize_native_semantics),
+        ("function_parameter_names", normalize_function_parameter_names),
+        ("opcode_maps", normalize_opcode_maps),
+        ("name_index", normalize_name_index),
+        ("reference_runtime", normalize_reference_runtime),
+        ("materialize_reference_entry", materialize_reference_entry),
+        ("reference_abi_helpers", normalize_reference_abi_helpers),
+        ("reference_float_bits", normalize_reference_float_bits),
+        ("reference_errors", normalize_reference_errors),
+        ("reference_error_text", normalize_reference_error_text),
+        ("reference_error_locations", normalize_reference_error_locations),
+        ("reference_value_kinds", normalize_reference_value_kinds),
+        ("reference_expression_kinds", normalize_reference_expression_kinds),
+        ("reference_nested_kinds", normalize_reference_nested_kinds),
+        ("reference_source_preprocess", normalize_reference_source_preprocess),
+        ("reference_data_builders", normalize_reference_data_builders),
+        ("reference_data_access", normalize_reference_data_access),
+        ("reference_bytes_literals", normalize_reference_bytes_literals),
+        ("native_parser", normalize_native_parser),
+        ("calls_closures", normalize_calls_closures),
+        ("keyword_calls", normalize_keyword_calls),
+        ("combine_native_parser", combine_native_parser),
+        ("native_parser_expressions", normalize_native_parser_expressions),
+        ("expr_stmt_initializer", normalize_expr_stmt_initializer),
+        ("parser_errors", normalize_parser_errors),
+        ("boolops", normalize_boolops),
+        ("closures", normalize_closures),
+        ("pattern_slices", normalize_pattern_slices),
+        ("extended_semantics", normalize_extended_semantics),
+        ("pop_top", normalize_pop_top),
+        ("make_function", normalize_make_function),
+        ("collections", normalize_collections),
+        ("builtins", normalize_builtins),
+        ("tracebacks", normalize_tracebacks),
+        ("nested_code_introspection", _normalize_nested_code_introspection),
+        ("opcode_validation", _normalize_opcode_validation),
+        ("truthiness", normalize_truthiness),
+        ("string_addition", normalize_string_addition),
+        ("reference_type_errors", normalize_reference_type_errors),
+    )
+    DIAGNOSTIC_PATH.unlink(missing_ok=True)
+    for name, callback in steps:
+        _run_step(name, callback)
     return 0
 
 

From 1fa460c112ca3511607408ebcf32545eaf7c62f3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:26:02 -0500
Subject: [PATCH 288/450] Track native user-function return kinds

---
 ...ze_full_reference_function_return_kinds.py | 159 ++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 tools/normalize_full_reference_function_return_kinds.py

diff --git a/tools/normalize_full_reference_function_return_kinds.py b/tools/normalize_full_reference_function_return_kinds.py
new file mode 100644
index 00000000..20f02b72
--- /dev/null
+++ b/tools/normalize_full_reference_function_return_kinds.py
@@ -0,0 +1,159 @@
+"""Teach the native ABI kind tracker about user-function return values."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HELPERS = r'''
+_native_function_return_kinds: dict[str, int] = {}
+
+
+def _native_function_kind_key(runtime: int, name: str) -> str:
+    return str(runtime) + ":" + name
+
+
+def _native_function_return_kind(runtime: int, name: str) -> int:
+    return _native_function_return_kinds.get(
+        _native_function_kind_key(runtime, name),
+        PORTAPY_VALUE_OBJECT,
+    )
+
+
+def _native_set_function_return_kind(runtime: int, name: str, kind: int) -> None:
+    _native_function_return_kinds[_native_function_kind_key(runtime, name)] = kind
+
+
+def _native_top_level_function_name(text: str) -> str:
+    start = 0
+    if text.startswith("def "):
+        start = 4
+    elif text.startswith("async def "):
+        start = 10
+    else:
+        return ""
+    end = text.find("(", start)
+    if end <= start:
+        return ""
+    name = text[start:end].strip()
+    if not _native_is_identifier(name):
+        return ""
+    return name
+
+
+def _native_record_function_return_kinds(runtime: int, source: str) -> None:
+    current = ""
+    position = 0
+    while position <= len(source):
+        line_end = position
+        while line_end < len(source) and source[line_end] != "\n":
+            line_end += 1
+        line = source[position:line_end]
+        indentation = 0
+        while indentation < len(line) and (line[indentation] == " " or line[indentation] == "\t"):
+            indentation += 1
+        text = line[indentation:].strip()
+        if indentation == 0 and len(text) != 0:
+            current = _native_top_level_function_name(text)
+            if current != "":
+                _native_set_function_return_kind(runtime, current, PORTAPY_VALUE_OBJECT)
+        elif current != "" and text.startswith("return"):
+            expression = text[6:].strip()
+            if len(expression) != 0:
+                kind = _native_expression_kind(runtime, expression)
+                previous = _native_function_return_kind(runtime, current)
+                if previous == PORTAPY_VALUE_OBJECT or previous == kind:
+                    _native_set_function_return_kind(runtime, current, kind)
+                else:
+                    _native_set_function_return_kind(runtime, current, PORTAPY_VALUE_OBJECT)
+        if line_end >= len(source):
+            break
+        position = line_end + 1
+'''
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.expression_rewritten = False
+        self.source_rewritten = False
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        node = self.generic_visit(node)
+        if node.name == "_native_expression_kind":
+            for statement in node.body:
+                if not isinstance(statement, ast.If):
+                    continue
+                test = statement.test
+                if not (
+                    isinstance(test, ast.Compare)
+                    and isinstance(test.left, ast.Name)
+                    and test.left.id == "open_at"
+                    and len(test.ops) == 1
+                    and isinstance(test.ops[0], ast.Gt)
+                ):
+                    continue
+                replacement = ast.parse(
+                    '''
+callee = text[0:open_at].strip()
+if _native_is_identifier(callee):
+    callee_kind = _native_global_kind(runtime, callee)
+    if callee_kind == PORTAPY_VALUE_CALLABLE:
+        return _native_function_return_kind(runtime, callee)
+'''
+                ).body
+                statement.body = replacement
+                self.expression_rewritten = True
+                break
+        elif node.name == "_native_record_source_kinds":
+            node.body.insert(
+                0,
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Name(id="_native_record_function_return_kinds", ctx=ast.Load()),
+                        args=[
+                            ast.Name(id="runtime", ctx=ast.Load()),
+                            ast.Name(id="source", ctx=ast.Load()),
+                        ],
+                        keywords=[],
+                    )
+                ),
+            )
+            self.source_rewritten = True
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    if any(
+        isinstance(node, ast.FunctionDef)
+        and node.name == "_native_record_function_return_kinds"
+        for node in module.body
+    ):
+        raise RuntimeError("native function return-kind tracking is already installed")
+    rewrite = _Rewrite()
+    module = rewrite.visit(module)
+    if not rewrite.expression_rewritten:
+        raise RuntimeError("native callable expression-kind branch was not found")
+    if not rewrite.source_rewritten:
+        raise RuntimeError("native source-kind recorder was not found")
+    module.body.extend(ast.parse(_HELPERS).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+    text = ast.unparse(ast.parse(source))
+    required = (
+        "_native_record_function_return_kinds(runtime, source)",
+        "return _native_function_return_kind(runtime, callee)",
+        "_native_function_return_kinds",
+    )
+    absent = [marker for marker in required if marker not in text]
+    if absent:
+        raise RuntimeError(f"native function return-kind validation failed: {absent}")
+    print("NORMALIZED NATIVE FUNCTION RETURN KINDS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 5fdc824074b541ef746ddd5db0112d3f644615c4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:26:35 -0500
Subject: [PATCH 289/450] Apply function return-kind normalization in full-core
 builds

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 707fdf56..5d511951 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -41,6 +41,7 @@
 from tools.normalize_full_reference_errors import main as normalize_reference_errors
 from tools.normalize_full_reference_expression_kinds import main as normalize_reference_expression_kinds
 from tools.normalize_full_reference_float_bits import main as normalize_reference_float_bits
+from tools.normalize_full_reference_function_return_kinds import main as normalize_reference_function_return_kinds
 from tools.normalize_full_reference_nested_kinds import main as normalize_reference_nested_kinds
 from tools.normalize_full_reference_runtime import main as normalize_reference_runtime
 from tools.normalize_full_reference_source_preprocess import main as normalize_reference_source_preprocess
@@ -117,6 +118,7 @@ def main() -> int:
         ("reference_error_text", normalize_reference_error_text),
         ("reference_error_locations", normalize_reference_error_locations),
         ("reference_value_kinds", normalize_reference_value_kinds),
+        ("reference_function_return_kinds", normalize_reference_function_return_kinds),
         ("reference_expression_kinds", normalize_reference_expression_kinds),
         ("reference_nested_kinds", normalize_reference_nested_kinds),
         ("reference_source_preprocess", normalize_reference_source_preprocess),

From dd92eb52a0fcb03b35abf6d6b00473c96737f5a9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:30:13 -0500
Subject: [PATCH 290/450] Preserve native default argument AST nodes

---
 ...lize_full_core_native_argument_defaults.py | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 tools/normalize_full_core_native_argument_defaults.py

diff --git a/tools/normalize_full_core_native_argument_defaults.py b/tools/normalize_full_core_native_argument_defaults.py
new file mode 100644
index 00000000..75771011
--- /dev/null
+++ b/tools/normalize_full_core_native_argument_defaults.py
@@ -0,0 +1,95 @@
+"""Preserve default-argument AST nodes through the standalone native bridge.
+
+``A.FuncDef.defaults`` is an opaque external list to the pinned compiler.  A bare
+``node.defaults[index]`` therefore receives the compiler's scalar fallback type;
+conversion of a real ``IntLit``/``StrLit`` can collapse to a null AST pointer.
+The frontend later calls ``_Lowerer.expr(None)`` while defining a function with
+defaults and crashes in its unsupported-expression formatter.
+
+Read the field dynamically and pin list elements to the native AST's dict-backed
+representation before passing them to ``_convert_expr``.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+
+_OLD = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
+    all_args = [arg(name) for name in node.params]
+    defaults: list[expr] = []
+    first_default = len(node.defaults)
+    index = 0
+    while index < len(node.defaults):
+        if node.defaults[index] is not None:
+            first_default = index
+            break
+        index += 1
+    if first_default < len(node.defaults):
+        index = first_default
+        while index < len(node.defaults):
+            defaults.append(_convert_expr(node.defaults[index], lifted))
+            index += 1
+    return arguments([], all_args, None if node.vararg is None else arg(node.vararg), [], [], None if node.kwarg is None else arg(node.kwarg), defaults)
+'''
+
+_NEW = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
+    all_args = [arg(name) for name in node.params]
+    defaults: list[expr] = []
+    native_defaults: list[dict] = getattr(node, "defaults")
+    first_default = len(native_defaults)
+    index = 0
+    while index < len(native_defaults):
+        default_node: dict = native_defaults[index]
+        if default_node is not None:
+            first_default = index
+            break
+        index += 1
+    if first_default < len(native_defaults):
+        index = first_default
+        while index < len(native_defaults):
+            default_node: dict = native_defaults[index]
+            defaults.append(_convert_expr(default_node, lifted))
+            index += 1
+    return arguments([], all_args, None if node.vararg is None else arg(node.vararg), [], [], None if node.kwarg is None else arg(node.kwarg), defaults)
+'''
+
+
+def main() -> int:
+    source = PATH.read_text(encoding="utf-8")
+    old_count = source.count(_OLD)
+    new_count = source.count(_NEW)
+    if old_count == 1 and new_count == 0:
+        source = source.replace(_OLD, _NEW, 1)
+        changed = 1
+    elif old_count == 0 and new_count == 1:
+        changed = 0
+    else:
+        raise RuntimeError(
+            "native default argument bridge source shape changed: "
+            f"old={old_count}, normalized={new_count}"
+        )
+    PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        'native_defaults: list[dict] = getattr(node, "defaults")',
+        "default_node: dict = native_defaults[index]",
+        "defaults.append(_convert_expr(default_node, lifted))",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native default argument validation failed: {missing}")
+    forbidden = (
+        "first_default = len(node.defaults)",
+        "_convert_expr(node.defaults[index], lifted)",
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if remaining:
+        raise RuntimeError(f"unsafe native default extraction remains: {remaining}")
+    print("NORMALIZED NATIVE DEFAULT ARGUMENT NODES", changed)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From dd38315051ecd9a75f2e75d2d0367c8297b0172c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:30:34 -0500
Subject: [PATCH 291/450] Test native default argument node preservation

---
 ...lize_full_core_native_argument_defaults.py | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_argument_defaults.py

diff --git a/tests/test_normalize_full_core_native_argument_defaults.py b/tests/test_normalize_full_core_native_argument_defaults.py
new file mode 100644
index 00000000..eaa9f469
--- /dev/null
+++ b/tests/test_normalize_full_core_native_argument_defaults.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_native_argument_defaults as normalizer
+
+
+_SOURCE = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
+    all_args = [arg(name) for name in node.params]
+    defaults: list[expr] = []
+    first_default = len(node.defaults)
+    index = 0
+    while index < len(node.defaults):
+        if node.defaults[index] is not None:
+            first_default = index
+            break
+        index += 1
+    if first_default < len(node.defaults):
+        index = first_default
+        while index < len(node.defaults):
+            defaults.append(_convert_expr(node.defaults[index], lifted))
+            index += 1
+    return arguments([], all_args, None if node.vararg is None else arg(node.vararg), [], [], None if node.kwarg is None else arg(node.kwarg), defaults)
+'''
+
+
+def test_pins_default_elements_to_dict_backed_ast(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert 'native_defaults: list[dict] = getattr(node, "defaults")' in source
+    assert source.count("default_node: dict = native_defaults[index]") == 2
+    assert "defaults.append(_convert_expr(default_node, lifted))" in source
+    assert "_convert_expr(node.defaults[index], lifted)" not in source
+
+
+def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    first = path.read_text(encoding="utf-8")
+    assert normalizer.main() == 0
+    assert path.read_text(encoding="utf-8") == first
+
+
+def test_fails_closed_for_unknown_shape(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text("def _convert_arguments():\n    pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "source shape changed" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unknown default bridge")

From d78e05f1c0cd8b87d9c8b0ff6d8043e25c8540bb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:31:13 -0500
Subject: [PATCH 292/450] Run native default argument normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5d511951..3181458a 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -21,6 +21,7 @@
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_name_index import main as normalize_name_index
+from tools.normalize_full_core_native_argument_defaults import main as normalize_native_argument_defaults
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
@@ -126,6 +127,7 @@ def main() -> int:
         ("reference_data_access", normalize_reference_data_access),
         ("reference_bytes_literals", normalize_reference_bytes_literals),
         ("native_parser", normalize_native_parser),
+        ("native_argument_defaults", normalize_native_argument_defaults),
         ("calls_closures", normalize_calls_closures),
         ("keyword_calls", normalize_keyword_calls),
         ("combine_native_parser", combine_native_parser),

From c7b52bd24d32fd2d77012b8e1204c7209cb4f328 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:33:45 -0500
Subject: [PATCH 293/450] Make native host ID getters type-safe

---
 tools/normalize_full_core_validation.py       |  2 +
 .../normalize_full_reference_safe_host_ids.py | 91 +++++++++++++++++++
 2 files changed, 93 insertions(+)
 create mode 100644 tools/normalize_full_reference_safe_host_ids.py

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 3181458a..ea450c2c 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -45,6 +45,7 @@
 from tools.normalize_full_reference_function_return_kinds import main as normalize_reference_function_return_kinds
 from tools.normalize_full_reference_nested_kinds import main as normalize_reference_nested_kinds
 from tools.normalize_full_reference_runtime import main as normalize_reference_runtime
+from tools.normalize_full_reference_safe_host_ids import main as normalize_reference_safe_host_ids
 from tools.normalize_full_reference_source_preprocess import main as normalize_reference_source_preprocess
 from tools.normalize_full_reference_type_errors import main as normalize_reference_type_errors
 from tools.normalize_full_reference_value_kinds import main as normalize_reference_value_kinds
@@ -114,6 +115,7 @@ def main() -> int:
         ("reference_runtime", normalize_reference_runtime),
         ("materialize_reference_entry", materialize_reference_entry),
         ("reference_abi_helpers", normalize_reference_abi_helpers),
+        ("reference_safe_host_ids", normalize_reference_safe_host_ids),
         ("reference_float_bits", normalize_reference_float_bits),
         ("reference_errors", normalize_reference_errors),
         ("reference_error_text", normalize_reference_error_text),
diff --git a/tools/normalize_full_reference_safe_host_ids.py b/tools/normalize_full_reference_safe_host_ids.py
new file mode 100644
index 00000000..67557773
--- /dev/null
+++ b/tools/normalize_full_reference_safe_host_ids.py
@@ -0,0 +1,91 @@
+"""Make host ID getters return status errors without unsafe value dereferences."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HOST_OBJECT_ID_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+status, kind = instance.value_kind(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+if _native_value_kind_code(kind) != PORTAPY_VALUE_OBJECT:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+status, result = instance.unbox(value)
+_set_status(status)
+if status is not Status.OK:
+    return 0
+return result
+'''
+
+_HOST_CALLABLE_ID_SOURCE = '''
+instance = _runtime(runtime)
+if instance is None:
+    _set_status(Status.INVALID_HANDLE)
+    return 0
+status, kind = instance.value_kind(value)
+if status is not Status.OK:
+    _set_status(status)
+    return 0
+if _native_value_kind_code(kind) != PORTAPY_VALUE_CALLABLE:
+    _set_status(Status.TYPE_ERROR)
+    return 0
+status, result = instance.unbox(value)
+_set_status(status)
+if status is not Status.OK:
+    return 0
+return result
+'''
+
+_REPLACEMENTS = {
+    "_portapy_value_get_host_id_impl": _HOST_OBJECT_ID_SOURCE,
+    "_portapy_value_get_host_callable_id_impl": _HOST_CALLABLE_ID_SOURCE,
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.replaced: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        replacement = _REPLACEMENTS.get(node.name)
+        if replacement is None:
+            return self.generic_visit(node)
+        node.body = ast.parse(replacement).body
+        self.replaced.add(node.name)
+        return node
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    rewrite = _Rewrite()
+    module = rewrite.visit(module)
+    missing = sorted(set(_REPLACEMENTS) - rewrite.replaced)
+    if missing:
+        raise RuntimeError(f"native host ID getters missing: {missing}")
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+    verified = ast.unparse(ast.parse(source))
+    required = (
+        "_native_value_kind_code(kind) != PORTAPY_VALUE_OBJECT",
+        "_native_value_kind_code(kind) != PORTAPY_VALUE_CALLABLE",
+        "status, result = instance.unbox(value)",
+    )
+    absent = [marker for marker in required if marker not in verified]
+    if absent:
+        raise RuntimeError(f"native host ID getter validation failed: {absent}")
+    print("NORMALIZED SAFE NATIVE HOST ID GETTERS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From f4543931a7595ff0cca8c683b06b58a73d4a5d30 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:35:04 -0500
Subject: [PATCH 294/450] Normalize native defaults structurally

---
 ...lize_full_core_native_argument_defaults.py | 145 ++++++++++--------
 1 file changed, 81 insertions(+), 64 deletions(-)

diff --git a/tools/normalize_full_core_native_argument_defaults.py b/tools/normalize_full_core_native_argument_defaults.py
index 75771011..033f520a 100644
--- a/tools/normalize_full_core_native_argument_defaults.py
+++ b/tools/normalize_full_core_native_argument_defaults.py
@@ -1,90 +1,107 @@
 """Preserve default-argument AST nodes through the standalone native bridge.
 
-``A.FuncDef.defaults`` is an opaque external list to the pinned compiler.  A bare
-``node.defaults[index]`` therefore receives the compiler's scalar fallback type;
-conversion of a real ``IntLit``/``StrLit`` can collapse to a null AST pointer.
-The frontend later calls ``_Lowerer.expr(None)`` while defining a function with
-defaults and crashes in its unsupported-expression formatter.
+``A.FuncDef.defaults`` is an opaque external list to the pinned compiler. A bare
+``node.defaults[index]`` receives the compiler's scalar fallback type, so a real
+literal AST can collapse to a null pointer. The frontend then lowers
+``_Lowerer.expr(None)`` while defining a function with defaults.
 
-Read the field dynamically and pin list elements to the native AST's dict-backed
-representation before passing them to ``_convert_expr``.
+This pass runs after parser vendoring, so names and formatting may already have
+changed. Rewrite ``_convert_arguments`` structurally and retain its vendored AST
+argument constructor rather than relying on exact source text.
 """
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 
 PATH = Path("src/portapy/core/native_ast.py")
 
-_OLD = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
-    all_args = [arg(name) for name in node.params]
-    defaults: list[expr] = []
-    first_default = len(node.defaults)
-    index = 0
-    while index < len(node.defaults):
-        if node.defaults[index] is not None:
-            first_default = index
-            break
-        index += 1
-    if first_default < len(node.defaults):
-        index = first_default
-        while index < len(node.defaults):
-            defaults.append(_convert_expr(node.defaults[index], lifted))
-            index += 1
-    return arguments([], all_args, None if node.vararg is None else arg(node.vararg), [], [], None if node.kwarg is None else arg(node.kwarg), defaults)
-'''
 
-_NEW = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
-    all_args = [arg(name) for name in node.params]
-    defaults: list[expr] = []
-    native_defaults: list[dict] = getattr(node, "defaults")
-    first_default = len(native_defaults)
-    index = 0
-    while index < len(native_defaults):
-        default_node: dict = native_defaults[index]
-        if default_node is not None:
-            first_default = index
-            break
-        index += 1
-    if first_default < len(native_defaults):
-        index = first_default
-        while index < len(native_defaults):
-            default_node: dict = native_defaults[index]
-            defaults.append(_convert_expr(default_node, lifted))
-            index += 1
-    return arguments([], all_args, None if node.vararg is None else arg(node.vararg), [], [], None if node.kwarg is None else arg(node.kwarg), defaults)
-'''
+def _constructor_name(function: ast.FunctionDef) -> str:
+    for node in ast.walk(function):
+        if not isinstance(node, ast.ListComp):
+            continue
+        element = node.elt
+        if (
+            isinstance(element, ast.Call)
+            and isinstance(element.func, ast.Name)
+            and element.args
+            and isinstance(element.args[0], ast.Name)
+            and element.args[0].id == "name"
+        ):
+            return element.func.id
+    raise RuntimeError("native default bridge lost its AST argument constructor")
+
+
+def _is_normalized(function: ast.FunctionDef) -> bool:
+    text = ast.unparse(function)
+    return (
+        'native_defaults: list[dict] = getattr(node, \'defaults\')' in text
+        and "default_node: dict = native_defaults[index]" in text
+        and "defaults.append(_convert_expr(default_node, lifted))" in text
+    )
 
 
 def main() -> int:
-    source = PATH.read_text(encoding="utf-8")
-    old_count = source.count(_OLD)
-    new_count = source.count(_NEW)
-    if old_count == 1 and new_count == 0:
-        source = source.replace(_OLD, _NEW, 1)
-        changed = 1
-    elif old_count == 0 and new_count == 1:
-        changed = 0
-    else:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_arguments"
+    ]
+    if len(matches) != 1:
         raise RuntimeError(
-            "native default argument bridge source shape changed: "
-            f"old={old_count}, normalized={new_count}"
+            "native default argument bridge: expected one _convert_arguments, "
+            f"found {len(matches)}"
         )
+    function = matches[0]
+    if _is_normalized(function):
+        changed = 0
+    else:
+        constructor = _constructor_name(function)
+        replacement = ast.parse(
+            f'''all_args = [{constructor}(name) for name in node.params]
+defaults: list[expr] = []
+native_defaults: list[dict] = getattr(node, "defaults")
+first_default = len(native_defaults)
+index = 0
+while index < len(native_defaults):
+    default_node: dict = native_defaults[index]
+    if default_node is not None:
+        first_default = index
+        break
+    index += 1
+if first_default < len(native_defaults):
+    index = first_default
+    while index < len(native_defaults):
+        default_node: dict = native_defaults[index]
+        defaults.append(_convert_expr(default_node, lifted))
+        index += 1
+return arguments([], all_args, None if node.vararg is None else {constructor}(node.vararg), [], [], None if node.kwarg is None else {constructor}(node.kwarg), defaults)
+'''
+        ).body
+        function.body = replacement
+        changed = 1
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
 
-    required = (
-        'native_defaults: list[dict] = getattr(node, "defaults")',
-        "default_node: dict = native_defaults[index]",
-        "defaults.append(_convert_expr(default_node, lifted))",
-    )
-    missing = [marker for marker in required if marker not in source]
-    if missing:
-        raise RuntimeError(f"native default argument validation failed: {missing}")
+    reparsed = ast.parse(source)
+    functions = [
+        node
+        for node in reparsed.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_arguments"
+    ]
+    if len(functions) != 1 or not _is_normalized(functions[0]):
+        raise RuntimeError("native default argument structural validation failed")
+    text = ast.unparse(functions[0])
     forbidden = (
         "first_default = len(node.defaults)",
         "_convert_expr(node.defaults[index], lifted)",
     )
-    remaining = [marker for marker in forbidden if marker in source]
+    remaining = [marker for marker in forbidden if marker in text]
     if remaining:
         raise RuntimeError(f"unsafe native default extraction remains: {remaining}")
     print("NORMALIZED NATIVE DEFAULT ARGUMENT NODES", changed)

From 097fb1188b8d402047bf34d09e4e321c67a348e6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:39:08 -0500
Subject: [PATCH 295/450] Unify native callable return-kind tracking

---
 ...ze_full_reference_function_return_kinds.py | 269 ++++++++++--------
 1 file changed, 145 insertions(+), 124 deletions(-)

diff --git a/tools/normalize_full_reference_function_return_kinds.py b/tools/normalize_full_reference_function_return_kinds.py
index 20f02b72..feeeae27 100644
--- a/tools/normalize_full_reference_function_return_kinds.py
+++ b/tools/normalize_full_reference_function_return_kinds.py
@@ -1,4 +1,17 @@
-"""Teach the native ABI kind tracker about user-function return values."""
+"""Stabilize native callable return-kind inference.
+
+The structural expression-kind pass installs one callable return-kind ledger.
+This pass makes that ledger distinguish three different states:
+
+* no return kind has been observed yet;
+* one concrete return kind has been observed;
+* incompatible return kinds have been observed.
+
+Using ``PORTAPY_VALUE_NONE`` as the initial/unknown state loses real bare-None
+returns, while allowing a later return to overwrite ``OBJECT`` can accidentally
+"unmix" a function after conflicting return types.  Both cases can cause the
+native ABI to decode a value through the wrong getter.
+"""
 from __future__ import annotations
 
 import ast
@@ -6,152 +19,160 @@
 
 
 PATH = Path("src/portapy/native_full_reference_entry.py")
-
-_HELPERS = r'''
-_native_function_return_kinds: dict[str, int] = {}
-
-
-def _native_function_kind_key(runtime: int, name: str) -> str:
-    return str(runtime) + ":" + name
-
-
-def _native_function_return_kind(runtime: int, name: str) -> int:
-    return _native_function_return_kinds.get(
-        _native_function_kind_key(runtime, name),
-        PORTAPY_VALUE_OBJECT,
-    )
+_UNKNOWN_NAME = "_NATIVE_RETURN_KIND_UNKNOWN"
+_MIXED_NAME = "_NATIVE_RETURN_KIND_MIXED"
+
+
+_RETURN_KIND_BODY = '''
+kind = _native_callable_return_kinds.get(
+    _native_callable_key(runtime, name),
+    _NATIVE_RETURN_KIND_UNKNOWN,
+)
+if kind < 0:
+    return PORTAPY_VALUE_OBJECT
+return kind
+'''
 
 
-def _native_set_function_return_kind(runtime: int, name: str, kind: int) -> None:
-    _native_function_return_kinds[_native_function_kind_key(runtime, name)] = kind
-
-
-def _native_top_level_function_name(text: str) -> str:
-    start = 0
-    if text.startswith("def "):
-        start = 4
-    elif text.startswith("async def "):
-        start = 10
-    else:
-        return ""
-    end = text.find("(", start)
-    if end <= start:
-        return ""
-    name = text[start:end].strip()
-    if not _native_is_identifier(name):
-        return ""
-    return name
-
-
-def _native_record_function_return_kinds(runtime: int, source: str) -> None:
-    current = ""
-    position = 0
-    while position <= len(source):
-        line_end = position
-        while line_end < len(source) and source[line_end] != "\n":
-            line_end += 1
-        line = source[position:line_end]
-        indentation = 0
-        while indentation < len(line) and (line[indentation] == " " or line[indentation] == "\t"):
-            indentation += 1
-        text = line[indentation:].strip()
-        if indentation == 0 and len(text) != 0:
-            current = _native_top_level_function_name(text)
-            if current != "":
-                _native_set_function_return_kind(runtime, current, PORTAPY_VALUE_OBJECT)
-        elif current != "" and text.startswith("return"):
-            expression = text[6:].strip()
-            if len(expression) != 0:
-                kind = _native_expression_kind(runtime, expression)
-                previous = _native_function_return_kind(runtime, current)
-                if previous == PORTAPY_VALUE_OBJECT or previous == kind:
-                    _native_set_function_return_kind(runtime, current, kind)
-                else:
-                    _native_set_function_return_kind(runtime, current, PORTAPY_VALUE_OBJECT)
-        if line_end >= len(source):
-            break
-        position = line_end + 1
+_MERGE_BODY = '''
+key = _native_callable_key(runtime, name)
+existing = _native_callable_return_kinds.get(
+    key,
+    _NATIVE_RETURN_KIND_UNKNOWN,
+)
+if existing == _NATIVE_RETURN_KIND_MIXED:
+    return
+if existing == _NATIVE_RETURN_KIND_UNKNOWN:
+    _native_callable_return_kinds[key] = kind
+    return
+if existing != kind:
+    _native_callable_return_kinds[key] = _NATIVE_RETURN_KIND_MIXED
 '''
 
 
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
-        self.expression_rewritten = False
-        self.source_rewritten = False
+        self.return_kind_rewritten = False
+        self.merge_rewritten = False
+        self.initializers_rewritten = 0
+        self._in_callable_scanner = False
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        if node.name == "_native_callable_return_kind":
+            node.body = ast.parse(_RETURN_KIND_BODY).body
+            self.return_kind_rewritten = True
+            return node
+        if node.name == "_native_merge_callable_return_kind":
+            node.body = ast.parse(_MERGE_BODY).body
+            self.merge_rewritten = True
+            return node
+        previous = self._in_callable_scanner
+        if node.name == "_native_record_callable_return_kinds":
+            self._in_callable_scanner = True
         node = self.generic_visit(node)
-        if node.name == "_native_expression_kind":
-            for statement in node.body:
-                if not isinstance(statement, ast.If):
-                    continue
-                test = statement.test
-                if not (
-                    isinstance(test, ast.Compare)
-                    and isinstance(test.left, ast.Name)
-                    and test.left.id == "open_at"
-                    and len(test.ops) == 1
-                    and isinstance(test.ops[0], ast.Gt)
-                ):
-                    continue
-                replacement = ast.parse(
-                    '''
-callee = text[0:open_at].strip()
-if _native_is_identifier(callee):
-    callee_kind = _native_global_kind(runtime, callee)
-    if callee_kind == PORTAPY_VALUE_CALLABLE:
-        return _native_function_return_kind(runtime, callee)
-'''
-                ).body
-                statement.body = replacement
-                self.expression_rewritten = True
-                break
-        elif node.name == "_native_record_source_kinds":
-            node.body.insert(
-                0,
-                ast.Expr(
-                    value=ast.Call(
-                        func=ast.Name(id="_native_record_function_return_kinds", ctx=ast.Load()),
-                        args=[
-                            ast.Name(id="runtime", ctx=ast.Load()),
-                            ast.Name(id="source", ctx=ast.Load()),
-                        ],
-                        keywords=[],
-                    )
-                ),
-            )
-            self.source_rewritten = True
+        self._in_callable_scanner = previous
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        node = self.generic_visit(node)
+        if not self._in_callable_scanner:
+            return node
+        if not (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "_native_set_callable_return_kind"
+            and len(node.args) == 3
+            and isinstance(node.args[2], ast.Name)
+            and node.args[2].id == "PORTAPY_VALUE_NONE"
+        ):
+            return node
+        node.args[2] = ast.Name(id=_UNKNOWN_NAME, ctx=ast.Load())
+        self.initializers_rewritten += 1
         return node
 
 
+def _has_constant(module: ast.Module, name: str) -> bool:
+    return any(
+        isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == name for target in node.targets)
+        for node in module.body
+    )
+
+
+def _insert_state_constants(module: ast.Module) -> None:
+    if _has_constant(module, _UNKNOWN_NAME) or _has_constant(module, _MIXED_NAME):
+        raise RuntimeError("native callable return-kind state constants already exist")
+    insertion = next(
+        (
+            index
+            for index, node in enumerate(module.body)
+            if isinstance(node, ast.AnnAssign)
+            and isinstance(node.target, ast.Name)
+            and node.target.id == "_native_callable_return_kinds"
+        ),
+        None,
+    )
+    if insertion is None:
+        raise RuntimeError("native callable return-kind ledger is missing")
+    constants = ast.parse(
+        "_NATIVE_RETURN_KIND_UNKNOWN = -1\n"
+        "_NATIVE_RETURN_KIND_MIXED = -2\n"
+    ).body
+    module.body[insertion:insertion] = constants
+
+
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
-    if any(
-        isinstance(node, ast.FunctionDef)
-        and node.name == "_native_record_function_return_kinds"
+    forbidden = {
+        "_native_function_return_kinds",
+        "_native_record_function_return_kinds",
+        "_native_function_return_kind",
+    }
+    existing_forbidden = sorted(
+        node.name
         for node in module.body
-    ):
-        raise RuntimeError("native function return-kind tracking is already installed")
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and node.name in forbidden
+    )
+    if existing_forbidden:
+        raise RuntimeError(
+            "duplicate native return-kind tracker already installed: "
+            + ", ".join(existing_forbidden)
+        )
+
+    _insert_state_constants(module)
     rewrite = _Rewrite()
     module = rewrite.visit(module)
-    if not rewrite.expression_rewritten:
-        raise RuntimeError("native callable expression-kind branch was not found")
-    if not rewrite.source_rewritten:
-        raise RuntimeError("native source-kind recorder was not found")
-    module.body.extend(ast.parse(_HELPERS).body)
+    if not rewrite.return_kind_rewritten:
+        raise RuntimeError("native callable return-kind getter is missing")
+    if not rewrite.merge_rewritten:
+        raise RuntimeError("native callable return-kind merger is missing")
+    if rewrite.initializers_rewritten != 1:
+        raise RuntimeError(
+            "expected one callable unknown-state initializer, found "
+            f"{rewrite.initializers_rewritten}"
+        )
+
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
-    text = ast.unparse(ast.parse(source))
+
+    verified = ast.unparse(ast.parse(source))
     required = (
-        "_native_record_function_return_kinds(runtime, source)",
-        "return _native_function_return_kind(runtime, callee)",
-        "_native_function_return_kinds",
+        "_NATIVE_RETURN_KIND_UNKNOWN = -1",
+        "_NATIVE_RETURN_KIND_MIXED = -2",
+        "if kind < 0:",
+        "if existing == _NATIVE_RETURN_KIND_MIXED:",
+        "if existing == _NATIVE_RETURN_KIND_UNKNOWN:",
+        "_native_set_callable_return_kind(runtime, function_name, _NATIVE_RETURN_KIND_UNKNOWN)",
     )
-    absent = [marker for marker in required if marker not in text]
-    if absent:
-        raise RuntimeError(f"native function return-kind validation failed: {absent}")
-    print("NORMALIZED NATIVE FUNCTION RETURN KINDS")
+    missing = [marker for marker in required if marker not in verified]
+    if missing:
+        raise RuntimeError(
+            "native callable return-kind stabilization failed: " + repr(missing)
+        )
+    if "_native_function_return_kinds" in verified:
+        raise RuntimeError("duplicate native function return-kind ledger remains")
+    print("STABILIZED NATIVE CALLABLE RETURN KINDS")
     return 0
 
 

From 424d34d15f039a90d44c33d3117edcb5033358c3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:39:38 -0500
Subject: [PATCH 296/450] Test unified callable return-kind inference

---
 ...ze_full_reference_function_return_kinds.py | 128 ++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_function_return_kinds.py

diff --git a/tests/test_normalize_full_reference_function_return_kinds.py b/tests/test_normalize_full_reference_function_return_kinds.py
new file mode 100644
index 00000000..d6bdb197
--- /dev/null
+++ b/tests/test_normalize_full_reference_function_return_kinds.py
@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_reference_expression_kinds as expression_kinds
+from tools import normalize_full_reference_function_return_kinds as return_kinds
+from tools import normalize_full_reference_value_kinds as value_kinds
+
+
+_PRELUDE = '''
+PORTAPY_VALUE_NONE = 0
+PORTAPY_VALUE_BOOL = 1
+PORTAPY_VALUE_INT = 2
+PORTAPY_VALUE_FLOAT = 3
+PORTAPY_VALUE_STRING = 4
+PORTAPY_VALUE_BYTES = 5
+PORTAPY_VALUE_CALLABLE = 6
+PORTAPY_VALUE_OBJECT = 7
+PORTAPY_VALUE_TUPLE = 8
+PORTAPY_VALUE_DICT = 9
+PORTAPY_VALUE_LIST = 10
+
+class Runtime:
+    pass
+
+class ValueKind:
+    NONE = object()
+    BOOL = object()
+    INT = object()
+    FLOAT = object()
+    STRING = object()
+    BYTES = object()
+    CALLABLE = object()
+    OBJECT = object()
+    TUPLE = object()
+    DICT = object()
+    LIST = object()
+
+'''
+
+
+def _normalized_namespace(tmp_path: Path, monkeypatch) -> dict[str, object]:
+    path = tmp_path / "native_full_reference_entry.py"
+    path.write_text(_PRELUDE + value_kinds._KIND_HELPERS, encoding="utf-8")
+    monkeypatch.setattr(expression_kinds, "PATH", path)
+    monkeypatch.setattr(return_kinds, "PATH", path)
+
+    assert expression_kinds.main() == 0
+    assert return_kinds.main() == 0
+
+    namespace: dict[str, object] = {}
+    exec(path.read_text(encoding="utf-8"), namespace)
+    return namespace
+
+
+def test_mixed_return_kinds_stay_object(tmp_path: Path, monkeypatch) -> None:
+    namespace = _normalized_namespace(tmp_path, monkeypatch)
+    record = namespace["_native_record_source_kinds"]
+    infer = namespace["_native_expression_kind"]
+
+    record(
+        1,
+        '''def mixed(flag):
+    if flag:
+        return 7
+    return
+
+def never_unmix(flag):
+    if flag == 1:
+        return 7
+    if flag == 2:
+        return "seven"
+    return 8
+''',
+    )
+
+    assert infer(1, "mixed(True)") == 7
+    assert infer(1, "never_unmix(1)") == 7
+
+
+def test_consistent_and_none_returns_remain_precise(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    namespace = _normalized_namespace(tmp_path, monkeypatch)
+    record = namespace["_native_record_source_kinds"]
+    infer = namespace["_native_expression_kind"]
+
+    record(
+        2,
+        '''def consistent(flag):
+    if flag:
+        return 7
+    return 8
+
+def explicit_none():
+    return
+
+def no_return():
+    pass
+''',
+    )
+
+    assert infer(2, "consistent(True)") == 2
+    assert infer(2, "explicit_none()") == 0
+    assert infer(2, "no_return()") == 7
+
+
+def test_nested_callable_return_uses_single_ledger(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    namespace = _normalized_namespace(tmp_path, monkeypatch)
+    record = namespace["_native_record_source_kinds"]
+    infer = namespace["_native_expression_kind"]
+
+    record(
+        3,
+        '''def outer():
+    def inner():
+        return 42
+    return inner
+''',
+    )
+
+    assert infer(3, "outer()") == 6
+    assert "_native_function_return_kinds" not in namespace
+    assert "_native_record_function_return_kinds" not in namespace

From 17c1aea3cfd14d717a5a178ff675b8e48cb837bf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:41:12 -0500
Subject: [PATCH 297/450] Run callable return-kind stabilizer after expression
 inference

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index ea450c2c..81ed20d8 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -121,8 +121,8 @@ def main() -> int:
         ("reference_error_text", normalize_reference_error_text),
         ("reference_error_locations", normalize_reference_error_locations),
         ("reference_value_kinds", normalize_reference_value_kinds),
-        ("reference_function_return_kinds", normalize_reference_function_return_kinds),
         ("reference_expression_kinds", normalize_reference_expression_kinds),
+        ("reference_function_return_kinds", normalize_reference_function_return_kinds),
         ("reference_nested_kinds", normalize_reference_nested_kinds),
         ("reference_source_preprocess", normalize_reference_source_preprocess),
         ("reference_data_builders", normalize_reference_data_builders),

From b642ab9f7b1992fb4dc8e446ea8e2362f62cc8ae Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:45:32 -0500
Subject: [PATCH 298/450] Preserve concise full-core normalization diagnostics

---
 tools/normalize_full_core_validation.py | 28 +++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 81ed20d8..5d430650 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -1,6 +1,8 @@
 """Apply the complete native full-core normalization pipeline."""
 from __future__ import annotations
 
+import contextlib
+import io
 from pathlib import Path
 import traceback
 from typing import Callable
@@ -53,6 +55,7 @@
 
 BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
 DIAGNOSTIC_PATH = Path("dist/full-core-normalization-error.txt")
+NORMALIZATION_LOG_PATH = Path("dist/full-core-normalization.log")
 
 
 def _normalize_nested_code_introspection() -> None:
@@ -87,18 +90,38 @@ def _normalize_opcode_validation() -> None:
     print("REMOVED HOST OPCODE TYPE IDENTITY", count, flush=True)
 
 
+def _append_step_log(name: str, output: str) -> None:
+    NORMALIZATION_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with NORMALIZATION_LOG_PATH.open("a", encoding="utf-8") as stream:
+        stream.write(f"=== {name} ===\n")
+        if output:
+            stream.write(output)
+            if not output.endswith("\n"):
+                stream.write("\n")
+        stream.write("\n")
+
+
 def _run_step(name: str, callback: Callable[[], object]) -> None:
     print(f"FULL-CORE NORMALIZE START: {name}", flush=True)
+    captured = io.StringIO()
     try:
-        result = callback()
+        with contextlib.redirect_stdout(captured), contextlib.redirect_stderr(captured):
+            result = callback()
         if result not in (None, 0):
             raise RuntimeError(f"normalizer returned non-zero result {result!r}")
     except BaseException:
-        diagnostic = f"failed step: {name}\n\n{traceback.format_exc()}"
+        output = captured.getvalue()
+        _append_step_log(name, output)
+        diagnostic = f"failed step: {name}\n"
+        if output:
+            diagnostic += f"\nstep output:\n{output.rstrip()}\n"
+        diagnostic += f"\n{traceback.format_exc()}"
         DIAGNOSTIC_PATH.parent.mkdir(parents=True, exist_ok=True)
         DIAGNOSTIC_PATH.write_text(diagnostic, encoding="utf-8")
         print(diagnostic, flush=True)
         raise
+    output = captured.getvalue()
+    _append_step_log(name, output)
     print(f"FULL-CORE NORMALIZE OK: {name}", flush=True)
 
 
@@ -152,6 +175,7 @@ def main() -> int:
         ("reference_type_errors", normalize_reference_type_errors),
     )
     DIAGNOSTIC_PATH.unlink(missing_ok=True)
+    NORMALIZATION_LOG_PATH.unlink(missing_ok=True)
     for name, callback in steps:
         _run_step(name, callback)
     return 0

From b90b25b325d5fcc994e30f1c6d17df01880b5978 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:49:13 -0500
Subject: [PATCH 299/450] Pin frontend default AST nodes

---
 tools/normalize_full_core_function_specs.py | 63 ++++++++++++++++-----
 1 file changed, 50 insertions(+), 13 deletions(-)

diff --git a/tools/normalize_full_core_function_specs.py b/tools/normalize_full_core_function_specs.py
index ccc58c9c..e268703c 100644
--- a/tools/normalize_full_core_function_specs.py
+++ b/tools/normalize_full_core_function_specs.py
@@ -1,10 +1,9 @@
-"""Canonicalize frontend MAKE_FUNCTION constants to four native-safe fields.
+"""Canonicalize frontend MAKE_FUNCTION constants to native-safe fields.
 
-The pinned compiler cannot safely lower ``len(node.args.defaults)`` because the
-opaque AST attribute is mistaken for text and measured with ``strlen``. Count
-default expressions while emitting them, and give every function/lambda the
-same fixed specification layout:
-``[code, default_count, kw_default_count, annotations]``.
+The pinned compiler cannot safely infer either the length or element type of the
+opaque AST default lists.  Count defaults while emitting them and read every
+positional, keyword-only, and lambda default through an explicitly typed
+``list[dict]`` so real AST node pointers reach ``_Lowerer.expr``.
 """
 from __future__ import annotations
 
@@ -17,22 +16,45 @@
                 self.expr(default)
             self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), len(node.args.defaults), 0)))
 '''
-_LAMBDA_NEW = '''            lambda_default_count = 0
-            for default in node.args.defaults:
-                self.expr(default)
+_LAMBDA_NEW = '''            lambda_defaults: list[dict] = getattr(node.args, "defaults")
+            lambda_default_count = 0
+            lambda_default_index = 0
+            while lambda_default_index < len(lambda_defaults):
+                lambda_default: dict = lambda_defaults[lambda_default_index]
+                self.expr(lambda_default)
                 lambda_default_count += 1
+                lambda_default_index += 1
             self.emit(Op.MAKE_FUNCTION, self.constant((nested.finish(), lambda_default_count, 0, {})))
 '''
 _FUNCTION_DEFAULTS_OLD = '''            for default in node.args.defaults:
                 self.expr(default)
             kw_default_count = 0
 '''
-_FUNCTION_DEFAULTS_NEW = '''            default_count = 0
-            for default in node.args.defaults:
-                self.expr(default)
+_FUNCTION_DEFAULTS_NEW = '''            function_defaults: list[dict] = getattr(node.args, "defaults")
+            default_count = 0
+            default_index = 0
+            while default_index < len(function_defaults):
+                function_default: dict = function_defaults[default_index]
+                self.expr(function_default)
                 default_count += 1
+                default_index += 1
             kw_default_count = 0
 '''
+_KW_DEFAULTS_OLD = '''            for default in node.args.kw_defaults:
+                if default is None:
+                    continue
+                self.expr(default)
+                kw_default_count += 1
+'''
+_KW_DEFAULTS_NEW = '''            keyword_defaults: list[dict] = getattr(node.args, "kw_defaults")
+            keyword_default_index = 0
+            while keyword_default_index < len(keyword_defaults):
+                keyword_default: dict = keyword_defaults[keyword_default_index]
+                if keyword_default is not None:
+                    self.expr(keyword_default)
+                    kw_default_count += 1
+                keyword_default_index += 1
+'''
 _FUNCTION_SPEC_OLD = (
     "self.constant((nested.finish(), len(node.args.defaults), "
     "kw_default_count, annotations))"
@@ -59,6 +81,12 @@ def main() -> int:
         _FUNCTION_DEFAULTS_NEW,
         "function defaults",
     )
+    source = _replace_one(
+        source,
+        _KW_DEFAULTS_OLD,
+        _KW_DEFAULTS_NEW,
+        "keyword-only defaults",
+    )
     source = _replace_one(
         source,
         _FUNCTION_SPEC_OLD,
@@ -71,20 +99,29 @@ def main() -> int:
         "self.constant((nested.finish(), len(node.args.defaults)",
         _LAMBDA_OLD,
         _FUNCTION_DEFAULTS_OLD,
+        _KW_DEFAULTS_OLD,
+        "for default in node.args.defaults:",
+        "for default in node.args.kw_defaults:",
     )
     remaining = [marker for marker in forbidden if marker in source]
     if remaining:
         raise RuntimeError(f"native frontend unsafe function specs remain: {remaining}")
     required = (
+        'lambda_defaults: list[dict] = getattr(node.args, "defaults")',
+        "lambda_default: dict = lambda_defaults[lambda_default_index]",
         "lambda_default_count += 1",
         "(nested.finish(), lambda_default_count, 0, {})",
+        'function_defaults: list[dict] = getattr(node.args, "defaults")',
+        "function_default: dict = function_defaults[default_index]",
         "default_count += 1",
+        'keyword_defaults: list[dict] = getattr(node.args, "kw_defaults")',
+        "keyword_default: dict = keyword_defaults[keyword_default_index]",
         "(nested.finish(), default_count, kw_default_count, annotations)",
     )
     missing = [marker for marker in required if marker not in source]
     if missing:
         raise RuntimeError(f"native frontend function spec validation failed: {missing}")
-    print("CANONICALIZED NATIVE FUNCTION SPECS", 2)
+    print("CANONICALIZED NATIVE FUNCTION SPECS", 3)
     return 0
 
 

From 43f74296be6148cab4f285a91e90c4c4d67d7510 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:49:31 -0500
Subject: [PATCH 300/450] Test typed default AST extraction

---
 .../test_normalize_full_core_function_specs.py  | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_core_function_specs.py b/tests/test_normalize_full_core_function_specs.py
index b2046c90..47758ce9 100644
--- a/tests/test_normalize_full_core_function_specs.py
+++ b/tests/test_normalize_full_core_function_specs.py
@@ -15,6 +15,11 @@ def lower_function(self, node):
             for default in node.args.defaults:
                 self.expr(default)
             kw_default_count = 0
+            for default in node.args.kw_defaults:
+                if default is None:
+                    continue
+                self.expr(default)
+                kw_default_count += 1
             self.emit(
                 Op.MAKE_FUNCTION,
                 self.constant((nested.finish(), len(node.args.defaults), kw_default_count, annotations)),
@@ -22,7 +27,7 @@ def lower_function(self, node):
 '''
 
 
-def test_counts_defaults_and_canonicalizes_four_fields(
+def test_counts_defaults_and_pins_ast_elements(
     tmp_path: Path, monkeypatch,
 ) -> None:
     path = tmp_path / "frontend.py"
@@ -32,13 +37,19 @@ def test_counts_defaults_and_canonicalizes_four_fields(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "lambda_default_count = 0" in source
+    assert 'lambda_defaults: list[dict] = getattr(node.args, "defaults")' in source
+    assert "lambda_default: dict = lambda_defaults[lambda_default_index]" in source
     assert "lambda_default_count += 1" in source
     assert "(nested.finish(), lambda_default_count, 0, {})" in source
-    assert "default_count = 0" in source
+    assert 'function_defaults: list[dict] = getattr(node.args, "defaults")' in source
+    assert "function_default: dict = function_defaults[default_index]" in source
     assert "default_count += 1" in source
+    assert 'keyword_defaults: list[dict] = getattr(node.args, "kw_defaults")' in source
+    assert "keyword_default: dict = keyword_defaults[keyword_default_index]" in source
     assert "(nested.finish(), default_count, kw_default_count, annotations)" in source
     assert "len(node.args.defaults)" not in source
+    assert "for default in node.args.defaults:" not in source
+    assert "for default in node.args.kw_defaults:" not in source
 
 
 def test_fails_closed_without_lambda_defaults_shape(

From d6f94eb2ed6c2c7702e83f1a7dc131bcebcffade Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:49:49 -0500
Subject: [PATCH 301/450] Make native-default normalization tests structural

---
 ...lize_full_core_native_argument_defaults.py | 32 +++++++++++++++++--
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_core_native_argument_defaults.py b/tests/test_normalize_full_core_native_argument_defaults.py
index eaa9f469..22cfcae9 100644
--- a/tests/test_normalize_full_core_native_argument_defaults.py
+++ b/tests/test_normalize_full_core_native_argument_defaults.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 from tools import normalize_full_core_native_argument_defaults as normalizer
@@ -24,6 +25,17 @@
 '''
 
 
+def _function(path: Path) -> ast.FunctionDef:
+    module = ast.parse(path.read_text(encoding="utf-8"))
+    functions = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_arguments"
+    ]
+    assert len(functions) == 1
+    return functions[0]
+
+
 def test_pins_default_elements_to_dict_backed_ast(
     tmp_path: Path, monkeypatch,
 ) -> None:
@@ -33,8 +45,22 @@ def test_pins_default_elements_to_dict_backed_ast(
 
     assert normalizer.main() == 0
 
-    source = path.read_text(encoding="utf-8")
-    assert 'native_defaults: list[dict] = getattr(node, "defaults")' in source
+    function = _function(path)
+    source = ast.unparse(function)
+    annotated_getattrs = [
+        node
+        for node in ast.walk(function)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "native_defaults"
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name)
+        and node.value.func.id == "getattr"
+        and len(node.value.args) == 2
+        and isinstance(node.value.args[1], ast.Constant)
+        and node.value.args[1].value == "defaults"
+    ]
+    assert len(annotated_getattrs) == 1
     assert source.count("default_node: dict = native_defaults[index]") == 2
     assert "defaults.append(_convert_expr(default_node, lifted))" in source
     assert "_convert_expr(node.defaults[index], lifted)" not in source
@@ -59,6 +85,6 @@ def test_fails_closed_for_unknown_shape(tmp_path: Path, monkeypatch) -> None:
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "source shape changed" in str(error)
+        assert "native default" in str(error)
     else:
         raise AssertionError("normalizer accepted an unknown default bridge")

From 3f4d1eabdc3ac1ad0799d65726ba2de8f5fb524a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:52:17 -0500
Subject: [PATCH 302/450] Transport native keyword arguments without raw dict
 ABI

---
 ...lize_full_core_native_keyword_transport.py | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 tools/normalize_full_core_native_keyword_transport.py

diff --git a/tools/normalize_full_core_native_keyword_transport.py b/tools/normalize_full_core_native_keyword_transport.py
new file mode 100644
index 00000000..80c9b5d5
--- /dev/null
+++ b/tools/normalize_full_core_native_keyword_transport.py
@@ -0,0 +1,101 @@
+"""Avoid passing freshly-built keyword dictionaries across the native call ABI.
+
+The pinned native compiler can materialize dictionaries locally, but a keyword
+mapping created in the CALL_KW opcode path may arrive at ``VirtualMachine._call``
+as a null raw dictionary pointer.  Positional calls are unaffected.  Transport
+keyword names and values as lists instead, then build the mapping inside
+``_call`` where it is consumed.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+VM_PATH = Path("src/portapy/core/vm.py")
+
+
+def _replace(source: str, old: str, new: str, *, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(f"{label}: expected 1 match, found {count}")
+    return source.replace(old, new, 1)
+
+
+def main() -> int:
+    source = VM_PATH.read_text(encoding="utf-8")
+    source = _replace(
+        source,
+        '''    def _call(self, target: object, args: list[object], kwargs: dict[str, object] | None = None) -> object:
+        kwargs = kwargs or {}
+''',
+        '''    def _call(
+        self,
+        target: object,
+        args: list[object],
+        kwargs: dict[str, object] | None = None,
+        keyword_names: list[object] | None = None,
+        keyword_values: list[object] | None = None,
+    ) -> object:
+        kwargs = kwargs or {}
+        if keyword_names is not None and keyword_values is not None:
+            keyword_index = 0
+            while keyword_index < len(keyword_names):
+                keyword_name = keyword_names[keyword_index]
+                keyword_value = keyword_values[keyword_index]
+                if keyword_name is None:
+                    if not isinstance(keyword_value, dict):
+                        _raise_typed("TypeError: ** argument must be a mapping")
+                    for mapping_name, mapping_value in keyword_value.items():
+                        kwargs[mapping_name] = mapping_value
+                else:
+                    kwargs[keyword_name] = keyword_value
+                keyword_index += 1
+''',
+        label="native keyword receiver",
+    )
+    source = _replace(
+        source,
+        '''                    kwargs: dict[str, object] = {}
+                    for name, value in zip(names, values):
+                        if name is None:
+                            if not isinstance(value, dict): _raise_typed("TypeError: ** argument must be a mapping")
+                            kwargs.update(value)
+                        else:
+                            kwargs[name] = value
+                    if getattr(target, "__pyinbin_super__", False) and not positional and not kwargs:
+                        instance = frame.locals.get("self")
+                        cls = self._lexical_super_class(frame, instance)
+                        frame.stack.append(SuperProxy(self, cls, instance))
+                    else:
+                        frame.stack.append(self._call(target, positional, kwargs))
+''',
+        '''                    keyword_names: list[object] = []
+                    for name in names:
+                        keyword_names.append(name)
+                    if getattr(target, "__pyinbin_super__", False) and not positional and not keyword_names:
+                        instance = frame.locals.get("self")
+                        cls = self._lexical_super_class(frame, instance)
+                        frame.stack.append(SuperProxy(self, cls, instance))
+                    else:
+                        frame.stack.append(
+                            self._call(target, positional, None, keyword_names, values)
+                        )
+''',
+        label="native keyword sender",
+    )
+    VM_PATH.write_text(source, encoding="utf-8")
+    verified = VM_PATH.read_text(encoding="utf-8")
+    required = (
+        "keyword_names: list[object] | None = None",
+        "keyword_values: list[object] | None = None",
+        "self._call(target, positional, None, keyword_names, values)",
+    )
+    missing = [marker for marker in required if marker not in verified]
+    if missing:
+        raise RuntimeError(f"native keyword transport validation failed: {missing}")
+    print("NORMALIZED NATIVE KEYWORD TRANSPORT")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From c98e3d3d80d9f861a57cf98a6ee5fde42041c662 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:52:51 -0500
Subject: [PATCH 303/450] Apply native keyword transport normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5d430650..ff5d74ad 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -24,6 +24,7 @@
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_name_index import main as normalize_name_index
 from tools.normalize_full_core_native_argument_defaults import main as normalize_native_argument_defaults
+from tools.normalize_full_core_native_keyword_transport import main as normalize_native_keyword_transport
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
@@ -155,6 +156,7 @@ def main() -> int:
         ("native_argument_defaults", normalize_native_argument_defaults),
         ("calls_closures", normalize_calls_closures),
         ("keyword_calls", normalize_keyword_calls),
+        ("native_keyword_transport", normalize_native_keyword_transport),
         ("combine_native_parser", combine_native_parser),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("expr_stmt_initializer", normalize_expr_stmt_initializer),

From b8aaa6e65fb1c6384bafd608410e9dce7943e29e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:55:38 -0500
Subject: [PATCH 304/450] Run native keyword transport before VM rewrites

---
 tools/normalize_full_core_validation.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index ff5d74ad..220359dc 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -128,6 +128,9 @@ def _run_step(name: str, callback: Callable[[], object]) -> None:
 
 def main() -> int:
     steps: tuple[tuple[str, Callable[[], object]], ...] = (
+        # This pass relies on pristine VM source anchors. Keep it before every
+        # normalizer that rewrites or unparses src/portapy/core/vm.py.
+        ("native_keyword_transport", normalize_native_keyword_transport),
         ("probe", normalize_probe),
         ("lambdas", normalize_lambdas),
         ("function_specs", normalize_function_specs),
@@ -156,7 +159,6 @@ def main() -> int:
         ("native_argument_defaults", normalize_native_argument_defaults),
         ("calls_closures", normalize_calls_closures),
         ("keyword_calls", normalize_keyword_calls),
-        ("native_keyword_transport", normalize_native_keyword_transport),
         ("combine_native_parser", combine_native_parser),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("expr_stmt_initializer", normalize_expr_stmt_initializer),

From 1a0b42e132d278e1e06cd2d6cea67fece70dcbba Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 15:56:11 -0500
Subject: [PATCH 305/450] Test native keyword transport normalization

---
 ...lize_full_core_native_keyword_transport.py | 92 +++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_keyword_transport.py

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
new file mode 100644
index 00000000..ccf24bc3
--- /dev/null
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_native_keyword_transport as normalizer
+from tools import normalize_full_core_validation as validation
+
+
+_SOURCE = '''class VirtualMachine:
+    def _call(self, target: object, args: list[object], kwargs: dict[str, object] | None = None) -> object:
+        kwargs = kwargs or {}
+        return target
+
+    def _run_frame(self, frame: object) -> object:
+        target = object()
+        positional: list[object] = []
+        names: list[object] = []
+        values: list[object] = []
+                    kwargs: dict[str, object] = {}
+                    for name, value in zip(names, values):
+                        if name is None:
+                            if not isinstance(value, dict): _raise_typed("TypeError: ** argument must be a mapping")
+                            kwargs.update(value)
+                        else:
+                            kwargs[name] = value
+                    if getattr(target, "__pyinbin_super__", False) and not positional and not kwargs:
+                        instance = frame.locals.get("self")
+                        cls = self._lexical_super_class(frame, instance)
+                        frame.stack.append(SuperProxy(self, cls, instance))
+                    else:
+                        frame.stack.append(self._call(target, positional, kwargs))
+'''
+
+
+def test_transports_keyword_names_and_values_as_lists(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "VM_PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "keyword_names: list[object] | None = None" in source
+    assert "keyword_values: list[object] | None = None" in source
+    assert "self._call(target, positional, None, keyword_names, values)" in source
+    assert "kwargs: dict[str, object] = {}" not in source
+    assert "for name, value in zip(names, values):" not in source
+
+
+def test_fails_closed_when_call_shape_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text("class VirtualMachine:\n    pass\n", encoding="utf-8")
+    monkeypatch.setattr(normalizer, "VM_PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "native keyword receiver" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unknown VM call shape")
+
+
+def test_keyword_transport_runs_before_every_other_normalizer() -> None:
+    module = ast.parse(Path(validation.__file__).read_text(encoding="utf-8"))
+    main = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "main"
+    )
+    assignment = next(
+        node
+        for node in main.body
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "steps"
+    )
+    assert isinstance(assignment.value, ast.Tuple)
+    names = [
+        item.elts[0].value
+        for item in assignment.value.elts
+        if isinstance(item, ast.Tuple)
+        and len(item.elts) == 2
+        and isinstance(item.elts[0], ast.Constant)
+    ]
+    assert names[0] == "native_keyword_transport"

From b293336e006e5bdee9e0c826730e2dd35ee6ccd2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:04:43 -0500
Subject: [PATCH 306/450] Remove duplicate native shared-library workflow

---
 .github/workflows/native-probe.yml | 149 -----------------------------
 1 file changed, 149 deletions(-)
 delete mode 100644 .github/workflows/native-probe.yml

diff --git a/.github/workflows/native-probe.yml b/.github/workflows/native-probe.yml
deleted file mode 100644
index bad94549..00000000
--- a/.github/workflows/native-probe.yml
+++ /dev/null
@@ -1,149 +0,0 @@
-name: Native shared-library probe
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Compile Python source and link libportapy_probe.so
-        shell: bash
-        run: |
-          mkdir -p dist
-          set +e
-          set -o pipefail
-          python -m asmpython build src/portapy/native_probe.py \
-            --target linux --type library --backend legacy \
-            --no-pyinbin-fallback --keep-assembly \
-            -o dist/libportapy_probe.so \
-            2>&1 | tee dist/linux-build.log
-          compiler_status=${PIPESTATUS[0]}
-          set -e
-
-          if [ ! -f dist/libportapy_probe.asm ]; then
-            exit "$compiler_status"
-          fi
-
-          python tools/nasm_module_init.py dist/libportapy_probe.asm \
-            --target linux --public-symbol portapy_library_initialize
-          python tools/nasm_exports.py dist/libportapy_probe.asm \
-            --export portapy_library_initialize \
-            --export portapy_abi_version \
-            --export portapy_opcode_probe
-          python tools/elf_pic.py dist/libportapy_probe.asm
-          nasm -f elf64 -w-label-redef-late \
-            dist/libportapy_probe.asm -o dist/libportapy_probe.o
-          cat > dist/portapy_probe.map <<'MAP'
-          {
-            global:
-              portapy_library_initialize;
-              portapy_abi_version;
-              portapy_opcode_probe;
-            local: *;
-          };
-          MAP
-          gcc -shared dist/libportapy_probe.o -o dist/libportapy_probe.so \
-            -Wl,--version-script=dist/portapy_probe.map
-      - name: Inspect and execute through an external C host
-        run: |
-          file dist/libportapy_probe.so
-          readelf -dW dist/libportapy_probe.so | tee dist/linux-dynamic.txt
-          if readelf -dW dist/libportapy_probe.so | grep -q TEXTREL; then
-            echo 'text relocations are forbidden'
-            exit 1
-          fi
-          nm -D --defined-only dist/libportapy_probe.so | tee dist/linux-exports.txt
-          awk '{print $3}' dist/linux-exports.txt | grep '^portapy_' | sort > dist/linux-portapy-symbols.txt
-          printf 'portapy_abi_version\nportapy_library_initialize\nportapy_opcode_probe\n' > dist/expected-symbols.txt
-          diff -u dist/expected-symbols.txt dist/linux-portapy-symbols.txt
-          if awk '{print $3}' dist/linux-exports.txt | grep -qx main; then
-            echo 'main must not be public'
-            exit 1
-          fi
-          cc -std=c11 -Wall -Wextra -Werror tests/native_probe_host.c -ldl -o dist/native_probe_host
-          ./dist/native_probe_host ./dist/libportapy_probe.so | tee dist/linux-host-output.txt
-          grep -qx 'abi=1 opcode=10' dist/linux-host-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-probe
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Compile Python source and link portapy_probe.dll
-        shell: powershell
-        run: |
-          New-Item -ItemType Directory -Force dist | Out-Null
-          python -m asmpython build src/portapy/native_probe.py `
-            --target windows --type library --backend legacy `
-            --no-pyinbin-fallback --keep-assembly `
-            -o dist/portapy_probe.dll `
-            *>&1 | Tee-Object -FilePath dist/windows-build.log
-          $compilerExit = $LASTEXITCODE
-
-          if (-not (Test-Path dist/portapy_probe.asm)) {
-            exit $compilerExit
-          }
-          python tools/nasm_module_init.py dist/portapy_probe.asm `
-            --target windows --public-symbol portapy_library_initialize
-          python tools/nasm_exports.py dist/portapy_probe.asm `
-            --export portapy_library_initialize `
-            --export portapy_abi_version `
-            --export portapy_opcode_probe
-          nasm -f win64 -w-label-redef-late `
-            dist/portapy_probe.asm -o dist/portapy_probe.obj
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          @'
-          LIBRARY portapy_probe
-          EXPORTS
-              portapy_library_initialize
-              portapy_abi_version
-              portapy_opcode_probe
-          '@ | Set-Content -Encoding ascii dist/portapy_probe.def
-          gcc -shared dist/portapy_probe.obj dist/portapy_probe.def `
-            -o dist/portapy_probe.dll
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Inspect and execute through an external C host
-        shell: powershell
-        run: |
-          objdump -p dist/portapy_probe.dll | Out-File -Encoding utf8 dist/windows-exports.txt
-          if (-not (Select-String -Path dist/windows-exports.txt -Pattern 'portapy_library_initialize' -Quiet)) { throw 'missing portapy_library_initialize' }
-          if (-not (Select-String -Path dist/windows-exports.txt -Pattern 'portapy_abi_version' -Quiet)) { throw 'missing portapy_abi_version' }
-          if (-not (Select-String -Path dist/windows-exports.txt -Pattern 'portapy_opcode_probe' -Quiet)) { throw 'missing portapy_opcode_probe' }
-          gcc -std=c11 -Wall -Wextra -Werror tests/native_probe_host.c -o dist/native_probe_host.exe
-          $output = & dist/native_probe_host.exe dist/portapy_probe.dll
-          $output | Out-File -Encoding utf8 dist/windows-host-output.txt
-          if ($output -ne 'abi=1 opcode=10') { throw "unexpected host output: $output" }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-probe
-          path: dist

From 4dfbf34e819bf6bc0f856101ef17953de428433b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:04:54 -0500
Subject: [PATCH 307/450] Remove duplicate native function workflow

---
 .github/workflows/native-functions.yml | 119 -------------------------
 1 file changed, 119 deletions(-)
 delete mode 100644 .github/workflows/native-functions.yml

diff --git a/.github/workflows/native-functions.yml b/.github/workflows/native-functions.yml
deleted file mode 100644
index 36e3d21e..00000000
--- a/.github/workflows/native-functions.yml
+++ /dev/null
@@ -1,119 +0,0 @@
-name: Native function probe
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Compile generated native function entry
-        run: |
-          python tools/build_native_functions.py \
-            --target linux \
-            --output dist/libportapy-functions.so \
-            --work-dir dist/build-functions-linux
-      - name: Execute function entry from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_function_host.c -ldl -o dist/native_function_host
-          ./dist/native_function_host ./dist/libportapy-functions.so \
-            | tee dist/native-function-output.txt
-          grep -qx 'native-functions: ok' dist/native-function-output.txt
-      - name: Execute positional variadics from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_varargs_host.c -ldl -o dist/native_varargs_host
-          ./dist/native_varargs_host ./dist/libportapy-functions.so \
-            | tee dist/native-varargs-output.txt
-          grep -qx 'native-varargs: ok' dist/native-varargs-output.txt
-      - name: Execute keyword variadics from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_kwargs_host.c -ldl -o dist/native_kwargs_host
-          ./dist/native_kwargs_host ./dist/libportapy-functions.so \
-            | tee dist/native-kwargs-output.txt
-          grep -qx 'native-kwargs: ok' dist/native-kwargs-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-functions
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Compile generated native function entry
-        shell: powershell
-        run: |
-          python tools/build_native_functions.py `
-            --target windows `
-            --output dist/portapy-functions.dll `
-            --work-dir dist/build-functions-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Execute function entry from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_function_host.c -o dist/native_function_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_function_host.exe dist/portapy-functions.dll
-          $output | Out-File -Encoding utf8 dist/native-function-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-functions: ok') {
-            throw "unexpected native function output: $output"
-          }
-      - name: Execute positional variadics from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_varargs_host.c -o dist/native_varargs_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_varargs_host.exe dist/portapy-functions.dll
-          $output | Out-File -Encoding utf8 dist/native-varargs-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-varargs: ok') {
-            throw "unexpected native varargs output: $output"
-          }
-      - name: Execute keyword variadics from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_kwargs_host.c -o dist/native_kwargs_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_kwargs_host.exe dist/portapy-functions.dll
-          $output | Out-File -Encoding utf8 dist/native-kwargs-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-kwargs: ok') {
-            throw "unexpected native kwargs output: $output"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-functions
-          path: dist

From 3b3c59e8e79cf7b0522f4f427a19249fc3ccd097 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:02 -0500
Subject: [PATCH 308/450] Remove duplicate native host-object workflow

---
 .github/workflows/native-host-objects.yml | 81 -----------------------
 1 file changed, 81 deletions(-)
 delete mode 100644 .github/workflows/native-host-objects.yml

diff --git a/.github/workflows/native-host-objects.yml b/.github/workflows/native-host-objects.yml
deleted file mode 100644
index 4455efe6..00000000
--- a/.github/workflows/native-host-objects.yml
+++ /dev/null
@@ -1,81 +0,0 @@
-name: Native host object probe
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build host-object library
-        run: |
-          python tools/build_native_host.py \
-            --target linux \
-            --output dist/libportapy-host.so \
-            --work-dir dist/build-host-linux
-      - name: Execute host-object bridge from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_host_object_host.c -ldl -o dist/native_host_object_host
-          ./dist/native_host_object_host ./dist/libportapy-host.so \
-            | tee dist/native-host-output.txt
-          grep -qx 'native-host-objects: ok' dist/native-host-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-host-objects
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build host-object library
-        shell: powershell
-        run: |
-          python tools/build_native_host.py `
-            --target windows `
-            --output dist/portapy-host.dll `
-            --work-dir dist/build-host-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Execute host-object bridge from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_host_object_host.c -o dist/native_host_object_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_host_object_host.exe dist/portapy-host.dll
-          $output | Out-File -Encoding utf8 dist/native-host-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-host-objects: ok') {
-            throw "unexpected native host output: $output"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-host-objects
-          path: dist

From 4097a434f34063fc135380b30484fb96877e3301 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:11 -0500
Subject: [PATCH 309/450] Remove duplicate native list workflow

---
 .github/workflows/native-lists.yml | 98 ------------------------------
 1 file changed, 98 deletions(-)
 delete mode 100644 .github/workflows/native-lists.yml

diff --git a/.github/workflows/native-lists.yml b/.github/workflows/native-lists.yml
deleted file mode 100644
index a742f8c8..00000000
--- a/.github/workflows/native-lists.yml
+++ /dev/null
@@ -1,98 +0,0 @@
-name: Native list ABI
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          python -m pip install -e .
-      - name: Build native library with list ABI
-        run: |
-          python tools/build_native_host_calls.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-lists-linux
-      - name: Execute public list ABI from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_list_host.c -ldl -o dist/native_list_host
-          ./dist/native_list_host ./dist/libportapy.so \
-            | tee dist/list-output.txt
-          grep -qx 'native-lists: ok' dist/list-output.txt
-      - name: Exercise Python list facade
-        run: |
-          python tests/native_list_adapter_probe.py ./dist/libportapy.so \
-            | tee dist/list-adapter-output.txt
-          grep -qx 'native-list-adapter: ok' dist/list-adapter-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-lists
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          python -m pip install -e .
-      - name: Build native library with list ABI
-        shell: powershell
-        run: |
-          python tools/build_native_host_calls.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-lists-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Execute public list ABI from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_list_host.c -o dist/native_list_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_list_host.exe dist/portapy.dll
-          $output | Out-File -Encoding utf8 dist/list-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          if ($output -ne 'native-lists: ok') {
-            throw "unexpected native list output: $output"
-          }
-      - name: Exercise Python list facade
-        shell: powershell
-        run: |
-          $output = @(python tests/native_list_adapter_probe.py dist/portapy.dll)
-          $output | Out-File -Encoding utf8 dist/list-adapter-output.txt
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $lastLine = $output[-1]
-          if ($lastLine -ne 'native-list-adapter: ok') {
-            throw "unexpected native list adapter output: $($output -join [Environment]::NewLine)"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-lists
-          path: dist

From 58812fc2f50e134243716062dba2945465dfcea2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:19 -0500
Subject: [PATCH 310/450] Remove duplicate native host-call workflow

---
 .github/workflows/native-host-calls.yml | 107 ------------------------
 1 file changed, 107 deletions(-)
 delete mode 100644 .github/workflows/native-host-calls.yml

diff --git a/.github/workflows/native-host-calls.yml b/.github/workflows/native-host-calls.yml
deleted file mode 100644
index 6491ecc5..00000000
--- a/.github/workflows/native-host-calls.yml
+++ /dev/null
@@ -1,107 +0,0 @@
-name: Native host call probe
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build host-call library
-        run: |
-          python tools/build_native_host_calls.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-linux
-      - name: Execute host calls from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_host_call_host.c -ldl -o dist/native_host_call_host
-          ./dist/native_host_call_host ./dist/libportapy.so | tee dist/host-call-output.txt
-          grep -qx 'native-host-calls: ok' dist/host-call-output.txt
-      - name: Execute public tuple ABI from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_tuple_host.c -ldl -o dist/native_tuple_host
-          ./dist/native_tuple_host ./dist/libportapy.so | tee dist/tuple-output.txt
-          grep -qx 'native-tuples: ok' dist/tuple-output.txt
-      - name: Execute public dictionary ABI from C
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_dict_host.c -ldl -o dist/native_dict_host
-          ./dist/native_dict_host ./dist/libportapy.so | tee dist/dict-output.txt
-          grep -qx 'native-dicts: ok' dist/dict-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-host-calls
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build host-call library
-        shell: powershell
-        run: |
-          python tools/build_native_host_calls.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Execute host calls from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_host_call_host.c -o dist/native_host_call_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_host_call_host.exe dist/portapy.dll
-          $output | Out-File -Encoding utf8 dist/host-call-output.txt
-          if ($output -ne 'native-host-calls: ok') { throw "unexpected host-call output: $output" }
-      - name: Execute public tuple ABI from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_tuple_host.c -o dist/native_tuple_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_tuple_host.exe dist/portapy.dll
-          $output | Out-File -Encoding utf8 dist/tuple-output.txt
-          if ($output -ne 'native-tuples: ok') { throw "unexpected tuple output: $output" }
-      - name: Execute public dictionary ABI from C
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_dict_host.c -o dist/native_dict_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_dict_host.exe dist/portapy.dll
-          $output | Out-File -Encoding utf8 dist/dict-output.txt
-          if ($output -ne 'native-dicts: ok') { throw "unexpected dictionary output: $output" }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-host-calls
-          path: dist

From 8ad1ff10e8cdf8e6a90d5201889248dfe75f9771 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:27 -0500
Subject: [PATCH 311/450] Remove duplicate native handle workflow

---
 .github/workflows/native-handles.yml | 226 ---------------------------
 1 file changed, 226 deletions(-)
 delete mode 100644 .github/workflows/native-handles.yml

diff --git a/.github/workflows/native-handles.yml b/.github/workflows/native-handles.yml
deleted file mode 100644
index 203765d9..00000000
--- a/.github/workflows/native-handles.yml
+++ /dev/null
@@ -1,226 +0,0 @@
-name: Native opaque-handle ABI
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build genuine Python-authored library
-        run: |
-          python tools/build_native_typed.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-linux
-      - name: Report Linux build failure
-        if: failure() && github.event_name == 'pull_request'
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          {
-            echo '<!-- portapy-native-linux-diagnostic -->'
-            echo '### Linux native build diagnostic'
-            echo
-            echo '```text'
-            find dist -maxdepth 3 -type f -print 2>/dev/null || true
-            echo
-            for file in \
-              dist/build-linux/linux-asmpython-build.log \
-              dist/build-linux/linux-nasm.log \
-              dist/build-linux/linux-glue.log \
-              dist/build-linux/linux-host-glue.log \
-              dist/build-linux/linux-host-call-glue.log \
-              dist/build-linux/linux-host-call-nasm.log \
-              dist/build-linux/linux-host-call-link.log \
-              dist/build-linux/linux-link.log; do
-              if [ -f "$file" ]; then
-                echo "===== $file ====="
-                tail -n 120 "$file"
-              fi
-            done
-            echo '```'
-          } > /tmp/portapy-linux-diagnostic.md
-          gh pr comment "${{ github.event.pull_request.number }}" \
-            --body-file /tmp/portapy-linux-diagnostic.md
-      - name: Verify exports and execute external hosts
-        run: |
-          if readelf -dW dist/libportapy.so | grep -q TEXTREL; then
-            echo 'text relocations are forbidden'
-            exit 1
-          fi
-          nm -D --defined-only dist/libportapy.so | tee dist/linux-exports.txt
-          awk '{print $3}' dist/linux-exports.txt | grep '^portapy_' | sort > dist/actual-symbols.txt
-          python - <<'PY'
-          from pathlib import Path
-          from tools.native_surface import public_exports
-          Path('dist/expected-symbols.txt').write_text(
-              '\n'.join(sorted(public_exports(host_bridge=True, host_calls=True))) + '\n',
-              encoding='utf-8',
-          )
-          PY
-          diff -u dist/expected-symbols.txt dist/actual-symbols.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_handle_host.c -ldl -o dist/native_handle_host
-          ./dist/native_handle_host ./dist/libportapy.so | tee dist/host-output.txt
-          grep -qx 'opaque-floats: ok' dist/host-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_statement_host.c -ldl -o dist/native_statement_host
-          ./dist/native_statement_host ./dist/libportapy.so | tee dist/statement-output.txt
-          grep -qx 'statement-blocks: ok' dist/statement-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_text_error_host.c -ldl -o dist/native_text_error_host
-          ./dist/native_text_error_host ./dist/libportapy.so | tee dist/text-error-output.txt
-          grep -qx 'native-text-errors: ok' dist/text-error-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_typed_literal_host.c -ldl -o dist/native_typed_literal_host
-          ./dist/native_typed_literal_host ./dist/libportapy.so | tee dist/typed-literal-output.txt
-          grep -qx 'typed-literals: ok' dist/typed-literal-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_boolean_expression_host.c -ldl -o dist/native_boolean_expression_host
-          ./dist/native_boolean_expression_host ./dist/libportapy.so | tee dist/boolean-expression-output.txt
-          grep -qx 'boolean-expressions: ok' dist/boolean-expression-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_expression_host.c -ldl -o dist/native_expression_host
-          ./dist/native_expression_host ./dist/libportapy.so | tee dist/expression-output.txt
-          grep -qx 'general-expressions: ok' dist/expression-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_control_flow_host.c -ldl -o dist/native_control_flow_host
-          ./dist/native_control_flow_host ./dist/libportapy.so | tee dist/control-flow-output.txt
-          grep -qx 'control-flow: ok' dist/control-flow-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_function_host.c -ldl -o dist/native_function_host
-          ./dist/native_function_host ./dist/libportapy.so | tee dist/function-output.txt
-          grep -qx 'native-functions: ok' dist/function-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_host_object_host.c -ldl -o dist/native_host_object_host
-          ./dist/native_host_object_host ./dist/libportapy.so | tee dist/host-object-output.txt
-          grep -qx 'native-host-objects: ok' dist/host-object-output.txt
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_host_call_host.c -ldl -o dist/native_host_call_host
-          ./dist/native_host_call_host ./dist/libportapy.so | tee dist/host-call-output.txt
-          grep -qx 'native-host-calls: ok' dist/host-call-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build genuine Python-authored library
-        shell: powershell
-        run: |
-          python tools/build_native_typed.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Report Windows build failure
-        if: failure() && github.event_name == 'pull_request'
-        shell: powershell
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          $lines = @(
-            '<!-- portapy-native-windows-diagnostic -->',
-            '### Windows native build diagnostic',
-            '',
-            '```text'
-          )
-          Get-ChildItem -Path dist -File -Recurse -ErrorAction SilentlyContinue |
-            ForEach-Object { $lines += $_.FullName }
-          foreach ($file in @(
-            'dist/build-windows/windows-asmpython-build.log',
-            'dist/build-windows/windows-nasm.log',
-            'dist/build-windows/windows-glue.log',
-            'dist/build-windows/windows-host-glue.log',
-            'dist/build-windows/windows-host-call-glue.log',
-            'dist/build-windows/windows-host-call-nasm.log',
-            'dist/build-windows/windows-host-call-link.log',
-            'dist/build-windows/windows-link.log'
-          )) {
-            if (Test-Path $file) {
-              $lines += "===== $file ====="
-              $lines += Get-Content $file -Tail 120
-            }
-          }
-          $lines += '```'
-          $lines | Set-Content -Encoding utf8 $env:RUNNER_TEMP\portapy-windows-diagnostic.md
-          gh pr comment "${{ github.event.pull_request.number }}" `
-            --body-file $env:RUNNER_TEMP\portapy-windows-diagnostic.md
-      - name: Verify exports and execute external hosts
-        shell: powershell
-        run: |
-          objdump -p dist/portapy.dll | Out-File -Encoding utf8 dist/windows-exports.txt
-          $symbols = python -c "from tools.native_surface import public_exports; print(' '.join(public_exports(host_bridge=True, host_calls=True)))"
-          foreach ($symbol in $symbols.Split(' ', [System.StringSplitOptions]::RemoveEmptyEntries)) {
-            if (-not (Select-String -Path dist/windows-exports.txt -Pattern "\b$symbol\b" -Quiet)) {
-              throw "missing export: $symbol"
-            }
-          }
-          if (Select-String -Path dist/windows-exports.txt -Pattern 'portapy_internal_' -Quiet) {
-            throw 'internal Python symbols must not be exported'
-          }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_handle_host.c -o dist/native_handle_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = & dist/native_handle_host.exe dist/portapy.dll
-          if ($output -ne 'opaque-floats: ok') { throw "unexpected host output: $output" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_statement_host.c -o dist/native_statement_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $statementOutput = & dist/native_statement_host.exe dist/portapy.dll
-          if ($statementOutput -ne 'statement-blocks: ok') { throw "unexpected statement output: $statementOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_text_error_host.c -o dist/native_text_error_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $textErrorOutput = & dist/native_text_error_host.exe dist/portapy.dll
-          if ($textErrorOutput -ne 'native-text-errors: ok') { throw "unexpected text/error output: $textErrorOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_typed_literal_host.c -o dist/native_typed_literal_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $typedLiteralOutput = & dist/native_typed_literal_host.exe dist/portapy.dll
-          if ($typedLiteralOutput -ne 'typed-literals: ok') { throw "unexpected typed literal output: $typedLiteralOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_boolean_expression_host.c -o dist/native_boolean_expression_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $booleanExpressionOutput = & dist/native_boolean_expression_host.exe dist/portapy.dll
-          if ($booleanExpressionOutput -ne 'boolean-expressions: ok') { throw "unexpected boolean expression output: $booleanExpressionOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_expression_host.c -o dist/native_expression_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $expressionOutput = & dist/native_expression_host.exe dist/portapy.dll
-          if ($expressionOutput -ne 'general-expressions: ok') { throw "unexpected expression output: $expressionOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_control_flow_host.c -o dist/native_control_flow_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $controlFlowOutput = & dist/native_control_flow_host.exe dist/portapy.dll
-          if ($controlFlowOutput -ne 'control-flow: ok') { throw "unexpected control-flow output: $controlFlowOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_function_host.c -o dist/native_function_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $functionOutput = & dist/native_function_host.exe dist/portapy.dll
-          if ($functionOutput -ne 'native-functions: ok') { throw "unexpected function output: $functionOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_host_object_host.c -o dist/native_host_object_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $hostObjectOutput = & dist/native_host_object_host.exe dist/portapy.dll
-          if ($hostObjectOutput -ne 'native-host-objects: ok') { throw "unexpected host-object output: $hostObjectOutput" }
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude tests/native_host_call_host.c -o dist/native_host_call_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $hostCallOutput = & dist/native_host_call_host.exe dist/portapy.dll
-          if ($hostCallOutput -ne 'native-host-calls: ok') { throw "unexpected host-call output: $hostCallOutput" }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native
-          path: dist

From f84d3b5dd9c126bad1b930510780f26667f75d0d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:36 -0500
Subject: [PATCH 312/450] Remove duplicate native environment-adapter workflow

---
 .../workflows/native-environment-adapter.yml  | 83 -------------------
 1 file changed, 83 deletions(-)
 delete mode 100644 .github/workflows/native-environment-adapter.yml

diff --git a/.github/workflows/native-environment-adapter.yml b/.github/workflows/native-environment-adapter.yml
deleted file mode 100644
index 2f5bc87f..00000000
--- a/.github/workflows/native-environment-adapter.yml
+++ /dev/null
@@ -1,83 +0,0 @@
-name: Native environment adapter
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install package, toolchain, and asmpython
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build native library
-        run: |
-          python tools/build_native_typed.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-linux
-      - name: Run Python facade against native library
-        run: |
-          set +e
-          python tests/native_environment_adapter_probe.py dist/libportapy.so \
-            2>&1 | tee dist/environment-adapter-output.txt
-          status=${PIPESTATUS[0]}
-          set -e
-          test "$status" -eq 0
-          grep -qx 'native-environment-adapter: ok' dist/environment-adapter-output.txt
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: linux-native-environment-adapter
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install package, toolchain, and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build native library
-        shell: powershell
-        run: |
-          python tools/build_native_typed.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Run Python facade against native library
-        shell: powershell
-        run: |
-          $output = & python tests/native_environment_adapter_probe.py dist/portapy.dll 2>&1
-          $status = $LASTEXITCODE
-          $output | Tee-Object -FilePath dist/environment-adapter-output.txt
-          if ($status -ne 0) { exit $status }
-          if (($output -join "`n") -ne 'native-environment-adapter: ok') {
-            throw "unexpected adapter output: $output"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: windows-native-environment-adapter
-          path: dist

From b8fabcbf400e19793bdfa07bedb48ddb11280775 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:05:46 -0500
Subject: [PATCH 313/450] Remove duplicate universal environment workflow

---
 .../workflows/universal-environment-api.yml   | 95 -------------------
 1 file changed, 95 deletions(-)
 delete mode 100644 .github/workflows/universal-environment-api.yml

diff --git a/.github/workflows/universal-environment-api.yml b/.github/workflows/universal-environment-api.yml
deleted file mode 100644
index 9f2dbded..00000000
--- a/.github/workflows/universal-environment-api.yml
+++ /dev/null
@@ -1,95 +0,0 @@
-name: Universal environment API
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install toolchain and package
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes nasm gcc binutils
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          python -m pip install -e . pytest
-      - name: Test hosted helper API
-        run: python -m pytest tests/test_environment_api.py
-      - name: Build shared library
-        run: |
-          python tools/build_native_typed.py \
-            --target linux \
-            --output dist/libportapy.so \
-            --work-dir dist/build-universal-linux
-      - name: Test universal and low-level ABI together
-        run: |
-          cc -std=c11 -Wall -Wextra -Werror -Iinclude \
-            tests/native_environment_api_host.c -ldl \
-            -o dist/native_environment_api_host
-          ./dist/native_environment_api_host ./dist/libportapy.so \
-            | tee dist/universal-environment-output.txt
-          grep -qx 'Hello, world!' dist/universal-environment-output.txt
-          tail -n 1 dist/universal-environment-output.txt \
-            | grep -qx 'universal-environment-api: ok'
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: universal-environment-linux
-          path: dist
-
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install toolchain and package
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-          python -m pip install -e . pytest
-      - name: Test hosted helper API
-        shell: powershell
-        run: python -m pytest tests/test_environment_api.py
-      - name: Build shared library
-        shell: powershell
-        run: |
-          python tools/build_native_typed.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-universal-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Test universal and low-level ABI together
-        shell: powershell
-        run: |
-          gcc -std=c11 -Wall -Wextra -Werror -Iinclude `
-            tests/native_environment_api_host.c `
-            -o dist/native_environment_api_host.exe
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output = @(& dist/native_environment_api_host.exe dist/portapy.dll)
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          $output | Out-File -Encoding utf8 dist/universal-environment-output.txt
-          if ($output[0] -ne 'Hello, world!') {
-            throw "unexpected callback output: $($output -join [Environment]::NewLine)"
-          }
-          if ($output[-1] -ne 'universal-environment-api: ok') {
-            throw "unexpected final output: $($output -join [Environment]::NewLine)"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: universal-environment-windows
-          path: dist

From 938311f05102314718e25d62e6f18ace3e10c704 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:08:35 -0500
Subject: [PATCH 314/450] Store native defaults as dict-backed AST nodes

---
 ...lize_full_core_native_argument_defaults.py | 115 +++++++++++++++---
 1 file changed, 100 insertions(+), 15 deletions(-)

diff --git a/tools/normalize_full_core_native_argument_defaults.py b/tools/normalize_full_core_native_argument_defaults.py
index 033f520a..61359ddb 100644
--- a/tools/normalize_full_core_native_argument_defaults.py
+++ b/tools/normalize_full_core_native_argument_defaults.py
@@ -1,13 +1,13 @@
 """Preserve default-argument AST nodes through the standalone native bridge.
 
-``A.FuncDef.defaults`` is an opaque external list to the pinned compiler. A bare
-``node.defaults[index]`` receives the compiler's scalar fallback type, so a real
-literal AST can collapse to a null pointer. The frontend then lowers
-``_Lowerer.expr(None)`` while defining a function with defaults.
-
-This pass runs after parser vendoring, so names and formatting may already have
-changed. Rewrite ``_convert_arguments`` structurally and retain its vendored AST
-argument constructor rather than relying on exact source text.
+``A.FuncDef.defaults`` and the compatibility ``arguments.defaults`` field are
+opaque to the pinned compiler when typed as the abstract ``expr`` base. Real
+literal nodes can therefore collapse into a type token or null pointer before
+``_Lowerer.expr`` receives them.
+
+Run after parser vendoring, rewrite ``_convert_arguments`` structurally, box each
+converted default as a dict-backed AST value, and change the compatibility
+``arguments`` storage contract to ``list[dict]``.
 """
 from __future__ import annotations
 
@@ -34,12 +34,77 @@ def _constructor_name(function: ast.FunctionDef) -> str:
     raise RuntimeError("native default bridge lost its AST argument constructor")
 
 
+def _arguments_initializer(module: ast.Module) -> ast.FunctionDef:
+    classes = [
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == "arguments"
+    ]
+    if len(classes) != 1:
+        raise RuntimeError(
+            "native default arguments class: expected one arguments class, "
+            f"found {len(classes)}"
+        )
+    initializers = [
+        node
+        for node in classes[0].body
+        if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+    ]
+    if len(initializers) != 1:
+        raise RuntimeError(
+            "native default arguments class: expected one initializer, "
+            f"found {len(initializers)}"
+        )
+    return initializers[0]
+
+
+def _list_annotation(item: ast.expr) -> ast.Subscript:
+    return ast.Subscript(
+        value=ast.Name(id="list", ctx=ast.Load()),
+        slice=item,
+        ctx=ast.Load(),
+    )
+
+
+def _dict_annotation() -> ast.Name:
+    return ast.Name(id="dict", ctx=ast.Load())
+
+
+def _optional_dict_annotation() -> ast.BinOp:
+    return ast.BinOp(
+        left=_dict_annotation(),
+        op=ast.BitOr(),
+        right=ast.Constant(value=None),
+    )
+
+
+def _normalize_arguments_storage(initializer: ast.FunctionDef) -> int:
+    changed = 0
+    for argument in initializer.args.args:
+        if argument.arg == "defaults":
+            expected = "list[dict]"
+            if argument.annotation is None or ast.unparse(argument.annotation) != expected:
+                argument.annotation = _list_annotation(_dict_annotation())
+                changed += 1
+        elif argument.arg == "kw_defaults":
+            expected = "list[dict | None]"
+            if argument.annotation is None or ast.unparse(argument.annotation) != expected:
+                argument.annotation = _list_annotation(_optional_dict_annotation())
+                changed += 1
+    parameter_names = {argument.arg for argument in initializer.args.args}
+    if "defaults" not in parameter_names or "kw_defaults" not in parameter_names:
+        raise RuntimeError("native arguments initializer lost default fields")
+    return changed
+
+
 def _is_normalized(function: ast.FunctionDef) -> bool:
     text = ast.unparse(function)
     return (
-        'native_defaults: list[dict] = getattr(node, \'defaults\')' in text
+        "defaults: list[dict] = []" in text
+        and "native_defaults: list[dict] = getattr(node, 'defaults')" in text
         and "default_node: dict = native_defaults[index]" in text
-        and "defaults.append(_convert_expr(default_node, lifted))" in text
+        and "converted_default: dict = _convert_expr(default_node, lifted)" in text
+        and "defaults.append(converted_default)" in text
     )
 
 
@@ -56,13 +121,16 @@ def main() -> int:
             f"found {len(matches)}"
         )
     function = matches[0]
+    initializer = _arguments_initializer(module)
+    storage_changes = _normalize_arguments_storage(initializer)
+
     if _is_normalized(function):
-        changed = 0
+        bridge_changed = 0
     else:
         constructor = _constructor_name(function)
         replacement = ast.parse(
             f'''all_args = [{constructor}(name) for name in node.params]
-defaults: list[expr] = []
+defaults: list[dict] = []
 native_defaults: list[dict] = getattr(node, "defaults")
 first_default = len(native_defaults)
 index = 0
@@ -76,13 +144,14 @@ def main() -> int:
     index = first_default
     while index < len(native_defaults):
         default_node: dict = native_defaults[index]
-        defaults.append(_convert_expr(default_node, lifted))
+        converted_default: dict = _convert_expr(default_node, lifted)
+        defaults.append(converted_default)
         index += 1
 return arguments([], all_args, None if node.vararg is None else {constructor}(node.vararg), [], [], None if node.kwarg is None else {constructor}(node.kwarg), defaults)
 '''
         ).body
         function.body = replacement
-        changed = 1
+        bridge_changed = 1
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -96,15 +165,31 @@ def main() -> int:
     ]
     if len(functions) != 1 or not _is_normalized(functions[0]):
         raise RuntimeError("native default argument structural validation failed")
+    verified_initializer = _arguments_initializer(reparsed)
+    annotations = {
+        argument.arg: ast.unparse(argument.annotation)
+        for argument in verified_initializer.args.args
+        if argument.annotation is not None
+    }
+    if annotations.get("defaults") != "list[dict]":
+        raise RuntimeError("native positional default storage is not dict-backed")
+    if annotations.get("kw_defaults") != "list[dict | None]":
+        raise RuntimeError("native keyword default storage is not dict-backed")
     text = ast.unparse(functions[0])
     forbidden = (
         "first_default = len(node.defaults)",
         "_convert_expr(node.defaults[index], lifted)",
+        "defaults: list[expr] = []",
+        "defaults.append(_convert_expr(default_node, lifted))",
     )
     remaining = [marker for marker in forbidden if marker in text]
     if remaining:
         raise RuntimeError(f"unsafe native default extraction remains: {remaining}")
-    print("NORMALIZED NATIVE DEFAULT ARGUMENT NODES", changed)
+    print(
+        "NORMALIZED NATIVE DEFAULT ARGUMENT NODES",
+        bridge_changed,
+        storage_changes,
+    )
     return 0
 
 

From 49b0447ba4a770ae9c1866dc3440421c44441200 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:09:04 -0500
Subject: [PATCH 315/450] Test dict-backed default field storage

---
 ...lize_full_core_native_argument_defaults.py | 62 +++++++++++++++++--
 1 file changed, 57 insertions(+), 5 deletions(-)

diff --git a/tests/test_normalize_full_core_native_argument_defaults.py b/tests/test_normalize_full_core_native_argument_defaults.py
index 22cfcae9..12cde805 100644
--- a/tests/test_normalize_full_core_native_argument_defaults.py
+++ b/tests/test_normalize_full_core_native_argument_defaults.py
@@ -6,7 +6,29 @@
 from tools import normalize_full_core_native_argument_defaults as normalizer
 
 
-_SOURCE = '''def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
+_SOURCE = '''class AST:
+    pass
+
+class expr(AST):
+    pass
+
+class arg(AST):
+    def __init__(self, arg: str) -> None:
+        self.arg = arg
+
+class arguments(AST):
+    def __init__(self, posonlyargs: list[arg], args: list[arg], vararg: arg | None,
+                 kwonlyargs: list[arg], kw_defaults: list[expr | None],
+                 kwarg: arg | None, defaults: list[expr]) -> None:
+        self.posonlyargs = posonlyargs
+        self.args = args
+        self.vararg = vararg
+        self.kwonlyargs = kwonlyargs
+        self.kw_defaults = kw_defaults
+        self.kwarg = kwarg
+        self.defaults = defaults
+
+def _convert_arguments(node: A.FuncDef, lifted: dict[str, A.FuncDef]) -> arguments:
     all_args = [arg(name) for name in node.params]
     defaults: list[expr] = []
     first_default = len(node.defaults)
@@ -25,18 +47,37 @@
 '''
 
 
+def _module(path: Path) -> ast.Module:
+    return ast.parse(path.read_text(encoding="utf-8"))
+
+
 def _function(path: Path) -> ast.FunctionDef:
-    module = ast.parse(path.read_text(encoding="utf-8"))
     functions = [
         node
-        for node in module.body
+        for node in _module(path).body
         if isinstance(node, ast.FunctionDef) and node.name == "_convert_arguments"
     ]
     assert len(functions) == 1
     return functions[0]
 
 
-def test_pins_default_elements_to_dict_backed_ast(
+def _arguments_initializer(path: Path) -> ast.FunctionDef:
+    classes = [
+        node
+        for node in _module(path).body
+        if isinstance(node, ast.ClassDef) and node.name == "arguments"
+    ]
+    assert len(classes) == 1
+    initializers = [
+        node
+        for node in classes[0].body
+        if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+    ]
+    assert len(initializers) == 1
+    return initializers[0]
+
+
+def test_pins_default_elements_and_storage_to_dict_backed_ast(
     tmp_path: Path, monkeypatch,
 ) -> None:
     path = tmp_path / "native_ast.py"
@@ -61,10 +102,21 @@ def test_pins_default_elements_to_dict_backed_ast(
         and node.value.args[1].value == "defaults"
     ]
     assert len(annotated_getattrs) == 1
+    assert "defaults: list[dict] = []" in source
     assert source.count("default_node: dict = native_defaults[index]") == 2
-    assert "defaults.append(_convert_expr(default_node, lifted))" in source
+    assert "converted_default: dict = _convert_expr(default_node, lifted)" in source
+    assert "defaults.append(converted_default)" in source
     assert "_convert_expr(node.defaults[index], lifted)" not in source
 
+    initializer = _arguments_initializer(path)
+    annotations = {
+        argument.arg: ast.unparse(argument.annotation)
+        for argument in initializer.args.args
+        if argument.annotation is not None
+    }
+    assert annotations["defaults"] == "list[dict]"
+    assert annotations["kw_defaults"] == "list[dict | None]"
+
 
 def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"

From f9988744490a8bc2f5049e45c8c7957b514675fb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:09:17 -0500
Subject: [PATCH 316/450] Preserve lexical super across keyword transport

---
 ...lize_full_core_native_keyword_transport.py | 25 ++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_native_keyword_transport.py b/tools/normalize_full_core_native_keyword_transport.py
index 80c9b5d5..e054f7eb 100644
--- a/tools/normalize_full_core_native_keyword_transport.py
+++ b/tools/normalize_full_core_native_keyword_transport.py
@@ -2,7 +2,7 @@
 
 The pinned native compiler can materialize dictionaries locally, but a keyword
 mapping created in the CALL_KW opcode path may arrive at ``VirtualMachine._call``
-as a null raw dictionary pointer.  Positional calls are unaffected.  Transport
+as a null raw dictionary pointer. Positional calls are unaffected. Transport
 keyword names and values as lists instead, then build the mapping inside
 ``_call`` where it is consumed.
 """
@@ -70,9 +70,25 @@ def main() -> int:
                         frame.stack.append(self._call(target, positional, kwargs))
 ''',
         '''                    keyword_names: list[object] = []
-                    for name in names:
+                    has_effective_keywords = False
+                    keyword_index = 0
+                    while keyword_index < len(names):
+                        name = names[keyword_index]
+                        value = values[keyword_index]
                         keyword_names.append(name)
-                    if getattr(target, "__pyinbin_super__", False) and not positional and not keyword_names:
+                        if name is None:
+                            if not isinstance(value, dict):
+                                _raise_typed("TypeError: ** argument must be a mapping")
+                            if len(value) > 0:
+                                has_effective_keywords = True
+                        else:
+                            has_effective_keywords = True
+                        keyword_index += 1
+                    if (
+                        getattr(target, "__pyinbin_super__", False)
+                        and not positional
+                        and not has_effective_keywords
+                    ):
                         instance = frame.locals.get("self")
                         cls = self._lexical_super_class(frame, instance)
                         frame.stack.append(SuperProxy(self, cls, instance))
@@ -88,6 +104,9 @@ def main() -> int:
     required = (
         "keyword_names: list[object] | None = None",
         "keyword_values: list[object] | None = None",
+        "has_effective_keywords = False",
+        "if len(value) > 0:",
+        "and not has_effective_keywords",
         "self._call(target, positional, None, keyword_names, values)",
     )
     missing = [marker for marker in required if marker not in verified]

From 39eacbebce0396fb02941d71b7ed481d99d64b95 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:09:45 -0500
Subject: [PATCH 317/450] Test lexical super through keyword transport

---
 ...malize_full_core_native_keyword_transport.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
index ccf24bc3..4718bca9 100644
--- a/tests/test_normalize_full_core_native_keyword_transport.py
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -51,6 +51,23 @@ def test_transports_keyword_names_and_values_as_lists(
     assert "for name, value in zip(names, values):" not in source
 
 
+def test_empty_keyword_unpack_preserves_lexical_super(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "VM_PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "has_effective_keywords = False" in source
+    assert "if len(value) > 0:" in source
+    assert "and not has_effective_keywords" in source
+    assert "and not keyword_names" not in source
+
+
 def test_fails_closed_when_call_shape_changes(
     tmp_path: Path,
     monkeypatch,

From d1dcfea8bbb791f792a7ad7d48cc134c7384ada9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:10:49 -0500
Subject: [PATCH 318/450] Require keyword transport output to parse

---
 ...lize_full_core_native_keyword_transport.py | 26 ++++++++++---------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
index 4718bca9..dd697d20 100644
--- a/tests/test_normalize_full_core_native_keyword_transport.py
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -17,6 +17,8 @@ def _run_frame(self, frame: object) -> object:
         positional: list[object] = []
         names: list[object] = []
         values: list[object] = []
+        if True:
+            if True:
                     kwargs: dict[str, object] = {}
                     for name, value in zip(names, values):
                         if name is None:
@@ -33,17 +35,22 @@ def _run_frame(self, frame: object) -> object:
 '''
 
 
-def test_transports_keyword_names_and_values_as_lists(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
+def _normalize(tmp_path: Path, monkeypatch) -> str:
     path = tmp_path / "vm.py"
     path.write_text(_SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "VM_PATH", path)
-
     assert normalizer.main() == 0
-
     source = path.read_text(encoding="utf-8")
+    ast.parse(source)
+    return source
+
+
+def test_transports_keyword_names_and_values_as_lists(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    source = _normalize(tmp_path, monkeypatch)
+
     assert "keyword_names: list[object] | None = None" in source
     assert "keyword_values: list[object] | None = None" in source
     assert "self._call(target, positional, None, keyword_names, values)" in source
@@ -55,13 +62,8 @@ def test_empty_keyword_unpack_preserves_lexical_super(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
-    path = tmp_path / "vm.py"
-    path.write_text(_SOURCE, encoding="utf-8")
-    monkeypatch.setattr(normalizer, "VM_PATH", path)
-
-    assert normalizer.main() == 0
+    source = _normalize(tmp_path, monkeypatch)
 
-    source = path.read_text(encoding="utf-8")
     assert "has_effective_keywords = False" in source
     assert "if len(value) > 0:" in source
     assert "and not has_effective_keywords" in source

From 7e5ad28db3f8da8bb7c8951ca7fea638b3b83b16 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:12:01 -0500
Subject: [PATCH 319/450] Run release builds only for explicit publication

---
 .github/workflows/release-3.14.0.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/release-3.14.0.yml b/.github/workflows/release-3.14.0.yml
index f3675282..1ee21318 100644
--- a/.github/workflows/release-3.14.0.yml
+++ b/.github/workflows/release-3.14.0.yml
@@ -1,8 +1,6 @@
 name: Build and release PortaPy 3.14.0
 
 on:
-  pull_request:
-    branches: [main]
   workflow_dispatch:
     inputs:
       publish:
@@ -15,7 +13,7 @@ on:
       - release/3.14.0
 
 concurrency:
-  group: portapy-3.14.0-${{ github.event.pull_request.number || github.ref }}
+  group: portapy-3.14.0-${{ github.ref }}
   cancel-in-progress: true
 
 permissions:

From 539cbac561473591f80809cb30aa181c1315981e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:12:51 -0500
Subject: [PATCH 320/450] Capture native build diagnostics in canonical CI

---
 .github/workflows/ci.yml | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a8113873..31961031 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -74,20 +74,25 @@ jobs:
         shell: bash
         run: |
           mkdir -p dist
+          set -o pipefail
           python tools/build_native_typed.py \
             --target linux \
             --output dist/libportapy.so \
-            --work-dir dist/build-verify-linux
+            --work-dir dist/build-verify-linux \
+            2>&1 | tee dist/build-linux.log
       - name: Build Windows standalone library
         if: matrix.target == 'windows'
         shell: powershell
         run: |
           New-Item -ItemType Directory -Force dist | Out-Null
-          python tools/build_native_typed.py `
+          $output = & python tools/build_native_typed.py `
             --target windows `
             --output dist/portapy.dll `
-            --work-dir dist/build-verify-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+            --work-dir dist/build-verify-windows `
+            2>&1
+          $buildStatus = $LASTEXITCODE
+          $output | Tee-Object -FilePath dist/build-windows.log
+          if ($buildStatus -ne 0) { exit $buildStatus }
       - name: Verify Linux standalone library
         if: matrix.target == 'linux'
         shell: bash

From 64f56f978e23e45025db9983bacd43a5936d39d0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:13:09 -0500
Subject: [PATCH 321/450] Remove duplicate native build diagnostic workflow

---
 .github/workflows/native-build-diagnostic.yml | 163 ------------------
 1 file changed, 163 deletions(-)
 delete mode 100644 .github/workflows/native-build-diagnostic.yml

diff --git a/.github/workflows/native-build-diagnostic.yml b/.github/workflows/native-build-diagnostic.yml
deleted file mode 100644
index 8a203d29..00000000
--- a/.github/workflows/native-build-diagnostic.yml
+++ /dev/null
@@ -1,163 +0,0 @@
-name: Native build diagnostic
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-concurrency:
-  group: native-build-diagnostic-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  build-linux:
-    runs-on: ubuntu-22.04
-    outputs:
-      status: ${{ steps.build.outputs.status }}
-      report: ${{ steps.build.outputs.report }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install quietly
-        shell: bash
-        run: |
-          sudo apt-get update > /tmp/install.log 2>&1
-          sudo apt-get install --yes nasm gcc binutils >> /tmp/install.log 2>&1
-          python -m pip install -e '.[test]' >> /tmp/install.log 2>&1
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1' \
-            >> /tmp/install.log 2>&1
-      - name: Capture compiler diagnostic
-        id: build
-        shell: bash
-        run: |
-          set +e
-          python tools/build_native_typed.py \
-            --target linux \
-            --output /tmp/libportapy.so \
-            --work-dir /tmp/build-linux \
-            > /tmp/build.log 2>&1
-          status=$?
-          {
-            echo '=== FIRST 35 LINES ==='
-            head -n 35 /tmp/build.log
-            echo
-            echo '=== ERROR-LIKE LINES ==='
-            grep -Ein 'error|failed|failure|unsupported|traceback|exception|undefined|invalid' \
-              /tmp/build.log | tail -n 120 || true
-            echo
-            echo '=== FINAL 120 LINES ==='
-            tail -n 120 /tmp/build.log
-          } > /tmp/report.log
-          echo "status=$status" >> "$GITHUB_OUTPUT"
-          echo 'report<<PORTAPY_BUILD_REPORT' >> "$GITHUB_OUTPUT"
-          cat /tmp/report.log >> "$GITHUB_OUTPUT"
-          echo 'PORTAPY_BUILD_REPORT' >> "$GITHUB_OUTPUT"
-          exit 0
-      - name: Upload normalized compiler input
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: native-build-diagnostic-source
-          path: |
-            /tmp/build.log
-            /tmp/report.log
-            src/portapy/native_full_reference_entry.py
-            src/portapy/core/frontend.py
-            src/portapy/core/vm.py
-            src/portapy/core/loader.py
-            src/portapy/core/bytecode.py
-
-  report-linux:
-    needs: build-linux
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Report compiler diagnostic
-        env:
-          BUILD_REPORT: ${{ needs.build-linux.outputs.report }}
-          BUILD_STATUS: ${{ needs.build-linux.outputs.status }}
-        shell: bash
-        run: |
-          printf '%s\n' "$BUILD_REPORT"
-          exit "$BUILD_STATUS"
-
-  build-windows:
-    runs-on: windows-2022
-    outputs:
-      status: ${{ steps.build.outputs.status }}
-      report: ${{ steps.build.outputs.report }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install quietly
-        shell: powershell
-        run: |
-          $installLog = Join-Path $env:RUNNER_TEMP 'portapy-install-windows.log'
-          & .\tools\install_windows_toolchain.ps1 *>> $installLog
-          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
-          python -m pip install -e '.[test]' *>> $installLog
-          if ($LASTEXITCODE -ne 0) { Get-Content $installLog; exit $LASTEXITCODE }
-          & .\tools\install_pinned_asmpython.ps1 -LogPath $installLog
-      - name: Capture compiler diagnostic
-        id: build
-        shell: powershell
-        run: |
-          $buildLog = Join-Path $env:RUNNER_TEMP 'portapy-build-windows.log'
-          $reportLog = Join-Path $env:RUNNER_TEMP 'portapy-report-windows.log'
-          $output = Join-Path $env:RUNNER_TEMP 'portapy.dll'
-          $workDir = Join-Path $env:RUNNER_TEMP 'portapy-build-windows'
-          python tools/build_native_typed.py `
-            --target windows `
-            --output $output `
-            --work-dir $workDir `
-            *> $buildLog
-          $status = $LASTEXITCODE
-          $lines = Get-Content $buildLog
-          $errorLines = $lines | Select-String -Pattern 'error|failed|failure|unsupported|traceback|exception|undefined|invalid'
-          @(
-            '=== FIRST 35 LINES ==='
-            $lines | Select-Object -First 35
-            ''
-            '=== ERROR-LIKE LINES ==='
-            $errorLines | Select-Object -Last 120
-            ''
-            '=== FINAL 120 LINES ==='
-            $lines | Select-Object -Last 120
-          ) | Set-Content -Encoding utf8 $reportLog
-          "status=$status" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          'report<<PORTAPY_BUILD_REPORT' | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          Get-Content $reportLog | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          'PORTAPY_BUILD_REPORT' | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          exit 0
-      - name: Upload Windows compiler diagnostic
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: native-build-diagnostic-windows
-          path: |
-            ${{ runner.temp }}/portapy-install-windows.log
-            ${{ runner.temp }}/portapy-build-windows.log
-            ${{ runner.temp }}/portapy-report-windows.log
-            ${{ runner.temp }}/portapy-build-windows
-            ${{ runner.temp }}/portapy.dll
-            ${{ runner.temp }}/portapy.dll.json
-
-  report-windows:
-    needs: build-windows
-    runs-on: windows-2022
-    steps:
-      - name: Report compiler diagnostic
-        env:
-          BUILD_REPORT: ${{ needs.build-windows.outputs.report }}
-          BUILD_STATUS: ${{ needs.build-windows.outputs.status }}
-        shell: powershell
-        run: |
-          Write-Host $env:BUILD_REPORT
-          exit [int]$env:BUILD_STATUS

From f77c61c27b58260c39c356ed24cc89646616c01c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:14:01 -0500
Subject: [PATCH 322/450] Consolidate release checks into canonical CI

---
 .github/workflows/ci.yml | 52 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 31961031..10b520f3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,6 +36,38 @@ jobs:
           name: portapy-hosted-pytest
           path: hosted-pytest.log
 
+  audit:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install verified asmpython
+        run: |
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - name: Audit full-core imports and source positions
+        shell: bash
+        run: |
+          mkdir -p dist
+          python tools/normalize_full_core_probe.py
+          python tools/normalize_full_core_lambdas.py
+          python -m asmpython._compiler.import_audit \
+            src/portapy/native_full_core_probe.py \
+            > dist/full-core-import-audit.txt 2>&1
+          python tools/asmpython_parse_audit.py \
+            src/portapy/core/frontend.py \
+            src/portapy/core/vm.py \
+            > dist/full-core-parse-audit.txt 2>&1
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: full-core-import-audit
+          path: |
+            dist/full-core-import-audit.txt
+            dist/full-core-parse-audit.txt
+
   native:
     strategy:
       fail-fast: false
@@ -122,6 +154,26 @@ jobs:
             --compiler gcc `
             --output-dir dist/conformance-windows
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - name: Verify direct CSharp PInvoke
+        if: matrix.target == 'windows'
+        shell: powershell
+        run: |
+          dotnet build examples/csharp/PortaPyExample.csproj `
+            --configuration Release `
+            --output dist/csharp
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          Copy-Item dist/portapy.dll dist/csharp/portapy.dll
+          Push-Location dist/csharp
+          try {
+            $output = @(dotnet PortaPyExample.dll)
+            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          } finally {
+            Pop-Location
+          }
+          $output | Out-File -Encoding utf8 dist/csharp-output.txt
+          if ($output[-1] -ne 'Hello, world!') {
+            throw "unexpected C# output: $($output -join [Environment]::NewLine)"
+          }
       - uses: actions/upload-artifact@v4
         if: always()
         with:

From 963a4b9c9f6eaba0148513a24dd63ea7a31aebea Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:14:12 -0500
Subject: [PATCH 323/450] Type native keyword keys before binding

---
 ...lize_full_core_native_keyword_transport.py | 55 ++++++++++++-------
 1 file changed, 36 insertions(+), 19 deletions(-)

diff --git a/tools/normalize_full_core_native_keyword_transport.py b/tools/normalize_full_core_native_keyword_transport.py
index e054f7eb..2b34cf16 100644
--- a/tools/normalize_full_core_native_keyword_transport.py
+++ b/tools/normalize_full_core_native_keyword_transport.py
@@ -1,10 +1,10 @@
-"""Avoid passing freshly-built keyword dictionaries across the native call ABI.
+"""Transport keyword arguments through compiler-safe native values.
 
-The pinned native compiler can materialize dictionaries locally, but a keyword
-mapping created in the CALL_KW opcode path may arrive at ``VirtualMachine._call``
-as a null raw dictionary pointer. Positional calls are unaffected. Transport
-keyword names and values as lists instead, then build the mapping inside
-``_call`` where it is consumed.
+The pinned native compiler cannot safely pass a freshly built dictionary from
+``CALL_KW`` into ``VirtualMachine._call``. It also needs keyword keys to be
+statically typed as strings before dictionary mutation. Transport names and
+values as lists, encode ``**mapping`` with an impossible empty direct-keyword
+sentinel, and construct a typed mapping inside ``_call`` where it is consumed.
 """
 from __future__ import annotations
 
@@ -33,23 +33,27 @@ def main() -> int:
         target: object,
         args: list[object],
         kwargs: dict[str, object] | None = None,
-        keyword_names: list[object] | None = None,
+        keyword_names: list[str] | None = None,
         keyword_values: list[object] | None = None,
     ) -> object:
-        kwargs = kwargs or {}
         if keyword_names is not None and keyword_values is not None:
+            transported_kwargs: dict[str, object] = {}
             keyword_index = 0
             while keyword_index < len(keyword_names):
-                keyword_name = keyword_names[keyword_index]
+                keyword_name: str = keyword_names[keyword_index]
                 keyword_value = keyword_values[keyword_index]
-                if keyword_name is None:
+                if keyword_name == "":
                     if not isinstance(keyword_value, dict):
                         _raise_typed("TypeError: ** argument must be a mapping")
-                    for mapping_name, mapping_value in keyword_value.items():
-                        kwargs[mapping_name] = mapping_value
+                    for raw_mapping_name, mapping_value in keyword_value.items():
+                        mapping_name: str = raw_mapping_name
+                        transported_kwargs[mapping_name] = mapping_value
                 else:
-                    kwargs[keyword_name] = keyword_value
+                    transported_kwargs[keyword_name] = keyword_value
                 keyword_index += 1
+            kwargs = transported_kwargs
+        else:
+            kwargs = kwargs or {}
 ''',
         label="native keyword receiver",
     )
@@ -69,19 +73,21 @@ def main() -> int:
                     else:
                         frame.stack.append(self._call(target, positional, kwargs))
 ''',
-        '''                    keyword_names: list[object] = []
+        '''                    keyword_names: list[str] = []
                     has_effective_keywords = False
                     keyword_index = 0
                     while keyword_index < len(names):
                         name = names[keyword_index]
                         value = values[keyword_index]
-                        keyword_names.append(name)
                         if name is None:
                             if not isinstance(value, dict):
                                 _raise_typed("TypeError: ** argument must be a mapping")
+                            keyword_names.append("")
                             if len(value) > 0:
                                 has_effective_keywords = True
                         else:
+                            keyword_name: str = name
+                            keyword_names.append(keyword_name)
                             has_effective_keywords = True
                         keyword_index += 1
                     if (
@@ -102,17 +108,28 @@ def main() -> int:
     VM_PATH.write_text(source, encoding="utf-8")
     verified = VM_PATH.read_text(encoding="utf-8")
     required = (
-        "keyword_names: list[object] | None = None",
-        "keyword_values: list[object] | None = None",
+        "keyword_names: list[str] | None = None",
+        "transported_kwargs: dict[str, object] = {}",
+        "keyword_name: str = keyword_names[keyword_index]",
+        "mapping_name: str = raw_mapping_name",
+        "kwargs = transported_kwargs",
+        "keyword_names: list[str] = []",
         "has_effective_keywords = False",
-        "if len(value) > 0:",
+        'keyword_names.append("")',
         "and not has_effective_keywords",
+        "keyword_name: str = name",
         "self._call(target, positional, None, keyword_names, values)",
     )
     missing = [marker for marker in required if marker not in verified]
     if missing:
         raise RuntimeError(f"native keyword transport validation failed: {missing}")
-    print("NORMALIZED NATIVE KEYWORD TRANSPORT")
+    forbidden = (
+        "keyword_names: list[object]",
+    )
+    remaining = [marker for marker in forbidden if marker in verified]
+    if remaining:
+        raise RuntimeError(f"unsafe native keyword transport remains: {remaining}")
+    print("NORMALIZED TYPED NATIVE KEYWORD TRANSPORT")
     return 0
 
 

From fcc06e32ffbc3dd4991398c7d6277c6c37a5b557 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:14:15 -0500
Subject: [PATCH 324/450] Remove duplicate CSharp FFI workflow

---
 .github/workflows/csharp-ffi.yml | 56 --------------------------------
 1 file changed, 56 deletions(-)
 delete mode 100644 .github/workflows/csharp-ffi.yml

diff --git a/.github/workflows/csharp-ffi.yml b/.github/workflows/csharp-ffi.yml
deleted file mode 100644
index fe83fecb..00000000
--- a/.github/workflows/csharp-ffi.yml
+++ /dev/null
@@ -1,56 +0,0 @@
-name: CSharp direct FFI
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  windows:
-    runs-on: windows-2025
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install native toolchain and asmpython
-        shell: powershell
-        run: |
-          choco install nasm mingw -y --no-progress
-          python -m pip install --no-cache-dir --force-reinstall `
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Build portapy.dll
-        shell: powershell
-        run: |
-          python tools/build_native_typed.py `
-            --target windows `
-            --output dist/portapy.dll `
-            --work-dir dist/build-csharp-windows
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-      - name: Build and run direct PInvoke example
-        shell: powershell
-        run: |
-          dotnet build examples/csharp/PortaPyExample.csproj `
-            --configuration Release `
-            --output dist/csharp
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          Copy-Item dist/portapy.dll dist/csharp/portapy.dll
-          Push-Location dist/csharp
-          try {
-            $output = @(dotnet PortaPyExample.dll)
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          } finally {
-            Pop-Location
-          }
-          $output | Out-File -Encoding utf8 dist/csharp-output.txt
-          if ($output[-1] -ne 'Hello, world!') {
-            throw "unexpected C# output: $($output -join [Environment]::NewLine)"
-          }
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: csharp-direct-ffi
-          path: dist

From c989c870a81e9f9f6318b118d8d7e1569645e2d9 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:14:28 -0500
Subject: [PATCH 325/450] Remove duplicate full-core audit workflow

---
 .github/workflows/full-core-import-audit.yml | 75 --------------------
 1 file changed, 75 deletions(-)
 delete mode 100644 .github/workflows/full-core-import-audit.yml

diff --git a/.github/workflows/full-core-import-audit.yml b/.github/workflows/full-core-import-audit.yml
deleted file mode 100644
index d62bce62..00000000
--- a/.github/workflows/full-core-import-audit.yml
+++ /dev/null
@@ -1,75 +0,0 @@
-name: Full-core import audit
-
-on:
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  audit:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Install verified asmpython
-        run: |
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
-      - name: Normalize probe source
-        run: |
-          python tools/normalize_full_core_probe.py
-          python tools/normalize_full_core_lambdas.py
-      - name: Audit full-core project import graph
-        id: import_audit
-        continue-on-error: true
-        run: |
-          mkdir -p dist
-          python -m asmpython._compiler.import_audit \
-            src/portapy/native_full_core_probe.py \
-            > dist/full-core-import-audit.txt 2>&1
-      - name: Audit source positions
-        id: parse_audit
-        continue-on-error: true
-        run: |
-          python tools/asmpython_parse_audit.py \
-            src/portapy/core/frontend.py \
-            src/portapy/core/vm.py \
-            > dist/full-core-parse-audit.txt 2>&1
-      - name: Show audits
-        if: always()
-        run: |
-          cat dist/full-core-import-audit.txt
-          cat dist/full-core-parse-audit.txt
-      - name: Report failed audits
-        if: (steps.import_audit.outcome != 'success' || steps.parse_audit.outcome != 'success') && github.event_name == 'pull_request'
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          {
-            echo '<!-- portapy-full-core-import-audit -->'
-            echo '### Full-core import and parser audit'
-            echo
-            echo '```text'
-            cat dist/full-core-import-audit.txt
-            echo
-            cat dist/full-core-parse-audit.txt
-            echo '```'
-          } > /tmp/portapy-full-core-import-audit.md
-          gh pr comment "${{ github.event.pull_request.number }}" \
-            --body-file /tmp/portapy-full-core-import-audit.md
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: full-core-import-audit
-          path: |
-            dist/full-core-import-audit.txt
-            dist/full-core-parse-audit.txt
-      - name: Require clean audits
-        if: steps.import_audit.outcome != 'success' || steps.parse_audit.outcome != 'success'
-        run: exit 1

From 31b7dfae41a75003511b4ee3b75c864334099793 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:14:51 -0500
Subject: [PATCH 326/450] Test typed native keyword transport

---
 ..._normalize_full_core_native_keyword_transport.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
index dd697d20..0c3c87b6 100644
--- a/tests/test_normalize_full_core_native_keyword_transport.py
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -45,16 +45,23 @@ def _normalize(tmp_path: Path, monkeypatch) -> str:
     return source
 
 
-def test_transports_keyword_names_and_values_as_lists(
+def test_transports_typed_keyword_names_and_values(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
     source = _normalize(tmp_path, monkeypatch)
 
-    assert "keyword_names: list[object] | None = None" in source
+    assert "keyword_names: list[str] | None = None" in source
     assert "keyword_values: list[object] | None = None" in source
+    assert "transported_kwargs: dict[str, object] = {}" in source
+    assert "keyword_name: str = keyword_names[keyword_index]" in source
+    assert "mapping_name: str = raw_mapping_name" in source
+    assert "kwargs = transported_kwargs" in source
+    assert "keyword_names: list[str] = []" in source
+    assert 'keyword_names.append("")' in source
+    assert "keyword_name: str = name" in source
     assert "self._call(target, positional, None, keyword_names, values)" in source
-    assert "kwargs: dict[str, object] = {}" not in source
+    assert "keyword_names: list[object]" not in source
     assert "for name, value in zip(names, values):" not in source
 
 

From 23ad73744c8c8984fdc55e1ff1d5e564079296f8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:17:03 -0500
Subject: [PATCH 327/450] Enforce Python keyword mapping semantics natively

---
 ...normalize_full_core_native_keyword_transport.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tools/normalize_full_core_native_keyword_transport.py b/tools/normalize_full_core_native_keyword_transport.py
index 2b34cf16..c88053af 100644
--- a/tools/normalize_full_core_native_keyword_transport.py
+++ b/tools/normalize_full_core_native_keyword_transport.py
@@ -46,9 +46,19 @@ def main() -> int:
                     if not isinstance(keyword_value, dict):
                         _raise_typed("TypeError: ** argument must be a mapping")
                     for raw_mapping_name, mapping_value in keyword_value.items():
+                        if not isinstance(raw_mapping_name, str):
+                            _raise_typed("TypeError: keywords must be strings")
                         mapping_name: str = raw_mapping_name
+                        if mapping_name in transported_kwargs:
+                            _raise_typed(
+                                f"TypeError: got multiple values for keyword argument {mapping_name!r}"
+                            )
                         transported_kwargs[mapping_name] = mapping_value
                 else:
+                    if keyword_name in transported_kwargs:
+                        _raise_typed(
+                            f"TypeError: got multiple values for keyword argument {keyword_name!r}"
+                        )
                     transported_kwargs[keyword_name] = keyword_value
                 keyword_index += 1
             kwargs = transported_kwargs
@@ -111,7 +121,11 @@ def main() -> int:
         "keyword_names: list[str] | None = None",
         "transported_kwargs: dict[str, object] = {}",
         "keyword_name: str = keyword_names[keyword_index]",
+        "if not isinstance(raw_mapping_name, str):",
+        'TypeError: keywords must be strings',
         "mapping_name: str = raw_mapping_name",
+        "if mapping_name in transported_kwargs:",
+        "if keyword_name in transported_kwargs:",
         "kwargs = transported_kwargs",
         "keyword_names: list[str] = []",
         "has_effective_keywords = False",

From 9e1d4075f93a64b170fb774aeb1d7670894bb092 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:17:37 -0500
Subject: [PATCH 328/450] Execute native keyword transport semantics in tests

---
 ...lize_full_core_native_keyword_transport.py | 59 ++++++++++++++++++-
 1 file changed, 57 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
index 0c3c87b6..e9c2cac8 100644
--- a/tests/test_normalize_full_core_native_keyword_transport.py
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -7,10 +7,18 @@
 from tools import normalize_full_core_validation as validation
 
 
-_SOURCE = '''class VirtualMachine:
+_SOURCE = '''def _raise_typed(message: str) -> None:
+    raise TypeError(message)
+
+
+class SuperProxy:
+    pass
+
+
+class VirtualMachine:
     def _call(self, target: object, args: list[object], kwargs: dict[str, object] | None = None) -> object:
         kwargs = kwargs or {}
-        return target
+        return kwargs
 
     def _run_frame(self, frame: object) -> object:
         target = object()
@@ -45,6 +53,21 @@ def _normalize(tmp_path: Path, monkeypatch) -> str:
     return source
 
 
+def _vm(source: str) -> object:
+    namespace: dict[str, object] = {}
+    exec(source, namespace)
+    return namespace["VirtualMachine"]()
+
+
+def _expect_type_error(callback, message: str) -> None:
+    try:
+        callback()
+    except TypeError as error:
+        assert message in str(error)
+    else:
+        raise AssertionError("expected TypeError")
+
+
 def test_transports_typed_keyword_names_and_values(
     tmp_path: Path,
     monkeypatch,
@@ -64,6 +87,38 @@ def test_transports_typed_keyword_names_and_values(
     assert "keyword_names: list[object]" not in source
     assert "for name, value in zip(names, values):" not in source
 
+    vm = _vm(source)
+    result = vm._call(
+        object(),
+        [],
+        None,
+        ["direct", ""],
+        [1, {"mapped": 2, "": 3}],
+    )
+    assert result == {"direct": 1, "mapped": 2, "": 3}
+
+
+def test_rejects_invalid_or_duplicate_mapping_keywords(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    vm = _vm(_normalize(tmp_path, monkeypatch))
+
+    _expect_type_error(
+        lambda: vm._call(object(), [], None, [""], [{1: "bad"}]),
+        "keywords must be strings",
+    )
+    _expect_type_error(
+        lambda: vm._call(
+            object(),
+            [],
+            None,
+            ["direct", ""],
+            [1, {"direct": 2}],
+        ),
+        "multiple values for keyword argument",
+    )
+
 
 def test_empty_keyword_unpack_preserves_lexical_super(
     tmp_path: Path,

From cf440982d50eaef9956cd7afd95156577ad4805b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:20:00 -0500
Subject: [PATCH 329/450] Gate final native semantic regressions

---
 tests/native_environment_adapter_probe.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/native_environment_adapter_probe.py b/tests/native_environment_adapter_probe.py
index 3cc7c7b6..4e84e86a 100644
--- a/tests/native_environment_adapter_probe.py
+++ b/tests/native_environment_adapter_probe.py
@@ -92,6 +92,19 @@ def main() -> int:
             "full_runtime_answer = box.get() if traced else -1\n"
         )
 
+        assert environment.evaluate("not ''") is True
+        assert environment.evaluate("'alpha' == 'alpha'") is True
+        assert environment.evaluate("'alpha' != 'beta'") is True
+        assert environment.evaluate("'alpha' < 'beta'") is True
+        try:
+            environment.evaluate("'alpha' < 1")
+        except ExecutionError as error:
+            assert error.error is not None
+            assert int(error.error.status) == 4
+            assert error.error.type_name == "TypeError"
+        else:
+            raise AssertionError("mixed string/number ordering did not raise TypeError")
+
         snapshot = environment.snapshot()
         assert "__pyinbin_import__" not in snapshot.var
         assert snapshot.var["http_provider"] is game.provider.HttpProvider

From 32c033be63f7ecc64d13eaf525253790e2a80c5e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:26:38 -0500
Subject: [PATCH 330/450] Install pinned asmpython in hosted CI

---
 .github/workflows/ci.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 10b520f3..5861c7b0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,7 +22,11 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
-      - run: python -m pip install -e '.[test]'
+      - name: Install package and verified compiler
+        run: |
+          python -m pip install -e '.[test]'
+          python -m pip install --no-cache-dir --force-reinstall \
+            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
       - name: Run complete hosted suite
         shell: bash
         run: |

From 191f8055a78e34fff3592d883d41d8f947c7d141 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:26:45 -0500
Subject: [PATCH 331/450] Keep keyword transport test independent of build-only
 asmpython

---
 tests/test_normalize_full_core_native_keyword_transport.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_native_keyword_transport.py b/tests/test_normalize_full_core_native_keyword_transport.py
index e9c2cac8..b054d657 100644
--- a/tests/test_normalize_full_core_native_keyword_transport.py
+++ b/tests/test_normalize_full_core_native_keyword_transport.py
@@ -4,7 +4,6 @@
 from pathlib import Path
 
 from tools import normalize_full_core_native_keyword_transport as normalizer
-from tools import normalize_full_core_validation as validation
 
 
 _SOURCE = '''def _raise_typed(message: str) -> None:
@@ -149,7 +148,8 @@ def test_fails_closed_when_call_shape_changes(
 
 
 def test_keyword_transport_runs_before_every_other_normalizer() -> None:
-    module = ast.parse(Path(validation.__file__).read_text(encoding="utf-8"))
+    validation_path = Path(__file__).parents[1] / "tools" / "normalize_full_core_validation.py"
+    module = ast.parse(validation_path.read_text(encoding="utf-8"))
     main = next(
         node
         for node in module.body

From caf7fd4a009f63d7d35b07a0346e95229a7a9ff1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:30:04 -0500
Subject: [PATCH 332/450] Reconcile full-core workflow with main

---
 .github/workflows/native-full-core-probe.yml | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 9e9d09ff..4115e262 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -30,6 +30,10 @@ jobs:
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
       - name: Normalize probe source
         run: |
+          python tools/normalize_full_core_probe.py
+          python tools/normalize_full_core_lambdas.py
+          python tools/normalize_full_core_native_semantics.py
+          python tools/normalize_full_core_opcode_maps.py
           python tools/normalize_full_core_validation.py
           mkdir -p dist/debug-tree
           python - <<'PY'
@@ -160,6 +164,14 @@ jobs:
       - name: Normalize probe source
         shell: powershell
         run: |
+          python tools/normalize_full_core_probe.py
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          python tools/normalize_full_core_lambdas.py
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          python tools/normalize_full_core_native_semantics.py
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          python tools/normalize_full_core_opcode_maps.py
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/normalize_full_core_validation.py
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
       - name: Compile full frontend and VM probe
@@ -248,14 +260,14 @@ jobs:
             '```text'
           )
           if (Test-Path dist/windows-full-core-build.log) {
-            $lines += Get-Content dist/windows-full-core-build.log | Select-Object -Last 180
+            $lines += Get-Content dist/windows-full-core-build.log -Tail 180
           } else {
             $lines += 'No compiler log was produced.'
           }
           $lines += '```'
-          $lines | Set-Content -Encoding utf8 $env:TEMP/portapy-full-core-windows.md
-          gh pr comment "${{ github.event.pull_request.number }}" `
-            --body-file $env:TEMP/portapy-full-core-windows.md
+          $path = "$env:RUNNER_TEMP\portapy-full-core-windows.md"
+          $lines | Set-Content -Encoding utf8 $path
+          gh pr comment "${{ github.event.pull_request.number }}" --body-file $path
       - uses: actions/upload-artifact@v4
         if: always()
         with:

From 8224c8916ed0251abad6d08fe2064c41e3630983 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:30:38 -0500
Subject: [PATCH 333/450] Reconcile consolidated CI with main

---
 .github/workflows/ci.yml | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5861c7b0..10b520f3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,11 +22,7 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
-      - name: Install package and verified compiler
-        run: |
-          python -m pip install -e '.[test]'
-          python -m pip install --no-cache-dir --force-reinstall \
-            'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
+      - run: python -m pip install -e '.[test]'
       - name: Run complete hosted suite
         shell: bash
         run: |

From 40ff0e2b8d68db89a5110d7d1a1157415b2951d6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:32:55 -0500
Subject: [PATCH 334/450] Make string-addition normalization indentation-aware

---
 tools/normalize_full_core_string_addition.py | 84 +++++++++++---------
 1 file changed, 48 insertions(+), 36 deletions(-)

diff --git a/tools/normalize_full_core_string_addition.py b/tools/normalize_full_core_string_addition.py
index 80c310a2..8b9660d7 100644
--- a/tools/normalize_full_core_string_addition.py
+++ b/tools/normalize_full_core_string_addition.py
@@ -3,6 +3,7 @@
 
 import ast
 from pathlib import Path
+import re
 
 
 FRONTEND_PATH = Path("src/portapy/core/frontend.py")
@@ -28,21 +29,6 @@ def _replace(source: str, old: str, new: str, label: str) -> str:
     return source.replace(old, new, 1)
 
 
-def _replace_one_of(
-    source: str,
-    replacements: tuple[tuple[str, str], ...],
-    label: str,
-) -> str:
-    matches = [(old, new) for old, new in replacements if source.count(old) == 1]
-    if len(matches) != 1:
-        counts = [source.count(old) for old, _ in replacements]
-        raise RuntimeError(
-            f"native string addition {label}: expected one source shape, found {counts}"
-        )
-    old, new = matches[0]
-    return source.replace(old, new, 1)
-
-
 def _is_source_node_test(node: ast.If, suffix: str) -> bool:
     test = node.test
     if not (
@@ -162,6 +148,52 @@ def _normalize_frontend() -> int:
     return 1
 
 
+def _normalize_vm_dispatch(source: str) -> str:
+    inline = re.compile(
+        r"^(?P<indent>[ \t]+)if op is Op\.BINARY_ADD: "
+        r"frame\.stack\.append\(left \+ right\)\n",
+        re.MULTILINE,
+    )
+    expanded = re.compile(
+        r"^(?P<indent>[ \t]+)if op is Op\.BINARY_ADD:\n"
+        r"(?P<child>[ \t]+)frame\.stack\.append\(left \+ right\)\n",
+        re.MULTILINE,
+    )
+    inline_matches = list(inline.finditer(source))
+    expanded_matches = list(expanded.finditer(source))
+    if len(inline_matches) + len(expanded_matches) != 1:
+        raise RuntimeError(
+            "native string addition VM dispatch: expected one source shape, "
+            f"found [{len(inline_matches)}, {len(expanded_matches)}]"
+        )
+
+    if inline_matches:
+        match = inline_matches[0]
+        indent = match.group("indent")
+        child = indent + "    "
+    else:
+        match = expanded_matches[0]
+        indent = match.group("indent")
+        child = match.group("child")
+        if len(child) <= len(indent):
+            raise RuntimeError("native string addition VM dispatch has invalid indentation")
+
+    replacement = (
+        f"{indent}if op is Op.BINARY_ADD:\n"
+        f"{child}if instr.arg == {_STRING_KIND}:\n"
+        f"{child}    frame.stack.append(\n"
+        f"{child}        _full_core_probe_concat_strings(left, right)\n"
+        f"{child}    )\n"
+        f"{child}elif instr.arg == {_MIXED_STRING_KIND}:\n"
+        f"{child}    _raise_typed(\n"
+        f'{child}        "TypeError: can only concatenate string to string"\n'
+        f"{child}    )\n"
+        f"{child}else:\n"
+        f"{child}    frame.stack.append(left + right)\n"
+    )
+    return source[: match.start()] + replacement + source[match.end() :]
+
+
 def _normalize_vm() -> int:
     source = VM_PATH.read_text(encoding="utf-8")
     class_anchor = "class VirtualMachine:"
@@ -171,27 +203,7 @@ def _normalize_vm() -> int:
         _CONCAT_HELPER + class_anchor,
         "helper insertion",
     )
-    inline_old = "                    if op is Op.BINARY_ADD: frame.stack.append(left + right)\n"
-    expanded_old = '''                    if op is Op.BINARY_ADD:
-                        frame.stack.append(left + right)
-'''
-    replacement = f'''                    if op is Op.BINARY_ADD:
-                        if instr.arg == {_STRING_KIND}:
-                            frame.stack.append(
-                                _full_core_probe_concat_strings(left, right)
-                            )
-                        elif instr.arg == {_MIXED_STRING_KIND}:
-                            _raise_typed(
-                                "TypeError: can only concatenate string to string"
-                            )
-                        else:
-                            frame.stack.append(left + right)
-'''
-    source = _replace_one_of(
-        source,
-        ((inline_old, replacement), (expanded_old, replacement)),
-        "VM dispatch",
-    )
+    source = _normalize_vm_dispatch(source)
     VM_PATH.write_text(source, encoding="utf-8")
     required = (
         "def _full_core_probe_concat_strings",

From a63de407ae73efaf963f6e450293651bff309db6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:33:50 -0500
Subject: [PATCH 335/450] Run the full-core normalizer exactly once

---
 .github/workflows/native-full-core-probe.yml | 72 +++++++++++++-------
 1 file changed, 47 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 4115e262..8811b030 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -29,12 +29,23 @@ jobs:
           python -m pip install --no-cache-dir --force-reinstall \
             'git+https://github.com/deltathedumb/asmpython.git@376cf9422c28123673a1dedd7dd66b845f3c5ed1'
       - name: Normalize probe source
+        shell: bash
         run: |
-          python tools/normalize_full_core_probe.py
-          python tools/normalize_full_core_lambdas.py
-          python tools/normalize_full_core_native_semantics.py
-          python tools/normalize_full_core_opcode_maps.py
-          python tools/normalize_full_core_validation.py
+          mkdir -p dist
+          set +e
+          python tools/normalize_full_core_validation.py \
+            > dist/linux-full-core-normalization.txt 2>&1
+          status=$?
+          set -e
+          if [ "$status" -ne 0 ]; then
+            if [ -f dist/full-core-normalization-error.txt ]; then
+              cat dist/full-core-normalization-error.txt
+            else
+              cat dist/linux-full-core-normalization.txt
+            fi
+            exit "$status"
+          fi
+          cat dist/linux-full-core-normalization.txt
           mkdir -p dist/debug-tree
           python - <<'PY'
           from pathlib import Path
@@ -129,13 +140,17 @@ jobs:
         run: |
           {
             echo '<!-- portapy-full-core-linux-diagnostic -->'
-            echo '### Linux full-core compiler diagnostic'
+            echo '### Linux full-core diagnostic'
             echo
             echo '```text'
-            if [ -f dist/linux-full-core-build.log ]; then
+            if [ -f dist/full-core-normalization-error.txt ]; then
+              cat dist/full-core-normalization-error.txt
+            elif [ -f dist/linux-full-core-build.log ]; then
               tail -n 180 dist/linux-full-core-build.log
+            elif [ -f dist/linux-full-core-normalization.txt ]; then
+              cat dist/linux-full-core-normalization.txt
             else
-              echo 'No compiler log was produced.'
+              echo 'No diagnostic log was produced.'
             fi
             echo '```'
           } > /tmp/portapy-full-core-linux.md
@@ -164,16 +179,19 @@ jobs:
       - name: Normalize probe source
         shell: powershell
         run: |
-          python tools/normalize_full_core_probe.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_lambdas.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_native_semantics.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_opcode_maps.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          python tools/normalize_full_core_validation.py
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          New-Item -ItemType Directory -Force dist | Out-Null
+          $normalizationLog = Join-Path $PWD 'dist/windows-full-core-normalization.txt'
+          python tools/normalize_full_core_validation.py *> $normalizationLog
+          $status = $LASTEXITCODE
+          if ($status -ne 0) {
+            if (Test-Path dist/full-core-normalization-error.txt) {
+              Get-Content dist/full-core-normalization-error.txt
+            } else {
+              Get-Content $normalizationLog
+            }
+            exit $status
+          }
+          Get-Content $normalizationLog
       - name: Compile full frontend and VM probe
         shell: powershell
         run: |
@@ -255,19 +273,23 @@ jobs:
         run: |
           $lines = @(
             '<!-- portapy-full-core-windows-diagnostic -->',
-            '### Windows full-core compiler diagnostic',
+            '### Windows full-core diagnostic',
             '',
             '```text'
           )
-          if (Test-Path dist/windows-full-core-build.log) {
-            $lines += Get-Content dist/windows-full-core-build.log -Tail 180
+          if (Test-Path dist/full-core-normalization-error.txt) {
+            $lines += Get-Content dist/full-core-normalization-error.txt
+          } elseif (Test-Path dist/windows-full-core-build.log) {
+            $lines += Get-Content dist/windows-full-core-build.log | Select-Object -Last 180
+          } elseif (Test-Path dist/windows-full-core-normalization.txt) {
+            $lines += Get-Content dist/windows-full-core-normalization.txt
           } else {
-            $lines += 'No compiler log was produced.'
+            $lines += 'No diagnostic log was produced.'
           }
           $lines += '```'
-          $path = "$env:RUNNER_TEMP\portapy-full-core-windows.md"
-          $lines | Set-Content -Encoding utf8 $path
-          gh pr comment "${{ github.event.pull_request.number }}" --body-file $path
+          $lines | Set-Content -Encoding utf8 $env:TEMP/portapy-full-core-windows.md
+          gh pr comment "${{ github.event.pull_request.number }}" `
+            --body-file $env:TEMP/portapy-full-core-windows.md
       - uses: actions/upload-artifact@v4
         if: always()
         with:

From 0b5ce5e103f55aaf164686d3c82ac0852eb339ff Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:36:50 -0500
Subject: [PATCH 336/450] Gate single-pass full-core normalization

---
 tests/test_full_core_workflow.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 tests/test_full_core_workflow.py

diff --git a/tests/test_full_core_workflow.py b/tests/test_full_core_workflow.py
new file mode 100644
index 00000000..eeb68207
--- /dev/null
+++ b/tests/test_full_core_workflow.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+WORKFLOW = Path(__file__).parents[1] / ".github" / "workflows" / "native-full-core-probe.yml"
+
+
+def test_full_core_workflow_runs_complete_normalizer_once_per_platform() -> None:
+    source = WORKFLOW.read_text(encoding="utf-8")
+
+    assert source.count("python tools/normalize_full_core_validation.py") == 2
+    for obsolete_command in (
+        "python tools/normalize_full_core_probe.py",
+        "python tools/normalize_full_core_lambdas.py",
+        "python tools/normalize_full_core_native_semantics.py",
+        "python tools/normalize_full_core_opcode_maps.py",
+    ):
+        assert obsolete_command not in source

From 3a910360ecb3e6cb3215a40617f9ced43f19ecb0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:39:00 -0500
Subject: [PATCH 337/450] Make full-core normalizer directly executable

---
 tools/normalize_full_core_validation.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 220359dc..472cc805 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -4,9 +4,16 @@
 import contextlib
 import io
 from pathlib import Path
+import sys
 import traceback
 from typing import Callable
 
+
+_REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+if str(_REPOSITORY_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPOSITORY_ROOT))
+
+
 from tools.combine_full_core_native_parser import main as combine_native_parser
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
 from tools.normalize_full_core_boolops import main as normalize_boolops

From addb1c464e69ee55c772e3b53178249c5bd3826e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:39:08 -0500
Subject: [PATCH 338/450] Run full-core validation as a package module

---
 .github/workflows/native-full-core-probe.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 8811b030..6f880a56 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -33,7 +33,7 @@ jobs:
         run: |
           mkdir -p dist
           set +e
-          python tools/normalize_full_core_validation.py \
+          python -m tools.normalize_full_core_validation \
             > dist/linux-full-core-normalization.txt 2>&1
           status=$?
           set -e
@@ -181,7 +181,7 @@ jobs:
         run: |
           New-Item -ItemType Directory -Force dist | Out-Null
           $normalizationLog = Join-Path $PWD 'dist/windows-full-core-normalization.txt'
-          python tools/normalize_full_core_validation.py *> $normalizationLog
+          python -m tools.normalize_full_core_validation *> $normalizationLog
           $status = $LASTEXITCODE
           if ($status -ne 0) {
             if (Test-Path dist/full-core-normalization-error.txt) {

From a3be8d074093493a839e5156b4059a537ad6cc49 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:39:27 -0500
Subject: [PATCH 339/450] Gate module-based full-core normalization

---
 tests/test_full_core_workflow.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_full_core_workflow.py b/tests/test_full_core_workflow.py
index eeb68207..2a419735 100644
--- a/tests/test_full_core_workflow.py
+++ b/tests/test_full_core_workflow.py
@@ -9,7 +9,8 @@
 def test_full_core_workflow_runs_complete_normalizer_once_per_platform() -> None:
     source = WORKFLOW.read_text(encoding="utf-8")
 
-    assert source.count("python tools/normalize_full_core_validation.py") == 2
+    assert source.count("python -m tools.normalize_full_core_validation") == 2
+    assert "python tools/normalize_full_core_validation.py" not in source
     for obsolete_command in (
         "python tools/normalize_full_core_probe.py",
         "python tools/normalize_full_core_lambdas.py",

From 68445b70c72a1d0c624c1a3de53b32558c9c5ff3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:41:20 -0500
Subject: [PATCH 340/450] Gate importable full-core validation module

---
 tests/test_full_core_workflow.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/test_full_core_workflow.py b/tests/test_full_core_workflow.py
index 2a419735..2c0e9179 100644
--- a/tests/test_full_core_workflow.py
+++ b/tests/test_full_core_workflow.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib.util
 from pathlib import Path
 
 
@@ -18,3 +19,7 @@ def test_full_core_workflow_runs_complete_normalizer_once_per_platform() -> None
         "python tools/normalize_full_core_opcode_maps.py",
     ):
         assert obsolete_command not in source
+
+
+def test_full_core_normalizer_is_importable_as_a_module() -> None:
+    assert importlib.util.find_spec("tools.normalize_full_core_validation") is not None

From 3f01e5cba091b51b7c4249ab0d4d686c23f80eed Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:52:15 -0500
Subject: [PATCH 341/450] Avoid unresolved Enum equality in native probe

---
 src/portapy/native_full_core_probe.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/portapy/native_full_core_probe.py b/src/portapy/native_full_core_probe.py
index f6628a3b..fc8d0b6f 100644
--- a/src/portapy/native_full_core_probe.py
+++ b/src/portapy/native_full_core_probe.py
@@ -23,6 +23,7 @@
     _portapy_value_get_kind_impl,
     _runtime,
 )
+from .reference_api import Status
 
 
 class _ProbeModule:
@@ -53,7 +54,7 @@ def portapy_full_core_probe() -> int:
     instance = _runtime(runtime)
     if instance is None:
         return -6
-    if instance.set_global("__pyinbin_import__", _probe_import) != PORTAPY_OK:
+    if instance.set_global("__pyinbin_import__", _probe_import) is not Status.OK:
         return -7
     forty = _portapy_value_from_i64_impl(runtime, 40)
     two = _portapy_value_from_i64_impl(runtime, 2)

From 1c6565b5c8b5bdd78372af3980bf9d15813d622a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 16:58:39 -0500
Subject: [PATCH 342/450] Complete native probe linking on Linux and Windows

---
 .github/workflows/native-full-core-probe.yml | 24 +++++++++++++++-----
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/native-full-core-probe.yml b/.github/workflows/native-full-core-probe.yml
index 6f880a56..5d20b3e1 100644
--- a/.github/workflows/native-full-core-probe.yml
+++ b/.github/workflows/native-full-core-probe.yml
@@ -98,6 +98,7 @@ jobs:
           MAP
           gcc -shared dist/libportapy_full_core_probe.o \
             -Wl,--version-script=dist/portapy_full_core_probe.map \
+            -lm \
             -o dist/libportapy_full_core_probe.so
       - name: Execute full core from external C host
         run: |
@@ -196,22 +197,33 @@ jobs:
         shell: powershell
         run: |
           New-Item -ItemType Directory -Force dist | Out-Null
-          python tools/run_full_core_asmpython.py build src/portapy/native_full_core_probe.py `
-            --target windows --type library --backend legacy `
-            --no-pyinbin-fallback --keep-assembly `
-            -o dist/portapy_full_core_probe.dll `
-            *>&1 | Tee-Object -FilePath dist/windows-full-core-build.log
-          $compilerExit = $LASTEXITCODE
+          $oldErrorPreference = $ErrorActionPreference
+          $oldNativeErrorPreference = $PSNativeCommandUseErrorActionPreference
+          $ErrorActionPreference = 'Continue'
+          $PSNativeCommandUseErrorActionPreference = $false
+          try {
+            python tools/run_full_core_asmpython.py build src/portapy/native_full_core_probe.py `
+              --target windows --type library --backend legacy `
+              --no-pyinbin-fallback --keep-assembly `
+              -o dist/portapy_full_core_probe.dll `
+              *>&1 | Tee-Object -FilePath dist/windows-full-core-build.log
+            $compilerExit = $LASTEXITCODE
+          } finally {
+            $ErrorActionPreference = $oldErrorPreference
+            $PSNativeCommandUseErrorActionPreference = $oldNativeErrorPreference
+          }
           if (-not (Test-Path dist/portapy_full_core_probe.asm)) {
             exit $compilerExit
           }
           python tools/nasm_module_init.py dist/portapy_full_core_probe.asm `
             --target windows --public-symbol portapy_library_initialize
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           python tools/nasm_exports.py dist/portapy_full_core_probe.asm `
             --export portapy_library_initialize `
             --export portapy_abi_version `
             --export portapy_full_core_parse_probe `
             --export portapy_full_core_probe
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           nasm -f win64 -w-label-redef-late `
             dist/portapy_full_core_probe.asm `
             -o dist/portapy_full_core_probe.obj

From 4a0b2fe692e3c3343825aeb79906ec4b41f61879 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:06:37 -0500
Subject: [PATCH 343/450] Store native value handles in an indexed list

---
 tools/normalize_full_reference_runtime.py | 41 +++++++++++++----------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index ee8aa54c..b884abad 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -64,8 +64,13 @@ class _Slot:
     ) -> int:
         handle = self._next
         self._next += 1
-        self._values[handle] = _Slot(value, kind)
+        self._values.append(_Slot(value, kind))
         return handle
+
+    def _value_slot(self, handle: int) -> _Slot | None:
+        if handle <= 0 or handle >= len(self._values):
+            return None
+        return self._values[handle]
 '''
 _BOX_METHODS = '''    def box_none(self) -> tuple[Status, int]:
         return Status.OK, self._store(None)
@@ -133,7 +138,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, kind
 '''
 _NATIVE_VALUE_KIND_METHOD = '''    def value_kind(self, handle: int) -> tuple[Status, ValueKind]:
-        slot = self._values.get(handle)
+        slot = self._value_slot(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), ValueKind.OBJECT
         return Status.OK, slot.kind
@@ -147,7 +152,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value
 '''
 _NATIVE_AS_INT_METHOD = '''    def as_int(self, handle: int) -> tuple[Status, int]:
-        slot = self._values.get(handle)
+        slot = self._value_slot(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0
         if slot.kind is not ValueKind.INT:
@@ -163,7 +168,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value
 '''
 _NATIVE_AS_FLOAT_METHOD = '''    def as_float(self, handle: int) -> tuple[Status, float]:
-        slot = self._values.get(handle)
+        slot = self._value_slot(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0.0
         if slot.kind is not ValueKind.FLOAT:
@@ -179,7 +184,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value.encode("utf-8")
 '''
 _NATIVE_AS_UTF8_METHOD = '''    def as_utf8(self, handle: int) -> tuple[Status, bytes]:
-        slot = self._values.get(handle)
+        slot = self._value_slot(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), b""
         if slot.kind is not ValueKind.STRING:
@@ -200,13 +205,13 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         self._error_column = 0
 '''
 _VALUES_ANNOTATION = "self._values: dict[int, _Slot] = {}"
-_NATIVE_VALUES_ANNOTATION = "self._values: dict[str, _Slot] = {}"
-_HANDLE_SUBSCRIPT = "self._values[handle]"
-_NATIVE_HANDLE_SUBSCRIPT = "self._values[str(handle)]"
+_NATIVE_VALUES_ANNOTATION = "self._values: list[_Slot | None] = [None]"
 _HANDLE_GET = "self._values.get(handle)"
-_NATIVE_HANDLE_GET = "self._values.get(str(handle))"
+_NATIVE_HANDLE_GET = "self._value_slot(handle)"
 _CALLABLE_HANDLE_GET = "self._values.get(callable_handle)"
-_NATIVE_CALLABLE_HANDLE_GET = "self._values.get(str(callable_handle))"
+_NATIVE_CALLABLE_HANDLE_GET = "self._value_slot(callable_handle)"
+_HANDLE_DELETE = "del self._values[handle]"
+_NATIVE_HANDLE_DELETE = "self._values[handle] = None"
 
 
 def _replace_exact(
@@ -250,13 +255,6 @@ def main() -> int:
         label="error coordinate reset",
         expected=3,
     )
-    source = _replace_exact(
-        source,
-        _HANDLE_SUBSCRIPT,
-        _NATIVE_HANDLE_SUBSCRIPT,
-        label="value-table subscript",
-        expected=2,
-    )
     source = _replace_exact(
         source,
         _HANDLE_GET,
@@ -271,10 +269,17 @@ def main() -> int:
         label="callable value-table lookup",
         expected=1,
     )
+    source = _replace_exact(
+        source,
+        _HANDLE_DELETE,
+        _NATIVE_HANDLE_DELETE,
+        label="value-table release",
+        expected=1,
+    )
     PATH.write_text(source, encoding="utf-8")
     print("NORMALIZED NATIVE REFERENCE ERROR CAPTURE", 2)
     print("NORMALIZED NATIVE ERROR COORDINATES", 4)
-    print("NORMALIZED NATIVE VALUE HANDLE KEYS", 11)
+    print("NORMALIZED NATIVE VALUE HANDLE LIST", 11)
     print("NORMALIZED NATIVE VALUE KIND SLOTS", 9)
     return 0
 

From 754bf0097414af0c816f635a9867c9e0e85f7e95 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:07:06 -0500
Subject: [PATCH 344/450] Test indexed native value handle storage

---
 .../test_normalize_full_reference_runtime.py  | 59 +++++++++++++++++--
 1 file changed, 54 insertions(+), 5 deletions(-)

diff --git a/tests/test_normalize_full_reference_runtime.py b/tests/test_normalize_full_reference_runtime.py
index 016e8a46..f55c01a0 100644
--- a/tests/test_normalize_full_reference_runtime.py
+++ b/tests/test_normalize_full_reference_runtime.py
@@ -34,12 +34,16 @@ def test_normalizes_real_reference_runtime(
     assert result.count("self._error_line = 0") >= 4
     assert result.count("self._error_column = 0") >= 4
 
-    assert "dict[str, _Slot]" in result
+    assert "self._values: list[_Slot | None] = [None]" in result
     assert "kind: ValueKind = ValueKind.INT" in result
-    assert "self._values[str(handle)] = _Slot(value, kind)" in result
-    assert result.count("self._values.get(str(handle))") == 8
-    assert result.count("self._values.get(str(callable_handle))") == 1
-    assert "del self._values[str(handle)]" in result
+    assert "self._values.append(_Slot(value, kind))" in result
+    assert "def _value_slot(self, handle: int) -> _Slot | None:" in result
+    assert "if handle <= 0 or handle >= len(self._values):" in result
+    assert result.count("self._value_slot(handle)") == 8
+    assert result.count("self._value_slot(callable_handle)") == 1
+    assert "self._values[handle] = None" in result
+    assert "str(handle)" not in result
+    assert "dict[str, _Slot]" not in result
 
     assert "self._store(None, ValueKind.NONE)" in result
     assert "self._store(value, ValueKind.BOOL)" in result
@@ -55,6 +59,51 @@ def test_normalizes_real_reference_runtime(
     assert "type(slot.value)" not in result
 
 
+def test_native_value_slots_use_stable_integer_indices(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = tmp_path / "reference_api.py"
+    path.write_text(REFERENCE_SOURCE.read_text(encoding="utf-8"), encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    namespace: dict[str, object] = {}
+    # The complete module has package-relative imports, so execute only the
+    # normalized Runtime storage methods in a tiny compatible shell.
+    source = path.read_text(encoding="utf-8")
+    runtime_start = source.index("class Runtime:")
+    runtime_source = source[runtime_start:]
+    prefix = '''
+from dataclasses import dataclass
+from enum import IntEnum
+class Status(IntEnum):
+    OK = 0
+    INVALID_HANDLE = 7
+class ValueKind(IntEnum):
+    INT = 2
+@dataclass
+class _Slot:
+    value: object
+    kind: ValueKind = ValueKind.INT
+    refs: int = 1
+'''
+    # Keep just the methods needed for storage semantics.
+    store_start = runtime_source.index("    def _store(")
+    close_start = runtime_source.index("    def close(")
+    methods = runtime_source[store_start:close_start]
+    exec(prefix + "\nclass Probe:\n" + methods, namespace)
+    probe = namespace["Probe"]()
+    probe._values = [None]
+    probe._next = 1
+    first = probe._store("first")
+    second = probe._store("second")
+    assert (first, second) == (1, 2)
+    assert probe._value_slot(first).value == "first"
+    assert probe._value_slot(second).value == "second"
+    assert probe._value_slot(0) is None
+    assert probe._value_slot(99) is None
+
+
 def test_rejects_unexpected_reference_runtime_shape(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:

From 87f234a2298da20da534e7eba0e2ede1e37e359a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:14:22 -0500
Subject: [PATCH 345/450] Fix Linux stack alignment in native container writes

---
 .../normalize_full_reference_safe_host_ids.py | 88 +++++++++++++++++--
 1 file changed, 83 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_reference_safe_host_ids.py b/tools/normalize_full_reference_safe_host_ids.py
index 67557773..bb7c5f1d 100644
--- a/tools/normalize_full_reference_safe_host_ids.py
+++ b/tools/normalize_full_reference_safe_host_ids.py
@@ -1,4 +1,4 @@
-"""Make host ID getters return status errors without unsafe value dereferences."""
+"""Make native host ID getters and nested container writes compiler-safe."""
 from __future__ import annotations
 
 import ast
@@ -51,6 +51,72 @@
 }
 
 
+def _is_slot_value_call(node: ast.AST) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_slot_value"
+        and len(node.args) == 2
+        and not node.keywords
+    )
+
+
+class _NestedSlotValueHoister(ast.NodeTransformer):
+    """Keep asmpython from emitting an odd push across a nested native call."""
+
+    def __init__(self) -> None:
+        self.hoisted = 0
+
+    def _name(self) -> str:
+        name = f"_native_slot_value_{self.hoisted}"
+        self.hoisted += 1
+        return name
+
+    def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
+        self.generic_visit(node)
+        if (
+            len(node.targets) != 1
+            or not isinstance(node.targets[0], ast.Subscript)
+            or not _is_slot_value_call(node.value)
+        ):
+            return node
+        name = self._name()
+        value = node.value
+        node.value = ast.copy_location(ast.Name(id=name, ctx=ast.Load()), value)
+        temporary = ast.copy_location(
+            ast.Assign(
+                targets=[ast.Name(id=name, ctx=ast.Store())],
+                value=value,
+            ),
+            node,
+        )
+        return [temporary, node]
+
+    def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.stmt]:
+        self.generic_visit(node)
+        call = node.value
+        if (
+            not isinstance(call, ast.Call)
+            or not isinstance(call.func, ast.Attribute)
+            or call.func.attr != "append"
+            or len(call.args) != 1
+            or call.keywords
+            or not _is_slot_value_call(call.args[0])
+        ):
+            return node
+        name = self._name()
+        value = call.args[0]
+        call.args[0] = ast.copy_location(ast.Name(id=name, ctx=ast.Load()), value)
+        temporary = ast.copy_location(
+            ast.Assign(
+                targets=[ast.Name(id=name, ctx=ast.Store())],
+                value=value,
+            ),
+            node,
+        )
+        return [temporary, node]
+
+
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.replaced: set[str] = set()
@@ -68,9 +134,14 @@ def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     rewrite = _Rewrite()
     module = rewrite.visit(module)
+    hoister = _NestedSlotValueHoister()
+    module = hoister.visit(module)
     missing = sorted(set(_REPLACEMENTS) - rewrite.replaced)
-    if missing:
-        raise RuntimeError(f"native host ID getters missing: {missing}")
+    if missing or hoister.hoisted != 4:
+        raise RuntimeError(
+            "native host ABI normalization missed shapes; "
+            f"missing={missing}, nested_slot_calls={hoister.hoisted}"
+        )
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
@@ -79,11 +150,18 @@ def main() -> int:
         "_native_value_kind_code(kind) != PORTAPY_VALUE_OBJECT",
         "_native_value_kind_code(kind) != PORTAPY_VALUE_CALLABLE",
         "status, result = instance.unbox(value)",
+        "_native_slot_value_0 = _slot_value(instance, item)",
+        "_native_slot_value_3 = _slot_value(instance, item)",
     )
     absent = [marker for marker in required if marker not in verified]
     if absent:
-        raise RuntimeError(f"native host ID getter validation failed: {absent}")
-    print("NORMALIZED SAFE NATIVE HOST ID GETTERS", len(_REPLACEMENTS))
+        raise RuntimeError(f"native host ABI validation failed: {absent}")
+    print(
+        "NORMALIZED SAFE NATIVE HOST ABI",
+        len(_REPLACEMENTS),
+        "HOISTED SLOT CALLS",
+        hoister.hoisted,
+    )
     return 0
 
 

From 273a5633bf7c1c519fc4504ed5f9006d917459ba Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:14:32 -0500
Subject: [PATCH 346/450] Test native nested-call stack alignment normalization

---
 ...ze_full_reference_native_call_alignment.py | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_native_call_alignment.py

diff --git a/tests/test_normalize_full_reference_native_call_alignment.py b/tests/test_normalize_full_reference_native_call_alignment.py
new file mode 100644
index 00000000..42485709
--- /dev/null
+++ b/tests/test_normalize_full_reference_native_call_alignment.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import ast
+
+from tools import normalize_full_reference_safe_host_ids as normalizer
+
+
+def test_nested_slot_value_calls_are_hoisted_before_container_writes() -> None:
+    module = ast.parse(
+        '''
+def assign_item(instance, item, values, index):
+    values[index] = _slot_value(instance, item)
+
+
+def append_item(instance, item, values):
+    values.append(_slot_value(instance, item))
+'''
+    )
+    hoister = normalizer._NestedSlotValueHoister()
+    module = hoister.visit(module)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module)
+
+    assert hoister.hoisted == 2
+    assert "values[index] = _slot_value(" not in source
+    assert "values.append(_slot_value(" not in source
+    assert "_native_slot_value_0 = _slot_value(instance, item)" in source
+    assert "values[index] = _native_slot_value_0" in source
+    assert "_native_slot_value_1 = _slot_value(instance, item)" in source
+    assert "values.append(_native_slot_value_1)" in source

From 0db036a0e6c556c1c415682deacf0051e720f9c8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:21:15 -0500
Subject: [PATCH 347/450] Fix reference runtime handle normalization ordering

---
 tools/normalize_full_reference_runtime.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tools/normalize_full_reference_runtime.py b/tools/normalize_full_reference_runtime.py
index b884abad..57e53a12 100644
--- a/tools/normalize_full_reference_runtime.py
+++ b/tools/normalize_full_reference_runtime.py
@@ -138,7 +138,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, kind
 '''
 _NATIVE_VALUE_KIND_METHOD = '''    def value_kind(self, handle: int) -> tuple[Status, ValueKind]:
-        slot = self._value_slot(handle)
+        slot = self._values.get(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), ValueKind.OBJECT
         return Status.OK, slot.kind
@@ -152,7 +152,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value
 '''
 _NATIVE_AS_INT_METHOD = '''    def as_int(self, handle: int) -> tuple[Status, int]:
-        slot = self._value_slot(handle)
+        slot = self._values.get(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0
         if slot.kind is not ValueKind.INT:
@@ -168,7 +168,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value
 '''
 _NATIVE_AS_FLOAT_METHOD = '''    def as_float(self, handle: int) -> tuple[Status, float]:
-        slot = self._value_slot(handle)
+        slot = self._values.get(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), 0.0
         if slot.kind is not ValueKind.FLOAT:
@@ -184,7 +184,7 @@ def box_bytes(self, value: bytes) -> tuple[Status, int]:
         return Status.OK, slot.value.encode("utf-8")
 '''
 _NATIVE_AS_UTF8_METHOD = '''    def as_utf8(self, handle: int) -> tuple[Status, bytes]:
-        slot = self._value_slot(handle)
+        slot = self._values.get(handle)
         if slot is None:
             return self._capture(Status.INVALID_HANDLE, KeyError(handle)), b""
         if slot.kind is not ValueKind.STRING:
@@ -255,6 +255,8 @@ def main() -> int:
         label="error coordinate reset",
         expected=3,
     )
+    # Keep all handle accesses in one final pass. The four replaced conversion
+    # methods deliberately retain the dictionary lookup until this point.
     source = _replace_exact(
         source,
         _HANDLE_GET,

From f993aac848db17d3570241b31862dfdff30b5e3d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:22:30 -0500
Subject: [PATCH 348/450] Fix native keyword AST field extraction

---
 tools/normalize_full_core_keyword_calls.py | 28 ++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tools/normalize_full_core_keyword_calls.py b/tools/normalize_full_core_keyword_calls.py
index e36cb8c0..36aaaa9d 100644
--- a/tools/normalize_full_core_keyword_calls.py
+++ b/tools/normalize_full_core_keyword_calls.py
@@ -5,6 +5,7 @@
 
 
 CORE = Path("src/portapy/core")
+FRONTEND_PATH = CORE / "frontend.py"
 PARSER_RUNTIME_PATH = CORE / "native_parser_runtime.py"
 NATIVE_AST_PATH = CORE / "native_ast.py"
 VM_PATH = CORE / "vm.py"
@@ -28,6 +29,32 @@ def _replace_method(
     return source[:start] + replacement + source[end:]
 
 
+def _normalize_frontend() -> None:
+    source = FRONTEND_PATH.read_text(encoding="utf-8")
+    old = '''            for keyword in node.keywords:
+                self.expr(keyword.value)
+            names = tuple(keyword.arg for keyword in node.keywords)
+            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+'''
+    new = '''            keyword_names: list[object] = []
+            for keyword in node.keywords:
+                keyword_value: ast.expr = getattr(keyword, "value")
+                self.expr(keyword_value)
+                keyword_name = getattr(keyword, "arg")
+                keyword_names.append(keyword_name)
+            names = tuple(keyword_names)
+            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+'''
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(
+            f"native frontend keyword extraction: expected 1 match, found {count}"
+        )
+    source = source.replace(old, new, 1)
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    print("NORMALIZED NATIVE FRONTEND KEYWORD EXTRACTION", count)
+
+
 def _normalize_parser_runtime() -> None:
     source = PARSER_RUNTIME_PATH.read_text(encoding="utf-8")
     anchor = "class _npr_parser_Parser:\n"
@@ -142,6 +169,7 @@ def _normalize_vm() -> None:
 
 
 def main() -> int:
+    _normalize_frontend()
     _normalize_parser_runtime()
     _normalize_native_ast()
     _normalize_vm()

From 028cf6a0cef3fad018b4ace2396590252a62b4a4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:22:44 -0500
Subject: [PATCH 349/450] Test compiler-safe keyword field extraction

---
 .../test_normalize_full_core_keyword_calls.py | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/test_normalize_full_core_keyword_calls.py

diff --git a/tests/test_normalize_full_core_keyword_calls.py b/tests/test_normalize_full_core_keyword_calls.py
new file mode 100644
index 00000000..5fc535a7
--- /dev/null
+++ b/tests/test_normalize_full_core_keyword_calls.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_keyword_calls as normalizer
+
+
+def test_frontend_keyword_fields_are_extracted_through_typed_locals(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    frontend = tmp_path / "frontend.py"
+    frontend.write_text(
+        '''            for keyword in node.keywords:
+                self.expr(keyword.value)
+            names = tuple(keyword.arg for keyword in node.keywords)
+            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+
+    normalizer._normalize_frontend()
+
+    source = frontend.read_text(encoding="utf-8")
+    assert 'keyword_value: ast.expr = getattr(keyword, "value")' in source
+    assert 'keyword_name = getattr(keyword, "arg")' in source
+    assert "keyword_names.append(keyword_name)" in source
+    assert "self.expr(keyword.value)" not in source
+    assert "keyword.arg for keyword" not in source

From 3d0843a3b5ee809f2adf8abf500f1b90b35bd1ae Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:24:50 -0500
Subject: [PATCH 350/450] Normalize materialized native value lookups

---
 .../normalize_full_reference_safe_host_ids.py | 46 +++++++++++++++++--
 1 file changed, 43 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_reference_safe_host_ids.py b/tools/normalize_full_reference_safe_host_ids.py
index bb7c5f1d..822fdfe1 100644
--- a/tools/normalize_full_reference_safe_host_ids.py
+++ b/tools/normalize_full_reference_safe_host_ids.py
@@ -1,4 +1,4 @@
-"""Make native host ID getters and nested container writes compiler-safe."""
+"""Make native value access and nested container writes compiler-safe."""
 from __future__ import annotations
 
 import ast
@@ -61,6 +61,40 @@ def _is_slot_value_call(node: ast.AST) -> bool:
     )
 
 
+class _LegacyValueLookupRewriter(ast.NodeTransformer):
+    """Use Runtime._value_slot after the native runtime switches to a list."""
+
+    def __init__(self) -> None:
+        self.replaced = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            isinstance(node.func, ast.Attribute)
+            and node.func.attr == "get"
+            and isinstance(node.func.value, ast.Attribute)
+            and node.func.value.attr == "_values"
+            and isinstance(node.func.value.value, ast.Name)
+            and node.func.value.value.id == "instance"
+            and len(node.args) == 1
+            and not node.keywords
+        ):
+            self.replaced += 1
+            return ast.copy_location(
+                ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="instance", ctx=ast.Load()),
+                        attr="_value_slot",
+                        ctx=ast.Load(),
+                    ),
+                    args=node.args,
+                    keywords=[],
+                ),
+                node,
+            )
+        return node
+
+
 class _NestedSlotValueHoister(ast.NodeTransformer):
     """Keep asmpython from emitting an odd push across a nested native call."""
 
@@ -134,19 +168,23 @@ def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     rewrite = _Rewrite()
     module = rewrite.visit(module)
+    value_lookup = _LegacyValueLookupRewriter()
+    module = value_lookup.visit(module)
     hoister = _NestedSlotValueHoister()
     module = hoister.visit(module)
     missing = sorted(set(_REPLACEMENTS) - rewrite.replaced)
-    if missing or hoister.hoisted != 4:
+    if missing or value_lookup.replaced != 1 or hoister.hoisted != 4:
         raise RuntimeError(
             "native host ABI normalization missed shapes; "
-            f"missing={missing}, nested_slot_calls={hoister.hoisted}"
+            f"missing={missing}, value_lookups={value_lookup.replaced}, "
+            f"nested_slot_calls={hoister.hoisted}"
         )
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
     PATH.write_text(source, encoding="utf-8")
     verified = ast.unparse(ast.parse(source))
     required = (
+        "slot = instance._value_slot(handle)",
         "_native_value_kind_code(kind) != PORTAPY_VALUE_OBJECT",
         "_native_value_kind_code(kind) != PORTAPY_VALUE_CALLABLE",
         "status, result = instance.unbox(value)",
@@ -159,6 +197,8 @@ def main() -> int:
     print(
         "NORMALIZED SAFE NATIVE HOST ABI",
         len(_REPLACEMENTS),
+        "VALUE LOOKUPS",
+        value_lookup.replaced,
         "HOISTED SLOT CALLS",
         hoister.hoisted,
     )

From fbc93b357faabf0f6688041c90b0ec6cdf4b9785 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:25:06 -0500
Subject: [PATCH 351/450] Test native list-backed value lookup normalization

---
 ...ize_full_reference_native_call_alignment.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/tests/test_normalize_full_reference_native_call_alignment.py b/tests/test_normalize_full_reference_native_call_alignment.py
index 42485709..37125923 100644
--- a/tests/test_normalize_full_reference_native_call_alignment.py
+++ b/tests/test_normalize_full_reference_native_call_alignment.py
@@ -5,6 +5,24 @@
 from tools import normalize_full_reference_safe_host_ids as normalizer
 
 
+def test_legacy_value_lookup_uses_native_slot_accessor() -> None:
+    module = ast.parse(
+        '''
+def replace_value(instance, handle, value):
+    slot = instance._values.get(handle)
+    slot.value = value
+'''
+    )
+    rewrite = normalizer._LegacyValueLookupRewriter()
+    module = rewrite.visit(module)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module)
+
+    assert rewrite.replaced == 1
+    assert "slot = instance._value_slot(handle)" in source
+    assert "instance._values.get(handle)" not in source
+
+
 def test_nested_slot_value_calls_are_hoisted_before_container_writes() -> None:
     module = ast.parse(
         '''

From 5fe5f9f20e366a4763bcd2e2022939b61a0f146e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:25:41 -0500
Subject: [PATCH 352/450] Adapt materialized full runtime to list-backed
 handles

---
 tools/materialize_full_reference_entry.py | 24 +++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/tools/materialize_full_reference_entry.py b/tools/materialize_full_reference_entry.py
index b9368187..bc156730 100644
--- a/tools/materialize_full_reference_entry.py
+++ b/tools/materialize_full_reference_entry.py
@@ -10,18 +10,34 @@
 PAYLOAD = Path("tools/full_reference_payload/entry.py.gz.b64")
 OUTPUT = Path("src/portapy/native_full_reference_entry.py")
 EXPECTED_SHA256 = "907b729049b38ce3bbe6ca241a7b5530a705c046330e0a36aa0cae89ad6bc528"
+_LEGACY_VALUE_LOOKUP = "slot = instance._values.get(handle)"
+_NATIVE_VALUE_LOOKUP = "slot = instance._value_slot(handle)"
 
 
 def main() -> int:
     encoded = PAYLOAD.read_text(encoding="ascii").strip()
-    source = gzip.decompress(base64.b64decode(encoded))
-    digest = hashlib.sha256(source).hexdigest()
+    payload = gzip.decompress(base64.b64decode(encoded))
+    digest = hashlib.sha256(payload).hexdigest()
     if digest != EXPECTED_SHA256:
         raise RuntimeError(
             f"full Runtime ABI payload digest mismatch: {digest}"
         )
-    OUTPUT.write_bytes(source)
-    print("MATERIALIZED FULL RUNTIME ABI", len(source), digest)
+    source = payload.decode("utf-8")
+    lookup_count = source.count(_LEGACY_VALUE_LOOKUP)
+    if lookup_count != 1:
+        raise RuntimeError(
+            "full Runtime ABI payload value lookup expected 1 match, "
+            f"found {lookup_count}"
+        )
+    source = source.replace(_LEGACY_VALUE_LOOKUP, _NATIVE_VALUE_LOOKUP, 1)
+    OUTPUT.write_text(source, encoding="utf-8")
+    print(
+        "MATERIALIZED FULL RUNTIME ABI",
+        len(payload),
+        digest,
+        "NATIVE VALUE LOOKUPS",
+        lookup_count,
+    )
     return 0
 
 

From 40f4f5af813455b1533c56100b58984cef601bc4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:26:11 -0500
Subject: [PATCH 353/450] Allow already-adapted materialized value lookups

---
 tools/normalize_full_reference_safe_host_ids.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_reference_safe_host_ids.py b/tools/normalize_full_reference_safe_host_ids.py
index 822fdfe1..b812bc77 100644
--- a/tools/normalize_full_reference_safe_host_ids.py
+++ b/tools/normalize_full_reference_safe_host_ids.py
@@ -173,7 +173,7 @@ def main() -> int:
     hoister = _NestedSlotValueHoister()
     module = hoister.visit(module)
     missing = sorted(set(_REPLACEMENTS) - rewrite.replaced)
-    if missing or value_lookup.replaced != 1 or hoister.hoisted != 4:
+    if missing or value_lookup.replaced not in (0, 1) or hoister.hoisted != 4:
         raise RuntimeError(
             "native host ABI normalization missed shapes; "
             f"missing={missing}, value_lookups={value_lookup.replaced}, "

From 6834f95d9bf8b16f89b80eb79b193ff702be774f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:29:15 -0500
Subject: [PATCH 354/450] Materialize native values by handle kind

---
 .../normalize_full_reference_safe_host_ids.py | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/tools/normalize_full_reference_safe_host_ids.py b/tools/normalize_full_reference_safe_host_ids.py
index b812bc77..8c22d563 100644
--- a/tools/normalize_full_reference_safe_host_ids.py
+++ b/tools/normalize_full_reference_safe_host_ids.py
@@ -7,6 +7,24 @@
 
 PATH = Path("src/portapy/native_full_reference_entry.py")
 
+_SLOT_VALUE_SOURCE = '''
+kind_status, kind = instance.value_kind(handle)
+if kind_status is not Status.OK:
+    raise KeyError(handle)
+status, value = instance.unbox(handle)
+if status is not Status.OK:
+    raise KeyError(handle)
+if (
+    kind is ValueKind.STRING
+    or kind is ValueKind.BYTES
+    or kind is ValueKind.TUPLE
+    or kind is ValueKind.DICT
+    or kind is ValueKind.LIST
+):
+    return _materialize(value)
+return value
+'''
+
 _HOST_OBJECT_ID_SOURCE = '''
 instance = _runtime(runtime)
 if instance is None:
@@ -46,6 +64,7 @@
 '''
 
 _REPLACEMENTS = {
+    "_slot_value": _SLOT_VALUE_SOURCE,
     "_portapy_value_get_host_id_impl": _HOST_OBJECT_ID_SOURCE,
     "_portapy_value_get_host_callable_id_impl": _HOST_CALLABLE_ID_SOURCE,
 }
@@ -184,6 +203,8 @@ def main() -> int:
     PATH.write_text(source, encoding="utf-8")
     verified = ast.unparse(ast.parse(source))
     required = (
+        "kind_status, kind = instance.value_kind(handle)",
+        "kind is ValueKind.LIST",
         "slot = instance._value_slot(handle)",
         "_native_value_kind_code(kind) != PORTAPY_VALUE_OBJECT",
         "_native_value_kind_code(kind) != PORTAPY_VALUE_CALLABLE",

From 6969a839ecb289e12098ed4d25bbd101915d0517 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:34:39 -0500
Subject: [PATCH 355/450] Keep native parser target expressions boxed

---
 ...full_core_native_parser_target_dispatch.py | 146 ++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 tools/normalize_full_core_native_parser_target_dispatch.py

diff --git a/tools/normalize_full_core_native_parser_target_dispatch.py b/tools/normalize_full_core_native_parser_target_dispatch.py
new file mode 100644
index 00000000..1141f5cd
--- /dev/null
+++ b/tools/normalize_full_core_native_parser_target_dispatch.py
@@ -0,0 +1,146 @@
+"""Keep parsed expression nodes boxed through native target dispatch.
+
+The pinned compiler lowers a ``dict``-annotated local holding an opaque AST node
+as the static dict type token. The preceding one-item list subscript, however,
+is a real runtime load. Remove the unsafe local and use that boxed load for every
+remaining assignment-target check in ``Parser._parse_stmt``.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_BOX_NAME = "__pyinbin_native_expr_values"
+
+
+def _is_box_subscript(node: ast.expr | None) -> bool:
+    return (
+        isinstance(node, ast.Subscript)
+        and isinstance(node.value, ast.Name)
+        and node.value.id == _BOX_NAME
+        and isinstance(node.slice, ast.Constant)
+        and node.slice.value == 0
+    )
+
+
+def _box_subscript() -> ast.Subscript:
+    return ast.Subscript(
+        value=ast.Name(id=_BOX_NAME, ctx=ast.Load()),
+        slice=ast.Constant(value=0),
+        ctx=ast.Load(),
+    )
+
+
+def _parse_stmt_method(module: ast.Module) -> ast.FunctionDef:
+    parser = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.ClassDef) and node.name == "_npr_parser_Parser"
+        ),
+        None,
+    )
+    if parser is None:
+        raise RuntimeError("embedded native Parser class is missing")
+    method = next(
+        (
+            node
+            for node in parser.body
+            if isinstance(node, ast.FunctionDef) and node.name == "_parse_stmt"
+        ),
+        None,
+    )
+    if method is None:
+        raise RuntimeError("embedded native Parser._parse_stmt is missing")
+    return method
+
+
+class _ReplaceExpressionLoads(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        if node.id != "expr" or not isinstance(node.ctx, ast.Load):
+            return node
+        self.count += 1
+        return ast.copy_location(_box_subscript(), node)
+
+
+def _rewrite_method(method: ast.FunctionDef) -> tuple[int, int]:
+    body: list[ast.stmt] = []
+    removed = 0
+    replacements = 0
+    after_restore = False
+
+    for statement in method.body:
+        is_restore = (
+            isinstance(statement, ast.AnnAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.target.id == "expr"
+            and _is_box_subscript(statement.value)
+        )
+        if is_restore:
+            removed += 1
+            after_restore = True
+            continue
+        if after_restore:
+            rewriter = _ReplaceExpressionLoads()
+            statement = rewriter.visit(statement)
+            replacements += rewriter.count
+        body.append(statement)
+
+    method.body = body
+    return removed, replacements
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    method = _parse_stmt_method(module)
+    removed, replacements = _rewrite_method(method)
+    if removed != 1 or replacements < 4:
+        raise RuntimeError(
+            "native parser target dispatch normalization missed shapes; "
+            f"restores={removed}, expression_loads={replacements}"
+        )
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    verified_method = _parse_stmt_method(verified)
+    stale_restores = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "expr"
+        and _is_box_subscript(node.value)
+    ]
+    stale_loads = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Name)
+        and node.id == "expr"
+        and isinstance(node.ctx, ast.Load)
+    ]
+    boxed_loads = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Subscript) and _is_box_subscript(node)
+    ]
+    if stale_restores or stale_loads or len(boxed_loads) < replacements + 1:
+        raise RuntimeError(
+            "native parser target dispatch validation failed; "
+            f"restores={len(stale_restores)}, loads={len(stale_loads)}, "
+            f"boxed={len(boxed_loads)}"
+        )
+
+    print("KEPT NATIVE PARSER TARGET EXPRESSION BOXED", replacements)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From ea27aba2f99c067f59a10576c8bfd824aeec33f3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:35:12 -0500
Subject: [PATCH 356/450] Run boxed parser target dispatch normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 472cc805..ca40839c 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -34,6 +34,7 @@
 from tools.normalize_full_core_native_keyword_transport import main as normalize_native_keyword_transport
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
+from tools.normalize_full_core_native_parser_target_dispatch import main as normalize_native_parser_target_dispatch
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
@@ -168,6 +169,7 @@ def main() -> int:
         ("keyword_calls", normalize_keyword_calls),
         ("combine_native_parser", combine_native_parser),
         ("native_parser_expressions", normalize_native_parser_expressions),
+        ("native_parser_target_dispatch", normalize_native_parser_target_dispatch),
         ("expr_stmt_initializer", normalize_expr_stmt_initializer),
         ("parser_errors", normalize_parser_errors),
         ("boolops", normalize_boolops),

From d56750bb09c597ae7f01e03c690710c772977a8e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:35:25 -0500
Subject: [PATCH 357/450] Test boxed native parser target dispatch

---
 ...full_core_native_parser_target_dispatch.py | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_parser_target_dispatch.py

diff --git a/tests/test_normalize_full_core_native_parser_target_dispatch.py b/tests/test_normalize_full_core_native_parser_target_dispatch.py
new file mode 100644
index 00000000..a72a510d
--- /dev/null
+++ b/tests/test_normalize_full_core_native_parser_target_dispatch.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_native_parser_target_dispatch as normalizer
+
+
+def test_parser_target_dispatch_keeps_expression_in_runtime_box(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    target = tmp_path / "native_ast.py"
+    target.write_text(
+        '''
+class _npr_parser_Parser:
+    def _parse_stmt(self):
+        __pyinbin_native_expr_values: list[dict] = [self._parse_expr()]
+        if self._check("NEWLINE"):
+            return ExprStmt(__pyinbin_native_expr_values[0])
+        expr: dict = __pyinbin_native_expr_values[0]
+        if isinstance(expr, Name):
+            return expr
+        if isinstance(expr, Subscript):
+            return Assign(expr, expr)
+        if isinstance(expr, Attr):
+            return AugAssign(expr)
+        return ExprStmt(expr)
+''',
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", target)
+
+    assert normalizer.main() == 0
+
+    source = target.read_text(encoding="utf-8")
+    assert "expr: dict" not in source
+    assert "isinstance(expr" not in source
+    assert "return expr" not in source
+    assert source.count("__pyinbin_native_expr_values[0]") >= 8

From b4a1beb3cb1247958f1741aa09c9e78b858621e6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:42:12 -0500
Subject: [PATCH 358/450] Preserve native control-flow statement bodies

---
 ...alize_full_core_native_statement_bodies.py | 205 ++++++++++++++++++
 1 file changed, 205 insertions(+)
 create mode 100644 tools/normalize_full_core_native_statement_bodies.py

diff --git a/tools/normalize_full_core_native_statement_bodies.py b/tools/normalize_full_core_native_statement_bodies.py
new file mode 100644
index 00000000..f08d71d8
--- /dev/null
+++ b/tools/normalize_full_core_native_statement_bodies.py
@@ -0,0 +1,205 @@
+"""Preserve native control-flow statement bodies through AST conversion.
+
+``_convert_stmt`` accepts an opaque object. Direct accesses such as ``node.body``
+can therefore lower as null/static type values in the pinned compiler even after
+an ``isinstance`` check. Extract each body list with a typed ``getattr`` load and
+hoist ``_convert_body`` before constructing the final AST statement.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+
+
+def _convert_stmt(module: ast.Module) -> ast.FunctionDef:
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_stmt"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"native statement converter expected one _convert_stmt, found {len(matches)}"
+        )
+    return matches[0]
+
+
+def _branch_type(test: ast.expr) -> str | None:
+    if not (
+        isinstance(test, ast.Call)
+        and isinstance(test.func, ast.Name)
+        and test.func.id == "isinstance"
+        and len(test.args) == 2
+        and isinstance(test.args[0], ast.Name)
+        and test.args[0].id == "node"
+        and isinstance(test.args[1], ast.Name)
+    ):
+        return None
+    return test.args[1].id
+
+
+def _safe_name(value: str) -> str:
+    return re_sub_non_identifier(value).strip("_").lower()
+
+
+def re_sub_non_identifier(value: str) -> str:
+    result = ""
+    for character in value:
+        if character.isalnum() or character == "_":
+            result += character
+        else:
+            result += "_"
+    return result
+
+
+class _BodyCallCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.calls: list[tuple[ast.Call, str]] = []
+
+    def visit_Call(self, node: ast.Call) -> None:
+        if (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "_convert_body"
+            and len(node.args) == 2
+            and isinstance(node.args[0], ast.Attribute)
+            and isinstance(node.args[0].value, ast.Name)
+            and node.args[0].value.id == "node"
+        ):
+            self.calls.append((node, node.args[0].attr))
+        self.generic_visit(node)
+
+
+def _normalize_function(function: ast.FunctionDef) -> int:
+    changed = 0
+    for branch in function.body:
+        if not isinstance(branch, ast.If):
+            continue
+        type_name = _branch_type(branch.test)
+        if type_name is None:
+            continue
+        collector = _BodyCallCollector()
+        for statement in branch.body:
+            collector.visit(statement)
+        if not collector.calls:
+            continue
+
+        prefix = _safe_name(type_name.removeprefix("_npr_ast_nodes_"))
+        fields: list[str] = []
+        for _, field in collector.calls:
+            if field not in fields:
+                fields.append(field)
+
+        declarations: list[ast.stmt] = []
+        converted_names: dict[str, str] = {}
+        for field in fields:
+            raw_name = f"_native_{prefix}_{field}_body"
+            converted_name = f"_native_converted_{prefix}_{field}_body"
+            converted_names[field] = converted_name
+            declarations.extend(
+                ast.parse(
+                    f'''{raw_name}: list[object] = getattr(node, {field!r})
+{converted_name}: list[stmt] = _convert_body({raw_name}, lifted)
+'''
+                ).body
+            )
+
+        for call, field in collector.calls:
+            call.func = ast.copy_location(ast.Name(id="_identity_body", ctx=ast.Load()), call.func)
+            call.args = [
+                ast.copy_location(
+                    ast.Name(id=converted_names[field], ctx=ast.Load()),
+                    call.args[0],
+                )
+            ]
+            call.keywords = []
+
+        branch.body = [*declarations, *branch.body]
+        changed += len(collector.calls)
+    return changed
+
+
+def _install_identity_helper(module: ast.Module) -> int:
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == "_identity_body"
+        for node in module.body
+    ):
+        return 0
+    converter_index = next(
+        index
+        for index, node in enumerate(module.body)
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_stmt"
+    )
+    helper = ast.parse(
+        '''def _identity_body(body: list[stmt]) -> list[stmt]:
+    return body
+
+'''
+    ).body[0]
+    module.body.insert(converter_index, helper)
+    return 1
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    function = _convert_stmt(module)
+    changed = _normalize_function(function)
+    helper = _install_identity_helper(module)
+    if changed != 11 or helper != 1:
+        raise RuntimeError(
+            "native statement body normalization missed shapes; "
+            f"body_calls={changed}, helper={helper}"
+        )
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    verified_function = _convert_stmt(verified)
+    unsafe = [
+        node
+        for node in ast.walk(verified_function)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_convert_body"
+        and node.args
+        and isinstance(node.args[0], ast.Attribute)
+        and isinstance(node.args[0].value, ast.Name)
+        and node.args[0].value.id == "node"
+    ]
+    typed_loads = [
+        node
+        for node in ast.walk(verified_function)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.annotation, ast.Subscript)
+        and isinstance(node.annotation.value, ast.Name)
+        and node.annotation.value.id == "list"
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name)
+        and node.value.func.id == "getattr"
+    ]
+    converted = [
+        node
+        for node in ast.walk(verified_function)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id.startswith("_native_converted_")
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name)
+        and node.value.func.id == "_convert_body"
+    ]
+    if unsafe or len(typed_loads) != 11 or len(converted) != 11:
+        raise RuntimeError(
+            "native statement body validation failed; "
+            f"unsafe={len(unsafe)}, typed={len(typed_loads)}, converted={len(converted)}"
+        )
+
+    print("NORMALIZED NATIVE STATEMENT BODY LOADS", changed)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From f8cebe1af62893a31c32d5d7499e80e2f8938593 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:42:58 -0500
Subject: [PATCH 359/450] Replace native statement body calls with hoisted
 values

---
 ...alize_full_core_native_statement_bodies.py | 86 ++++++++++---------
 1 file changed, 44 insertions(+), 42 deletions(-)

diff --git a/tools/normalize_full_core_native_statement_bodies.py b/tools/normalize_full_core_native_statement_bodies.py
index f08d71d8..54ea4c7b 100644
--- a/tools/normalize_full_core_native_statement_bodies.py
+++ b/tools/normalize_full_core_native_statement_bodies.py
@@ -42,17 +42,13 @@ def _branch_type(test: ast.expr) -> str | None:
 
 
 def _safe_name(value: str) -> str:
-    return re_sub_non_identifier(value).strip("_").lower()
-
-
-def re_sub_non_identifier(value: str) -> str:
     result = ""
     for character in value:
         if character.isalnum() or character == "_":
             result += character
         else:
             result += "_"
-    return result
+    return result.strip("_").lower()
 
 
 class _BodyCallCollector(ast.NodeVisitor):
@@ -72,6 +68,22 @@ def visit_Call(self, node: ast.Call) -> None:
         self.generic_visit(node)
 
 
+class _ReplaceBodyCalls(ast.NodeTransformer):
+    def __init__(self, replacements: dict[int, str]) -> None:
+        self.replacements = replacements
+        self.changed = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        replacement = self.replacements.get(id(node))
+        if replacement is not None:
+            self.changed += 1
+            return ast.copy_location(
+                ast.Name(id=replacement, ctx=ast.Load()),
+                node,
+            )
+        return self.generic_visit(node)
+
+
 def _normalize_function(function: ast.FunctionDef) -> int:
     changed = 0
     for branch in function.body:
@@ -106,51 +118,30 @@ def _normalize_function(function: ast.FunctionDef) -> int:
                 ).body
             )
 
-        for call, field in collector.calls:
-            call.func = ast.copy_location(ast.Name(id="_identity_body", ctx=ast.Load()), call.func)
-            call.args = [
-                ast.copy_location(
-                    ast.Name(id=converted_names[field], ctx=ast.Load()),
-                    call.args[0],
-                )
-            ]
-            call.keywords = []
-
-        branch.body = [*declarations, *branch.body]
-        changed += len(collector.calls)
+        replacements = {
+            id(call): converted_names[field]
+            for call, field in collector.calls
+        }
+        rewriter = _ReplaceBodyCalls(replacements)
+        original_body = [rewriter.visit(statement) for statement in branch.body]
+        if rewriter.changed != len(collector.calls):
+            raise RuntimeError(
+                f"native {prefix} body call replacement expected {len(collector.calls)}, "
+                f"found {rewriter.changed}"
+            )
+        branch.body = [*declarations, *original_body]
+        changed += rewriter.changed
     return changed
 
 
-def _install_identity_helper(module: ast.Module) -> int:
-    if any(
-        isinstance(node, ast.FunctionDef) and node.name == "_identity_body"
-        for node in module.body
-    ):
-        return 0
-    converter_index = next(
-        index
-        for index, node in enumerate(module.body)
-        if isinstance(node, ast.FunctionDef) and node.name == "_convert_stmt"
-    )
-    helper = ast.parse(
-        '''def _identity_body(body: list[stmt]) -> list[stmt]:
-    return body
-
-'''
-    ).body[0]
-    module.body.insert(converter_index, helper)
-    return 1
-
-
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     function = _convert_stmt(module)
     changed = _normalize_function(function)
-    helper = _install_identity_helper(module)
-    if changed != 11 or helper != 1:
+    if changed != 11:
         raise RuntimeError(
             "native statement body normalization missed shapes; "
-            f"body_calls={changed}, helper={helper}"
+            f"body_calls={changed}"
         )
 
     ast.fix_missing_locations(module)
@@ -191,10 +182,21 @@ def main() -> int:
         and isinstance(node.value.func, ast.Name)
         and node.value.func.id == "_convert_body"
     ]
+    nested_body_calls = [
+        node
+        for node in ast.walk(verified_function)
+        if isinstance(node, ast.Call)
+        and not (
+            isinstance(getattr(node, "parent", None), ast.AnnAssign)
+        )
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "_convert_body"
+    ]
     if unsafe or len(typed_loads) != 11 or len(converted) != 11:
         raise RuntimeError(
             "native statement body validation failed; "
-            f"unsafe={len(unsafe)}, typed={len(typed_loads)}, converted={len(converted)}"
+            f"unsafe={len(unsafe)}, typed={len(typed_loads)}, converted={len(converted)}, "
+            f"calls={len(nested_body_calls)}"
         )
 
     print("NORMALIZED NATIVE STATEMENT BODY LOADS", changed)

From 8cfb7d97aa00e2c37289f132e1a169e2a564ffa7 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:43:51 -0500
Subject: [PATCH 360/450] Run native statement body normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index ca40839c..43a5215c 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -36,6 +36,7 @@
 from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
 from tools.normalize_full_core_native_parser_target_dispatch import main as normalize_native_parser_target_dispatch
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
+from tools.normalize_full_core_native_statement_bodies import main as normalize_native_statement_bodies
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
@@ -176,6 +177,7 @@ def main() -> int:
         ("closures", normalize_closures),
         ("pattern_slices", normalize_pattern_slices),
         ("extended_semantics", normalize_extended_semantics),
+        ("native_statement_bodies", normalize_native_statement_bodies),
         ("pop_top", normalize_pop_top),
         ("make_function", normalize_make_function),
         ("collections", normalize_collections),

From be74e7dc540fa571171c160faa12d26ad2a02e39 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:44:05 -0500
Subject: [PATCH 361/450] Test native control-flow body normalization

---
 ...alize_full_core_native_statement_bodies.py | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_statement_bodies.py

diff --git a/tests/test_normalize_full_core_native_statement_bodies.py b/tests/test_normalize_full_core_native_statement_bodies.py
new file mode 100644
index 00000000..7ae2eb43
--- /dev/null
+++ b/tests/test_normalize_full_core_native_statement_bodies.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import ast
+
+from tools import normalize_full_core_native_statement_bodies as normalizer
+
+
+def test_control_flow_bodies_are_loaded_and_converted_before_construction() -> None:
+    module = ast.parse(
+        '''
+def _convert_stmt(node: object, lifted: dict):
+    if isinstance(node, NativeFor):
+        return For(target, iterator, _convert_body(node.body, lifted), _convert_body(node.orelse, lifted))
+    return None
+'''
+    )
+    function = normalizer._convert_stmt(module)
+
+    assert normalizer._normalize_function(function) == 2
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module)
+    assert "_native_for_body_body: list[object] = getattr(node, 'body')" in source
+    assert "_native_for_orelse_body: list[object] = getattr(node, 'orelse')" in source
+    assert "_native_converted_for_body_body: list[stmt] = _convert_body(" in source
+    assert "_native_converted_for_orelse_body: list[stmt] = _convert_body(" in source
+    assert "_convert_body(node.body" not in source
+    assert "_convert_body(node.orelse" not in source
+    assert "For(target, iterator, _native_converted_for_body_body, _native_converted_for_orelse_body)" in source

From 084f7c1895aa4b821cd2777a0585ddccbbf366a0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 17:45:48 -0500
Subject: [PATCH 362/450] Fix native statement body test fixture

---
 tests/test_normalize_full_core_native_statement_bodies.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_core_native_statement_bodies.py b/tests/test_normalize_full_core_native_statement_bodies.py
index 7ae2eb43..cca1f47c 100644
--- a/tests/test_normalize_full_core_native_statement_bodies.py
+++ b/tests/test_normalize_full_core_native_statement_bodies.py
@@ -9,7 +9,7 @@ def test_control_flow_bodies_are_loaded_and_converted_before_construction() -> N
     module = ast.parse(
         '''
 def _convert_stmt(node: object, lifted: dict):
-    if isinstance(node, NativeFor):
+    if isinstance(node, _npr_ast_nodes_For):
         return For(target, iterator, _convert_body(node.body, lifted), _convert_body(node.orelse, lifted))
     return None
 '''

From aea76d7cfab0d91fb2b0b45473961a4e76e4820d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:03:19 -0500
Subject: [PATCH 363/450] Align generated ELF call stacks

---
 tools/elf_pic.py | 392 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 371 insertions(+), 21 deletions(-)

diff --git a/tools/elf_pic.py b/tools/elf_pic.py
index 34a6c8cc..2f48a9de 100644
--- a/tools/elf_pic.py
+++ b/tools/elf_pic.py
@@ -1,18 +1,27 @@
-"""Rewrite asmpython legacy NASM output into ELF shared-library-safe PIC.
+"""Rewrite asmpython legacy NASM output for safe ELF shared libraries.
 
-This is build/ABI glue only. It does not implement any PortaPy interpreter
-semantics. The pass is intentionally narrow and fails on unsupported references
-rather than producing a library with text relocations.
+The legacy backend emits direct external references and follows Win64's more
+permissive call-stack behavior. ELF shared libraries need PLT/GOT references,
+and System V AMD64 requires ``rsp`` to be 16-byte aligned immediately before
+``call``. This build-only pass fixes both properties and fails closed when the
+control-flow analysis cannot prove a call's alignment.
 """
 from __future__ import annotations
 
 import argparse
-import re
+from collections import defaultdict, deque
+from dataclasses import dataclass
 from pathlib import Path
+import re
 
 
 _EXTERN_DATA = {"stdin", "stdout", "stderr", "environ"}
-_CALL_RE = re.compile(r"^(?P<indent>\s*)(?P<op>call|jmp)\s+(?P<symbol>[A-Za-z_.$?][\w.$?@]*)\s*$")
+_NORETURN_CALLS = {"abort", "exit", "_exit", "longjmp", "_runtime_longjmp"}
+_DIRECT_TRANSFER_RE = re.compile(
+    r"^(?P<indent>\s*)(?P<op>call|jmp)\s+"
+    r"(?P<symbol>[A-Za-z_.$?][\w.$?@]*)\s*$"
+)
+_CALL_RE = re.compile(r"^(?P<indent>\s*)call\s+(?P<target>.+?)\s*$")
 _DATA_LOAD_RE = re.compile(
     r"^(?P<indent>\s*)mov\s+(?P<register>[A-Za-z][A-Za-z0-9]*),\s*"
     r"\[(?:rel\s+)?(?P<symbol>[A-Za-z_.$?][\w.$?@]*)\]\s*$"
@@ -20,12 +29,36 @@
 _EXTERNAL_MEMORY_RE = re.compile(
     r"\[(?:rel\s+)?(?P<symbol>[A-Za-z_.$?][\w.$?@]*)[^\]]*\]"
 )
+_STACK_ADJUST_RE = re.compile(
+    r"^(?P<indent>\s*)(?P<op>add|sub)\s+rsp,\s*"
+    r"(?P<amount>0x[0-9A-Fa-f]+|\d+)\s*$"
+)
+_LABEL_RE = re.compile(r"^(?P<label>[A-Za-z_.$?][\w.$?@]*):$")
+_TOP_LEVEL_LABEL_RE = re.compile(r"^[A-Za-z_$?][\w.$?@]*:$")
+_JUMP_RE = re.compile(
+    r"^(?P<op>j[a-z]+|loop(?:e|ne)?)\s+"
+    r"(?:(?:short|near)\s+)?(?P<target>[A-Za-z_.$?][\w.$?@]*)$"
+)
+_ALIGN_RSP_RE = re.compile(r"^and\s+rsp,\s*(?:-16|0xfffffffffffffff0)$")
+_RSP_WRITE_RE = re.compile(r"^(?:mov|lea|xchg)\s+rsp\s*,")
+_RBP_WRITE_RE = re.compile(r"^mov\s+rbp\s*,")
+
+
+@dataclass(frozen=True)
+class _Function:
+    name: str
+    start: int
+    end: int
+
+
+def _code(raw: str) -> str:
+    return raw.split(";", 1)[0].strip()
 
 
 def _extern_symbols(lines: list[str]) -> set[str]:
     symbols: set[str] = set()
     for raw in lines:
-        stripped = raw.strip()
+        stripped = _code(raw)
         if not stripped.startswith("extern "):
             continue
         payload = stripped.split(None, 1)[1]
@@ -34,23 +67,24 @@ def _extern_symbols(lines: list[str]) -> set[str]:
     return symbols
 
 
-def make_elf_pic(source: str) -> str:
+def _rewrite_external_references(source: str) -> str:
     lines = source.splitlines()
     externs = _extern_symbols(lines)
     output: list[str] = []
 
     for line_number, raw in enumerate(lines, start=1):
-        call_match = _CALL_RE.match(raw)
-        if call_match is not None:
-            symbol = call_match.group("symbol")
+        code = _code(raw)
+        transfer_match = _DIRECT_TRANSFER_RE.match(code)
+        if transfer_match is not None:
+            symbol = transfer_match.group("symbol")
             if symbol in externs:
                 output.append(
-                    f'{call_match.group("indent")}{call_match.group("op")} '
-                    f'{symbol} wrt ..plt'
+                    f'{transfer_match.group("indent")}{transfer_match.group("op")} '
+                    f"{symbol} wrt ..plt"
                 )
                 continue
 
-        data_match = _DATA_LOAD_RE.match(raw)
+        data_match = _DATA_LOAD_RE.match(code)
         if data_match is not None:
             symbol = data_match.group("symbol")
             if symbol in externs and symbol in _EXTERN_DATA:
@@ -60,29 +94,345 @@ def make_elf_pic(source: str) -> str:
                 output.append(f"{indent}mov {register}, [{register}]")
                 continue
 
-        for memory_match in _EXTERNAL_MEMORY_RE.finditer(raw):
+        for memory_match in _EXTERNAL_MEMORY_RE.finditer(code):
             symbol = memory_match.group("symbol")
-            if symbol in externs:
+            if symbol in externs and "wrt ..got" not in memory_match.group(0):
                 raise ValueError(
                     f"line {line_number}: unsupported external memory reference "
-                    f"to {symbol!r}: {raw.strip()}"
+                    f"to {symbol!r}: {code}"
                 )
 
         output.append(raw)
 
-    if not any(line.strip() == 'section .note.GNU-stack noalloc noexec nowrite progbits' for line in output):
-        output.extend(["", "section .note.GNU-stack noalloc noexec nowrite progbits"])
     return "\n".join(output) + "\n"
 
 
+def _text_functions(lines: list[str]) -> list[_Function]:
+    functions: list[_Function] = []
+    in_text = False
+    current_name: str | None = None
+    current_start = 0
+
+    for index, raw in enumerate(lines):
+        code = _code(raw)
+        if code.startswith("section "):
+            if current_name is not None:
+                functions.append(_Function(current_name, current_start, index))
+                current_name = None
+            section = code.split(None, 1)[1].split()[0]
+            in_text = section == ".text" or section.startswith(".text.")
+            continue
+
+        if (
+            in_text
+            and raw
+            and not raw[0].isspace()
+            and _TOP_LEVEL_LABEL_RE.fullmatch(code)
+        ):
+            if current_name is not None:
+                functions.append(_Function(current_name, current_start, index))
+            current_name = code[:-1]
+            current_start = index
+
+    if current_name is not None:
+        functions.append(_Function(current_name, current_start, len(lines)))
+    return functions
+
+
+def _stack_adjust(code: str) -> tuple[str, int] | None:
+    match = _STACK_ADJUST_RE.match(code)
+    if match is None:
+        return None
+    return match.group("op"), int(match.group("amount"), 0)
+
+
+def _call_target(code: str) -> str | None:
+    match = _CALL_RE.match(code)
+    if match is None:
+        return None
+    return match.group("target").split()[0]
+
+
+def _transfer_stack(
+    code: str,
+    state: tuple[int, int | None],
+    *,
+    line_number: int,
+) -> tuple[int, int | None] | None:
+    rsp, rbp = state
+
+    if code == "mov rbp, rsp":
+        rbp = rsp
+    elif _RBP_WRITE_RE.match(code):
+        rbp = None
+    elif code == "mov rsp, rbp":
+        if rbp is None:
+            raise ValueError(
+                f"line {line_number}: rsp restored before rbp alignment is known"
+            )
+        rsp = rbp
+    elif code == "leave":
+        if rbp is None:
+            raise ValueError(
+                f"line {line_number}: leave executed before rbp alignment is known"
+            )
+        rsp = (rbp + 8) % 16
+        rbp = None
+    elif code.startswith("push "):
+        rsp = (rsp - 8) % 16
+    elif code.startswith("pop "):
+        rsp = (rsp + 8) % 16
+        if code == "pop rbp":
+            rbp = None
+    else:
+        adjustment = _stack_adjust(code)
+        if adjustment is not None:
+            operation, amount = adjustment
+            if operation == "sub":
+                rsp = (rsp - amount) % 16
+            else:
+                rsp = (rsp + amount) % 16
+        elif _ALIGN_RSP_RE.fullmatch(code):
+            rsp = 0
+        elif _RSP_WRITE_RE.match(code):
+            # The generated longjmp helper restores an opaque saved stack and then
+            # transfers control without another call. Stop following that path;
+            # any reachable call behind an opaque rsp write must be rejected by a
+            # separate top-level entry instead of guessed here.
+            return None
+        elif code.startswith("enter ") or code.startswith(("pushf", "popf")):
+            raise ValueError(
+                f"line {line_number}: unsupported stack instruction: {code}"
+            )
+
+    return rsp, rbp
+
+
+def _analyze_call_stacks(lines: list[str]) -> dict[int, set[int]]:
+    call_states: dict[int, set[int]] = defaultdict(set)
+
+    for function in _text_functions(lines):
+        labels: dict[str, int] = {}
+        for index in range(function.start, function.end):
+            label_match = _LABEL_RE.fullmatch(_code(lines[index]))
+            if label_match is not None:
+                labels[label_match.group("label")] = index
+
+        entry = function.start + 1
+        if entry >= function.end:
+            continue
+
+        states: dict[int, set[tuple[int, int | None]]] = defaultdict(set)
+        states[entry].add((8, None))
+        pending: deque[int] = deque([entry])
+
+        while pending:
+            index = pending.popleft()
+            code = _code(lines[index])
+            for state in tuple(states[index]):
+                next_state = _transfer_stack(
+                    code,
+                    state,
+                    line_number=index + 1,
+                )
+                if next_state is None:
+                    continue
+
+                call_target = _call_target(code)
+                if call_target is not None:
+                    call_states[index].add(next_state[0])
+
+                successors: list[int] = []
+                if code.startswith("ret") or code in {"hlt", "ud2"}:
+                    pass
+                else:
+                    jump_match = _JUMP_RE.fullmatch(code)
+                    if jump_match is not None:
+                        jump_target = jump_match.group("target")
+                        target_index = labels.get(jump_target)
+                        if target_index is not None:
+                            successors.append(target_index)
+                        if jump_match.group("op") != "jmp":
+                            successors.append(index + 1)
+                    elif code.startswith("jmp "):
+                        # An indirect or cross-function tail transfer has no local
+                        # fallthrough edge.
+                        pass
+                    elif call_target in _NORETURN_CALLS:
+                        pass
+                    else:
+                        successors.append(index + 1)
+
+                for successor in successors:
+                    if successor >= function.end:
+                        continue
+                    if next_state not in states[successor]:
+                        states[successor].add(next_state)
+                        pending.append(successor)
+
+    return call_states
+
+
+def _next_instruction(lines: list[str], start: int, end: int) -> int | None:
+    for index in range(start, end):
+        code = _code(lines[index])
+        if code:
+            return index
+    return None
+
+
+def _function_containing(functions: list[_Function], index: int) -> _Function:
+    for function in functions:
+        if function.start <= index < function.end:
+            return function
+    raise ValueError(f"line {index + 1}: call is outside a recognized text function")
+
+
+def _find_stack_argument_reservation(
+    lines: list[str],
+    *,
+    call_index: int,
+    cleanup_amount: int,
+    function_start: int,
+) -> int | None:
+    for index in range(call_index - 1, function_start, -1):
+        code = _code(lines[index])
+        if not code:
+            continue
+        if _CALL_RE.match(code) or code.endswith(":"):
+            return None
+        adjustment = _stack_adjust(code)
+        if adjustment == ("sub", cleanup_amount):
+            return index
+        if (
+            adjustment is not None
+            or code.startswith(("push ", "pop ", "leave"))
+            or _RSP_WRITE_RE.match(code)
+        ):
+            return None
+    return None
+
+
+def _rewrite_stack_adjustment(raw: str, amount: int) -> str:
+    code = _code(raw)
+    match = _STACK_ADJUST_RE.match(code)
+    if match is None:
+        raise AssertionError(raw)
+    suffix = ""
+    if ";" in raw:
+        suffix = " ;" + raw.split(";", 1)[1]
+    return f'{match.group("indent")}{match.group("op")} rsp, {amount}{suffix}'
+
+
+def _align_elf_calls(source: str) -> tuple[str, int, int]:
+    lines = source.splitlines()
+    functions = _text_functions(lines)
+    call_states = _analyze_call_stacks(lines)
+
+    for index, states in call_states.items():
+        if len(states) > 1:
+            raise ValueError(
+                f"line {index + 1}: ambiguous stack alignment {sorted(states)} "
+                f"before {_code(lines[index])!r}"
+            )
+        if not states <= {0, 8}:
+            raise ValueError(
+                f"line {index + 1}: invalid stack alignment {sorted(states)}"
+            )
+
+    misaligned = [index for index, states in call_states.items() if states == {8}]
+    insert_before: dict[int, list[str]] = defaultdict(list)
+    insert_after: dict[int, list[str]] = defaultdict(list)
+    replacements: dict[int, str] = {}
+    stack_argument_blocks = 0
+
+    for call_index in misaligned:
+        function = _function_containing(functions, call_index)
+        cleanup_index = _next_instruction(
+            lines,
+            call_index + 1,
+            function.end,
+        )
+        cleanup = (
+            _stack_adjust(_code(lines[cleanup_index]))
+            if cleanup_index is not None
+            else None
+        )
+        reservation_index: int | None = None
+        if cleanup is not None and cleanup[0] == "add":
+            reservation_index = _find_stack_argument_reservation(
+                lines,
+                call_index=call_index,
+                cleanup_amount=cleanup[1],
+                function_start=function.start,
+            )
+
+        if reservation_index is not None and cleanup_index is not None:
+            new_amount = cleanup[1] + 8
+            for index in (reservation_index, cleanup_index):
+                replacement = _rewrite_stack_adjustment(lines[index], new_amount)
+                existing = replacements.get(index)
+                if existing is not None and existing != replacement:
+                    raise ValueError(
+                        f"line {index + 1}: conflicting stack-argument rewrite"
+                    )
+                replacements[index] = replacement
+            stack_argument_blocks += 1
+            continue
+
+        indent = lines[call_index][
+            : len(lines[call_index]) - len(lines[call_index].lstrip())
+        ]
+        insert_before[call_index].append(f"{indent}sub rsp, 8")
+        insert_after[call_index].append(f"{indent}add rsp, 8")
+
+    output: list[str] = []
+    for index, raw in enumerate(lines):
+        output.extend(insert_before[index])
+        output.append(replacements.get(index, raw))
+        output.extend(insert_after[index])
+
+    remaining = {
+        index: states
+        for index, states in _analyze_call_stacks(output).items()
+        if states != {0}
+    }
+    if remaining:
+        index, states = next(iter(remaining.items()))
+        raise ValueError(
+            f"line {index + 1}: ELF call-stack alignment failed with "
+            f"{sorted(states)} before {_code(output[index])!r}"
+        )
+
+    return "\n".join(output) + "\n", len(misaligned), stack_argument_blocks
+
+
+def make_elf_pic(source: str) -> str:
+    rewritten = _rewrite_external_references(source)
+    rewritten, _, _ = _align_elf_calls(rewritten)
+    lines = rewritten.splitlines()
+    stack_note = "section .note.GNU-stack noalloc noexec nowrite progbits"
+    if not any(_code(line) == stack_note for line in lines):
+        lines.extend(["", stack_note])
+    return "\n".join(lines) + "\n"
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("assembly", type=Path)
     parser.add_argument("-o", "--output", type=Path)
     args = parser.parse_args(argv)
     output = args.output or args.assembly
-    rewritten = make_elf_pic(args.assembly.read_text(encoding="utf-8"))
-    output.write_text(rewritten, encoding="utf-8")
+    source = _rewrite_external_references(
+        args.assembly.read_text(encoding="utf-8")
+    )
+    rewritten, call_count, stack_argument_blocks = _align_elf_calls(source)
+    stack_note = "section .note.GNU-stack noalloc noexec nowrite progbits"
+    lines = rewritten.splitlines()
+    if not any(_code(line) == stack_note for line in lines):
+        lines.extend(["", stack_note])
+    output.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print("ALIGNED ELF CALL STACKS", call_count, stack_argument_blocks)
     return 0
 
 

From 9abe4a3d2d5585765c741c119797856e56cf0c9e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:03:43 -0500
Subject: [PATCH 364/450] Test generated ELF stack alignment

---
 tests/test_elf_pic.py | 99 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/tests/test_elf_pic.py b/tests/test_elf_pic.py
index afe58c5e..718618e5 100644
--- a/tests/test_elf_pic.py
+++ b/tests/test_elf_pic.py
@@ -22,6 +22,7 @@ def test_external_calls_use_plt_and_data_uses_got() -> None:
     assert "mov rdx, [rel stdin wrt ..got]" in rewritten
     assert "mov rdx, [rdx]" in rewritten
     assert "section .note.GNU-stack noalloc noexec nowrite progbits" in rewritten
+    assert make_elf_pic(rewritten) == rewritten
 
 
 def test_local_calls_are_unchanged() -> None:
@@ -40,6 +41,104 @@ def test_local_calls_are_unchanged() -> None:
     assert "call local_helper wrt ..plt" not in rewritten
 
 
+def test_transient_push_is_aligned_around_call() -> None:
+    source = """\
+BITS 64
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    push rax
+    call helper
+    pop rax
+    leave
+    ret
+helper:
+    ret
+"""
+    rewritten = make_elf_pic(source)
+    assert (
+        "    push rax\n"
+        "    sub rsp, 8\n"
+        "    call helper\n"
+        "    add rsp, 8\n"
+        "    pop rax"
+    ) in rewritten
+
+
+def test_stack_argument_reservation_absorbs_alignment_padding() -> None:
+    source = """\
+BITS 64
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    push rax
+    sub rsp, 16
+    mov qword [rsp+0], 1
+    mov qword [rsp+8], 2
+    call helper
+    add rsp, 16
+    pop rax
+    leave
+    ret
+helper:
+    ret
+"""
+    rewritten = make_elf_pic(source)
+    assert "sub rsp, 24" in rewritten
+    assert "add rsp, 24" in rewritten
+    assert "sub rsp, 8\n    call helper" not in rewritten
+
+
+def test_branch_alternatives_keep_aligned_calls_unchanged() -> None:
+    source = """\
+BITS 64
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    test rax, rax
+    jz .alternate
+    call first
+    leave
+    ret
+.alternate:
+    call second
+    leave
+    ret
+first:
+    ret
+second:
+    ret
+"""
+    rewritten = make_elf_pic(source)
+    assert "sub rsp, 8" not in rewritten
+    assert "call first" in rewritten
+    assert "call second" in rewritten
+
+
+def test_ambiguous_stack_alignment_fails_closed() -> None:
+    source = """\
+BITS 64
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    test rax, rax
+    jz .joined
+    push rax
+.joined:
+    call helper
+    leave
+    ret
+helper:
+    ret
+"""
+    with pytest.raises(ValueError, match="ambiguous stack alignment"):
+        make_elf_pic(source)
+
+
 def test_unknown_external_memory_reference_fails_closed() -> None:
     source = """\
 BITS 64

From d154bf9b67e6e28c0f917668bc07d79dca26d384 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:13:29 -0500
Subject: [PATCH 365/450] Preserve native attribute target fields

---
 ...full_core_native_parser_target_dispatch.py | 111 +++++++++++++++++-
 1 file changed, 106 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_core_native_parser_target_dispatch.py b/tools/normalize_full_core_native_parser_target_dispatch.py
index 1141f5cd..2e3f036f 100644
--- a/tools/normalize_full_core_native_parser_target_dispatch.py
+++ b/tools/normalize_full_core_native_parser_target_dispatch.py
@@ -3,7 +3,9 @@
 The pinned compiler lowers a ``dict``-annotated local holding an opaque AST node
 as the static dict type token. The preceding one-item list subscript, however,
 is a real runtime load. Remove the unsafe local and use that boxed load for every
-remaining assignment-target check in ``Parser._parse_stmt``.
+remaining assignment-target check in ``Parser._parse_stmt``. Attribute targets
+also need their ``obj`` and ``name`` fields loaded into typed runtime boxes before
+constructing assignment nodes; direct opaque-field access otherwise becomes null.
 """
 from __future__ import annotations
 
@@ -95,14 +97,83 @@ def _rewrite_method(method: ast.FunctionDef) -> tuple[int, int]:
     return removed, replacements
 
 
+def _is_attribute_target_test(statement: ast.If) -> bool:
+    for node in ast.walk(statement.test):
+        if not (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Name)
+            and node.func.id == "isinstance"
+            and len(node.args) == 2
+            and _is_box_subscript(node.args[0])
+            and isinstance(node.args[1], ast.Name)
+        ):
+            continue
+        type_name = node.args[1].id
+        if type_name == "Attr" or type_name.endswith("_Attr"):
+            return True
+    return False
+
+
+class _ReplaceAttributeTargetFields(ast.NodeTransformer):
+    def __init__(self, suffix: int) -> None:
+        self.suffix = suffix
+        self.count = 0
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        self.generic_visit(node)
+        if not _is_box_subscript(node.value) or node.attr not in {"obj", "name"}:
+            return node
+        self.count += 1
+        box_name = f"_native_attr_{node.attr}_values_{self.suffix}"
+        return ast.copy_location(
+            ast.Subscript(
+                value=ast.Name(id=box_name, ctx=ast.Load()),
+                slice=ast.Constant(value=0),
+                ctx=ast.Load(),
+            ),
+            node,
+        )
+
+
+def _normalize_attribute_target_fields(method: ast.FunctionDef) -> tuple[int, int]:
+    branches = 0
+    replacements = 0
+    for statement in method.body:
+        if not isinstance(statement, ast.If) or not _is_attribute_target_test(statement):
+            continue
+
+        rewriter = _ReplaceAttributeTargetFields(branches)
+        rewritten_body = [rewriter.visit(item) for item in statement.body]
+        if rewriter.count == 0:
+            continue
+
+        loads = ast.parse(
+            f'''_native_attr_obj_values_{branches}: list[dict] = [getattr({_BOX_NAME}[0], "obj")]
+_native_attr_name_values_{branches}: list[str] = [getattr({_BOX_NAME}[0], "name")]
+'''
+        ).body
+        statement.body = [*loads, *rewritten_body]
+        replacements += rewriter.count
+        branches += 1
+
+    return branches, replacements
+
+
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     method = _parse_stmt_method(module)
     removed, replacements = _rewrite_method(method)
-    if removed != 1 or replacements < 4:
+    attr_branches, attr_fields = _normalize_attribute_target_fields(method)
+    if (
+        removed != 1
+        or replacements < 4
+        or attr_branches < 1
+        or attr_fields < attr_branches * 2
+    ):
         raise RuntimeError(
             "native parser target dispatch normalization missed shapes; "
-            f"restores={removed}, expression_loads={replacements}"
+            f"restores={removed}, expression_loads={replacements}, "
+            f"attribute_branches={attr_branches}, attribute_fields={attr_fields}"
         )
 
     ast.fix_missing_locations(module)
@@ -131,14 +202,44 @@ def main() -> int:
         for node in ast.walk(verified_method)
         if isinstance(node, ast.Subscript) and _is_box_subscript(node)
     ]
-    if stale_restores or stale_loads or len(boxed_loads) < replacements + 1:
+    stale_attr_fields = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.Attribute)
+        and _is_box_subscript(node.value)
+        and node.attr in {"obj", "name"}
+    ]
+    typed_attr_boxes = [
+        node
+        for node in ast.walk(verified_method)
+        if isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and (
+            node.target.id.startswith("_native_attr_obj_values_")
+            or node.target.id.startswith("_native_attr_name_values_")
+        )
+        and isinstance(node.value, ast.List)
+        and len(node.value.elts) == 1
+        and isinstance(node.value.elts[0], ast.Call)
+        and isinstance(node.value.elts[0].func, ast.Name)
+        and node.value.elts[0].func.id == "getattr"
+    ]
+    if (
+        stale_restores
+        or stale_loads
+        or stale_attr_fields
+        or len(boxed_loads) < replacements + 1
+        or len(typed_attr_boxes) != attr_branches * 2
+    ):
         raise RuntimeError(
             "native parser target dispatch validation failed; "
             f"restores={len(stale_restores)}, loads={len(stale_loads)}, "
-            f"boxed={len(boxed_loads)}"
+            f"boxed={len(boxed_loads)}, stale_attr_fields={len(stale_attr_fields)}, "
+            f"typed_attr_boxes={len(typed_attr_boxes)}"
         )
 
     print("KEPT NATIVE PARSER TARGET EXPRESSION BOXED", replacements)
+    print("TYPED NATIVE ATTRIBUTE TARGET FIELDS", attr_fields)
     return 0
 
 

From fbaafbbb845860b29231aa70e6ba48fdb99d5bfb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:13:47 -0500
Subject: [PATCH 366/450] Test native attribute target field preservation

---
 ...ze_full_core_native_parser_target_dispatch.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/tests/test_normalize_full_core_native_parser_target_dispatch.py b/tests/test_normalize_full_core_native_parser_target_dispatch.py
index a72a510d..2ddeaf3c 100644
--- a/tests/test_normalize_full_core_native_parser_target_dispatch.py
+++ b/tests/test_normalize_full_core_native_parser_target_dispatch.py
@@ -22,8 +22,8 @@ def _parse_stmt(self):
             return expr
         if isinstance(expr, Subscript):
             return Assign(expr, expr)
-        if isinstance(expr, Attr):
-            return AugAssign(expr)
+        if isinstance(expr, _npr_ast_nodes_Attr):
+            return AttrAssign(obj=expr.obj, name=expr.name)
         return ExprStmt(expr)
 ''',
         encoding="utf-8",
@@ -37,3 +37,15 @@ def _parse_stmt(self):
     assert "isinstance(expr" not in source
     assert "return expr" not in source
     assert source.count("__pyinbin_native_expr_values[0]") >= 8
+    assert (
+        "_native_attr_obj_values_0: list[dict] = "
+        "[getattr(__pyinbin_native_expr_values[0], 'obj')]"
+    ) in source
+    assert (
+        "_native_attr_name_values_0: list[str] = "
+        "[getattr(__pyinbin_native_expr_values[0], 'name')]"
+    ) in source
+    assert "__pyinbin_native_expr_values[0].obj" not in source
+    assert "__pyinbin_native_expr_values[0].name" not in source
+    assert "obj=_native_attr_obj_values_0[0]" in source
+    assert "name=_native_attr_name_values_0[0]" in source

From a71e6169f78c9498ec6c0df38d960632d991690f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:15:51 -0500
Subject: [PATCH 367/450] Fix native target dispatch validation invariant

---
 tools/normalize_full_core_native_parser_target_dispatch.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_native_parser_target_dispatch.py b/tools/normalize_full_core_native_parser_target_dispatch.py
index 2e3f036f..2c761469 100644
--- a/tools/normalize_full_core_native_parser_target_dispatch.py
+++ b/tools/normalize_full_core_native_parser_target_dispatch.py
@@ -228,7 +228,7 @@ def main() -> int:
         stale_restores
         or stale_loads
         or stale_attr_fields
-        or len(boxed_loads) < replacements + 1
+        or not boxed_loads
         or len(typed_attr_boxes) != attr_branches * 2
     ):
         raise RuntimeError(

From 8e42ad3e905fcf8b671cd4b0741090331d937710 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:17:03 -0500
Subject: [PATCH 368/450] Restore native exception handlers on return

---
 tools/nasm_exception_handlers.py | 242 +++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)
 create mode 100644 tools/nasm_exception_handlers.py

diff --git a/tools/nasm_exception_handlers.py b/tools/nasm_exception_handlers.py
new file mode 100644
index 00000000..c7d27207
--- /dev/null
+++ b/tools/nasm_exception_handlers.py
@@ -0,0 +1,242 @@
+"""Restore generated exception-handler chains on every function return.
+
+The legacy backend lowers ``try`` through a global ``_runtime_handler_top``
+stack of hand-rolled setjmp buffers. Normal fallthrough restores the parent,
+but an early ``return`` jumps straight to the function epilogue. That leaves
+the global handler pointing into a dead frame; once the stack is reused, the
+next raise restores arbitrary locals as RSP/RIP.
+
+This post-pass adds a no-call epilogue guard to every function that installs a
+handler. It preserves RAX/XMM0 return values and peels all still-active local
+handlers from inner to outer before the frame is destroyed.
+"""
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+
+_HANDLER_LOAD = "mov rax, [rel _runtime_handler_top]"
+_HANDLER_STORE = "mov [rel _runtime_handler_top], rax"
+_SETJMP_CALL = "call _runtime_setjmp"
+_MARKER = "; portapy: restore active exception handlers before return"
+_TOP_LEVEL_LABEL_RE = re.compile(r"^[A-Za-z_$?][\w.$?@]*:$")
+_LEA_RAX_LOCAL_RE = re.compile(r"^lea rax, \[rbp-(?P<offset>\d+)\]$")
+_STORE_RAX_LOCAL_RE = re.compile(r"^mov \[rbp-(?P<offset>\d+)\], rax$")
+
+
+@dataclass(frozen=True)
+class _Function:
+    name: str
+    start: int
+    end: int
+
+
+@dataclass(frozen=True)
+class _Handler:
+    buffer_offset: int
+    parent_offset: int
+
+
+def _code(raw: str) -> str:
+    return raw.split(";", 1)[0].strip()
+
+
+def _text_functions(lines: list[str]) -> list[_Function]:
+    functions: list[_Function] = []
+    in_text = False
+    current_name: str | None = None
+    current_start = 0
+
+    for index, raw in enumerate(lines):
+        code = _code(raw)
+        if code.startswith("section "):
+            if current_name is not None:
+                functions.append(_Function(current_name, current_start, index))
+                current_name = None
+            section = code.split(None, 1)[1].split()[0]
+            in_text = section == ".text" or section.startswith(".text.")
+            continue
+        if (
+            in_text
+            and raw
+            and not raw[0].isspace()
+            and _TOP_LEVEL_LABEL_RE.fullmatch(code)
+        ):
+            if current_name is not None:
+                functions.append(_Function(current_name, current_start, index))
+            current_name = code[:-1]
+            current_start = index
+
+    if current_name is not None:
+        functions.append(_Function(current_name, current_start, len(lines)))
+    return functions
+
+
+def _previous_instruction(lines: list[str], index: int, floor: int) -> int | None:
+    for candidate in range(index - 1, floor - 1, -1):
+        if _code(lines[candidate]):
+            return candidate
+    return None
+
+
+def _handler_for_setjmp(
+    lines: list[str],
+    *,
+    call_index: int,
+    function_start: int,
+) -> _Handler:
+    cursor = _previous_instruction(lines, call_index, function_start)
+    if cursor is None:
+        raise ValueError(f"line {call_index + 1}: setjmp has no buffer setup")
+    second_lea = _LEA_RAX_LOCAL_RE.fullmatch(_code(lines[cursor]))
+    if second_lea is None:
+        raise ValueError(
+            f"line {call_index + 1}: setjmp buffer is not loaded from rbp"
+        )
+    buffer_offset = int(second_lea.group("offset"))
+
+    cursor = _previous_instruction(lines, cursor, function_start)
+    if cursor is None or _code(lines[cursor]) != _HANDLER_STORE:
+        raise ValueError(
+            f"line {call_index + 1}: setjmp buffer was not installed globally"
+        )
+
+    cursor = _previous_instruction(lines, cursor, function_start)
+    if cursor is None:
+        raise ValueError(f"line {call_index + 1}: missing handler buffer address")
+    first_lea = _LEA_RAX_LOCAL_RE.fullmatch(_code(lines[cursor]))
+    if first_lea is None or int(first_lea.group("offset")) != buffer_offset:
+        raise ValueError(
+            f"line {call_index + 1}: inconsistent setjmp buffer setup"
+        )
+
+    parent_store_index = _previous_instruction(lines, cursor, function_start)
+    if parent_store_index is None:
+        raise ValueError(f"line {call_index + 1}: missing parent handler save")
+    parent_store = _STORE_RAX_LOCAL_RE.fullmatch(_code(lines[parent_store_index]))
+    if parent_store is None:
+        raise ValueError(
+            f"line {call_index + 1}: parent handler is not saved to rbp storage"
+        )
+
+    parent_load_index = _previous_instruction(
+        lines,
+        parent_store_index,
+        function_start,
+    )
+    if parent_load_index is None or _code(lines[parent_load_index]) != _HANDLER_LOAD:
+        raise ValueError(
+            f"line {call_index + 1}: parent handler save has no global load"
+        )
+
+    return _Handler(
+        buffer_offset=buffer_offset,
+        parent_offset=int(parent_store.group("offset")),
+    )
+
+
+def _handlers_in_function(lines: list[str], function: _Function) -> list[_Handler]:
+    handlers: list[_Handler] = []
+    seen: set[_Handler] = set()
+    for index in range(function.start, function.end):
+        if _code(lines[index]) != _SETJMP_CALL:
+            continue
+        handler = _handler_for_setjmp(
+            lines,
+            call_index=index,
+            function_start=function.start,
+        )
+        if handler not in seen:
+            handlers.append(handler)
+            seen.add(handler)
+    return handlers
+
+
+def _epilogues(lines: list[str], function: _Function) -> list[int]:
+    result: list[int] = []
+    for index in range(function.start, function.end - 1):
+        code = _code(lines[index])
+        next_code = _code(lines[index + 1])
+        if code == "mov rsp, rbp" and next_code == "pop rbp":
+            after = index + 2
+            if after < function.end and _code(lines[after]).startswith("ret"):
+                result.append(index)
+        elif code == "leave" and next_code.startswith("ret"):
+            result.append(index)
+    return result
+
+
+def restore_exception_handler_epilogues(source: str) -> tuple[str, int, int]:
+    lines = source.splitlines()
+    insertions: dict[int, list[str]] = {}
+    function_count = 0
+    epilogue_count = 0
+
+    for function_number, function in enumerate(_text_functions(lines), start=1):
+        handlers = _handlers_in_function(lines, function)
+        if not handlers:
+            continue
+        if any(
+            _MARKER in lines[index]
+            for index in range(function.start, function.end)
+        ):
+            continue
+
+        epilogues = _epilogues(lines, function)
+        if not epilogues:
+            raise ValueError(
+                f"function {function.name!r} installs an exception handler "
+                "but has no recognized frame epilogue"
+            )
+
+        function_count += 1
+        for epilogue_number, epilogue_index in enumerate(epilogues, start=1):
+            indent = lines[epilogue_index][
+                : len(lines[epilogue_index]) - len(lines[epilogue_index].lstrip())
+            ]
+            block = [f"{indent}{_MARKER}"]
+            for handler_number, handler in enumerate(reversed(handlers), start=1):
+                skip_label = (
+                    f".Lportapy_handler_cleanup_{function_number}_"
+                    f"{epilogue_number}_{handler_number}"
+                )
+                block.extend(
+                    [
+                        f"{indent}mov r10, [rel _runtime_handler_top]",
+                        f"{indent}lea r11, [rbp-{handler.buffer_offset}]",
+                        f"{indent}cmp r10, r11",
+                        f"{indent}jne {skip_label}",
+                        f"{indent}mov r10, [rbp-{handler.parent_offset}]",
+                        f"{indent}mov [rel _runtime_handler_top], r10",
+                        f"{skip_label}:",
+                    ]
+                )
+            insertions[epilogue_index] = block
+            epilogue_count += 1
+
+    output: list[str] = []
+    for index, raw in enumerate(lines):
+        output.extend(insertions.get(index, []))
+        output.append(raw)
+    return "\n".join(output) + "\n", function_count, epilogue_count
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("assembly", type=Path)
+    parser.add_argument("-o", "--output", type=Path)
+    args = parser.parse_args(argv)
+    output = args.output or args.assembly
+    rewritten, function_count, epilogue_count = restore_exception_handler_epilogues(
+        args.assembly.read_text(encoding="utf-8")
+    )
+    output.write_text(rewritten, encoding="utf-8")
+    print("RESTORED EXCEPTION HANDLER EPILOGUES", function_count, epilogue_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 389163d9bf3c1a0dd7e3e1069817ba408755edaa Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:17:19 -0500
Subject: [PATCH 369/450] Test native exception handler cleanup

---
 tests/test_nasm_exception_handlers.py | 78 +++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 tests/test_nasm_exception_handlers.py

diff --git a/tests/test_nasm_exception_handlers.py b/tests/test_nasm_exception_handlers.py
new file mode 100644
index 00000000..a36e1bd2
--- /dev/null
+++ b/tests/test_nasm_exception_handlers.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import pytest
+
+from tools.nasm_exception_handlers import restore_exception_handler_epilogues
+
+
+def test_restores_active_handler_without_clobbering_rax() -> None:
+    source = """\
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    sub rsp, 240
+    mov rax, [rel _runtime_handler_top]
+    mov [rbp-208], rax
+    lea rax, [rbp-200]
+    mov [rel _runtime_handler_top], rax
+    lea rax, [rbp-200]
+    call _runtime_setjmp
+    mov rax, 42
+.Lret_probe:
+    mov rsp, rbp
+    pop rbp
+    ret
+"""
+    rewritten, functions, epilogues = restore_exception_handler_epilogues(source)
+    assert (functions, epilogues) == (1, 1)
+    assert "mov r10, [rel _runtime_handler_top]" in rewritten
+    assert "lea r11, [rbp-200]" in rewritten
+    assert "mov r10, [rbp-208]" in rewritten
+    assert "mov [rel _runtime_handler_top], r10" in rewritten
+    assert "mov rax, 42" in rewritten
+    assert restore_exception_handler_epilogues(rewritten)[0] == rewritten
+
+
+def test_nested_handlers_are_peeled_inner_first() -> None:
+    source = """\
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    sub rsp, 448
+    mov rax, [rel _runtime_handler_top]
+    mov [rbp-208], rax
+    lea rax, [rbp-200]
+    mov [rel _runtime_handler_top], rax
+    lea rax, [rbp-200]
+    call _runtime_setjmp
+    mov rax, [rel _runtime_handler_top]
+    mov [rbp-416], rax
+    lea rax, [rbp-408]
+    mov [rel _runtime_handler_top], rax
+    lea rax, [rbp-408]
+    call _runtime_setjmp
+    mov rsp, rbp
+    pop rbp
+    ret
+"""
+    rewritten, _, _ = restore_exception_handler_epilogues(source)
+    assert rewritten.index("lea r11, [rbp-408]") < rewritten.index(
+        "lea r11, [rbp-200]"
+    )
+
+
+def test_malformed_setjmp_setup_fails_closed() -> None:
+    source = """\
+section .text
+probe:
+    push rbp
+    mov rbp, rsp
+    call _runtime_setjmp
+    mov rsp, rbp
+    pop rbp
+    ret
+"""
+    with pytest.raises(ValueError, match="setjmp buffer"):
+        restore_exception_handler_epilogues(source)

From 9da16ff5a1fe9f494e528124e4208c73a24aeaeb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:18:52 -0500
Subject: [PATCH 370/450] Finalize exception handlers during export pass

---
 tools/nasm_exports.py | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/tools/nasm_exports.py b/tools/nasm_exports.py
index fa77527a..fb631570 100644
--- a/tools/nasm_exports.py
+++ b/tools/nasm_exports.py
@@ -1,7 +1,8 @@
-"""Declare an explicit public-symbol allowlist in generated NASM source.
+"""Finalize generated NASM source and declare its public-symbol allowlist.
 
-This is build/ABI glue. It never changes function bodies or interpreter
-semantics. Requested symbols and alias targets must exist or the pass fails.
+This build/ABI pass validates exports and aliases, then repairs generated
+exception-handler epilogues before assembly. Requested symbols and alias
+targets must exist or the pass fails closed.
 """
 from __future__ import annotations
 
@@ -9,6 +10,8 @@
 import re
 from pathlib import Path
 
+from tools.nasm_exception_handlers import restore_exception_handler_epilogues
+
 
 _SYMBOL = r"[A-Za-z_.$?][\w.$?@]*"
 _LABEL_RE = re.compile(rf"^(?P<label>{_SYMBOL}):\s*(?:;.*)?$")
@@ -73,7 +76,17 @@ def declare_exports(
     ]
     if declarations:
         lines[declaration_insertion:declaration_insertion] = declarations
-    return "\n".join(lines) + "\n"
+
+    rewritten, function_count, epilogue_count = restore_exception_handler_epilogues(
+        "\n".join(lines) + "\n"
+    )
+    if function_count:
+        print(
+            "RESTORED EXCEPTION HANDLER EPILOGUES",
+            function_count,
+            epilogue_count,
+        )
+    return rewritten
 
 
 def _parse_alias(value: str) -> tuple[str, str]:

From effdbf0d5644acdc34e04b2f15f90d89b86f19bd Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:19:41 -0500
Subject: [PATCH 371/450] Make NASM finalizer directly executable

---
 tools/nasm_exports.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tools/nasm_exports.py b/tools/nasm_exports.py
index fb631570..8c578c0f 100644
--- a/tools/nasm_exports.py
+++ b/tools/nasm_exports.py
@@ -7,8 +7,14 @@
 from __future__ import annotations
 
 import argparse
-import re
 from pathlib import Path
+import re
+import sys
+
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+if str(REPOSITORY_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPOSITORY_ROOT))
 
 from tools.nasm_exception_handlers import restore_exception_handler_epilogues
 

From 7c79649238e2ae41fb315618565aaf75748bad77 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:28:02 -0500
Subject: [PATCH 372/450] Normalize opaque native AST field loads

---
 .../normalize_full_core_native_node_fields.py | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 tools/normalize_full_core_native_node_fields.py

diff --git a/tools/normalize_full_core_native_node_fields.py b/tools/normalize_full_core_native_node_fields.py
new file mode 100644
index 00000000..a44921d0
--- /dev/null
+++ b/tools/normalize_full_core_native_node_fields.py
@@ -0,0 +1,134 @@
+"""Load opaque native AST-node fields through the runtime object model.
+
+The pinned compiler can fold ``node.field`` to a static field type token when
+``node`` is annotated as ``object``. Native AST conversion then receives values
+such as the dict type ID instead of the parsed child node. Rewrite every direct
+field read in the conversion boundary to ``getattr(node, field)`` so the value is
+loaded from the runtime instance dictionary.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_CONVERTERS = {
+    "_convert_expr",
+    "_convert_arguments",
+    "_convert_func",
+    "_convert_stmt",
+}
+
+
+class _NodeFieldLoader(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+        self.fields: set[str] = set()
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        self.generic_visit(node)
+        if not (
+            isinstance(node.ctx, ast.Load)
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "node"
+            and not node.attr.startswith("__")
+        ):
+            return node
+        self.count += 1
+        self.fields.add(node.attr)
+        return ast.copy_location(
+            ast.Call(
+                func=ast.Name(id="getattr", ctx=ast.Load()),
+                args=[
+                    ast.Name(id="node", ctx=ast.Load()),
+                    ast.Constant(value=node.attr),
+                ],
+                keywords=[],
+            ),
+            node,
+        )
+
+
+def _converter_functions(module: ast.Module) -> dict[str, ast.FunctionDef]:
+    return {
+        node.name: node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name in _CONVERTERS
+    }
+
+
+def _normalize_function(function: ast.FunctionDef) -> tuple[int, set[str]]:
+    loader = _NodeFieldLoader()
+    loader.visit(function)
+    return loader.count, loader.fields
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    functions = _converter_functions(module)
+    missing = sorted(_CONVERTERS - set(functions))
+    if missing:
+        raise RuntimeError(f"native AST field normalization missing converters: {missing}")
+
+    total = 0
+    fields: set[str] = set()
+    counts: dict[str, int] = {}
+    for name in sorted(functions):
+        count, function_fields = _normalize_function(functions[name])
+        counts[name] = count
+        total += count
+        fields.update(function_fields)
+
+    if counts["_convert_expr"] == 0 or counts["_convert_stmt"] == 0:
+        raise RuntimeError(
+            "native AST field normalization found no opaque field loads; "
+            f"counts={counts}"
+        )
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source)
+    stale: list[tuple[str, str]] = []
+    runtime_loads = 0
+    for name, function in _converter_functions(verified).items():
+        for node in ast.walk(function):
+            if (
+                isinstance(node, ast.Attribute)
+                and isinstance(node.ctx, ast.Load)
+                and isinstance(node.value, ast.Name)
+                and node.value.id == "node"
+                and not node.attr.startswith("__")
+            ):
+                stale.append((name, node.attr))
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Name)
+                and node.func.id == "getattr"
+                and len(node.args) >= 2
+                and isinstance(node.args[0], ast.Name)
+                and node.args[0].id == "node"
+                and isinstance(node.args[1], ast.Constant)
+                and isinstance(node.args[1].value, str)
+            ):
+                runtime_loads += 1
+
+    if stale or runtime_loads < total:
+        raise RuntimeError(
+            "native AST field validation failed; "
+            f"stale={stale[:8]}, runtime_loads={runtime_loads}, expected={total}"
+        )
+
+    print(
+        "NORMALIZED NATIVE AST RUNTIME FIELD LOADS",
+        total,
+        "FIELDS",
+        len(fields),
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 5f664cfc9238521388483e2c21ac8301691ba603 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:29:03 -0500
Subject: [PATCH 373/450] Run native AST field-load normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 43a5215c..e249f889 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -32,6 +32,7 @@
 from tools.normalize_full_core_name_index import main as normalize_name_index
 from tools.normalize_full_core_native_argument_defaults import main as normalize_native_argument_defaults
 from tools.normalize_full_core_native_keyword_transport import main as normalize_native_keyword_transport
+from tools.normalize_full_core_native_node_fields import main as normalize_native_node_fields
 from tools.normalize_full_core_native_parser import main as normalize_native_parser
 from tools.normalize_full_core_native_parser_expressions import main as normalize_native_parser_expressions
 from tools.normalize_full_core_native_parser_target_dispatch import main as normalize_native_parser_target_dispatch
@@ -178,6 +179,7 @@ def main() -> int:
         ("pattern_slices", normalize_pattern_slices),
         ("extended_semantics", normalize_extended_semantics),
         ("native_statement_bodies", normalize_native_statement_bodies),
+        ("native_node_fields", normalize_native_node_fields),
         ("pop_top", normalize_pop_top),
         ("make_function", normalize_make_function),
         ("collections", normalize_collections),

From 7645bd88ffb0740afdb204769e2e3418629e8799 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:30:10 -0500
Subject: [PATCH 374/450] Test native AST runtime field loads

---
 ..._normalize_full_core_native_node_fields.py | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/test_normalize_full_core_native_node_fields.py

diff --git a/tests/test_normalize_full_core_native_node_fields.py b/tests/test_normalize_full_core_native_node_fields.py
new file mode 100644
index 00000000..7ca60569
--- /dev/null
+++ b/tests/test_normalize_full_core_native_node_fields.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import ast
+
+from tools import normalize_full_core_native_node_fields as normalizer
+
+
+def test_opaque_node_fields_use_runtime_getattr() -> None:
+    module = ast.parse(
+        '''
+def _convert_stmt(node: object, lifted: dict, other: object):
+    if isinstance(node, ExprStmt):
+        return Expr(_convert_expr(node.expr, lifted))
+    return (node.name, other.value)
+'''
+    )
+    function = module.body[0]
+    assert isinstance(function, ast.FunctionDef)
+
+    count, fields = normalizer._normalize_function(function)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module)
+
+    assert count == 2
+    assert fields == {"expr", "name"}
+    assert "node.expr" not in source
+    assert "node.name" not in source
+    assert "getattr(node, 'expr')" in source
+    assert "getattr(node, 'name')" in source
+    assert "other.value" in source

From 8b2a21ac1ee3838ec9d035974bbd23732919f784 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:30:30 -0500
Subject: [PATCH 375/450] Avoid ExprStmt parameter class collision

---
 ...rmalize_full_core_expr_stmt_initializer.py | 45 ++++++++++++++-----
 1 file changed, 35 insertions(+), 10 deletions(-)

diff --git a/tools/normalize_full_core_expr_stmt_initializer.py b/tools/normalize_full_core_expr_stmt_initializer.py
index 7658b7ff..480e7fa4 100644
--- a/tools/normalize_full_core_expr_stmt_initializer.py
+++ b/tools/normalize_full_core_expr_stmt_initializer.py
@@ -1,9 +1,9 @@
 """Install a compiler-safe initializer for the embedded native ExprStmt node.
 
-The pinned compiler's synthesized dataclass initializer stores the static ``dict``
-type token (0x7e) into ``ExprStmt.expr`` instead of the constructor argument. An
-explicit initializer keeps ordinary parameter slots and copies their runtime values
-directly into the instance fields, bypassing dataclass synthesis entirely.
+The pinned compiler resolves a parameter named ``expr`` as the global ``expr``
+class token instead of the constructor argument. Dataclass synthesis has the
+same failure mode. Use a non-colliding parameter name, rewrite keyword call
+sites, and copy the runtime value into the public ``expr`` field explicitly.
 """
 from __future__ import annotations
 
@@ -13,6 +13,7 @@
 
 PATH = Path("src/portapy/core/native_ast.py")
 _CLASS_NAME = "_npr_ast_nodes_ExprStmt"
+_PARAMETER_NAME = "expr_value"
 
 
 def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
@@ -40,14 +41,32 @@ def _install_initializer(class_node: ast.ClassDef) -> int:
         )
 
     initializer = ast.parse(
-        "def __init__(self, expr: dict, pos: dict) -> None:\n"
-        "    self.expr = expr\n"
+        f"def __init__(self, {_PARAMETER_NAME}: dict, pos: dict) -> None:\n"
+        f"    self.expr = {_PARAMETER_NAME}\n"
         "    self.pos = pos\n"
     ).body[0]
     class_node.body.append(initializer)
     return 1
 
 
+class _KeywordCallRenamer(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.rewritten = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if not (
+            isinstance(node.func, ast.Name)
+            and node.func.id == _CLASS_NAME
+        ):
+            return node
+        for keyword in node.keywords:
+            if keyword.arg == "expr":
+                keyword.arg = _PARAMETER_NAME
+                self.rewritten += 1
+        return node
+
+
 def _is_self_field_assignment(
     node: ast.stmt,
     field: str,
@@ -69,6 +88,8 @@ def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     class_node = _expr_stmt_class(module)
     installed = _install_initializer(class_node)
+    renamer = _KeywordCallRenamer()
+    module = renamer.visit(module)
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -86,7 +107,7 @@ def main() -> int:
 
     initializer = initializers[0]
     parameter_names = [argument.arg for argument in initializer.args.args]
-    if parameter_names != ["self", "expr", "pos"]:
+    if parameter_names != ["self", _PARAMETER_NAME, "pos"]:
         raise RuntimeError(
             f"native ExprStmt initializer parameters changed: {parameter_names}"
         )
@@ -101,17 +122,21 @@ def main() -> int:
         raise RuntimeError("native ExprStmt initializer lost dict parameter types")
 
     if not any(
-        _is_self_field_assignment(node, "expr", "expr")
+        _is_self_field_assignment(node, "expr", _PARAMETER_NAME)
         for node in initializer.body
     ):
-        raise RuntimeError("native ExprStmt initializer does not copy expr")
+        raise RuntimeError("native ExprStmt initializer does not copy expr value")
     if not any(
         _is_self_field_assignment(node, "pos", "pos")
         for node in initializer.body
     ):
         raise RuntimeError("native ExprStmt initializer does not copy pos")
 
-    print("INSTALLED NATIVE EXPRSTMT INITIALIZER", installed)
+    print(
+        "INSTALLED NATIVE EXPRSTMT INITIALIZER",
+        installed,
+        renamer.rewritten,
+    )
     return 0
 
 

From 767471d08aa2141639cef810ba0d34ee71d399df Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:30:51 -0500
Subject: [PATCH 376/450] Test ExprStmt collision-safe initializer

---
 ...rmalize_full_core_expr_stmt_initializer.py | 38 +++++++++++++++++--
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/tests/test_normalize_full_core_expr_stmt_initializer.py b/tests/test_normalize_full_core_expr_stmt_initializer.py
index 720cf543..531ecd22 100644
--- a/tests/test_normalize_full_core_expr_stmt_initializer.py
+++ b/tests/test_normalize_full_core_expr_stmt_initializer.py
@@ -13,10 +13,16 @@ class _npr_ast_nodes_ExprStmt:
 
 class Other:
     pass
+
+def build(value, pos):
+    return _npr_ast_nodes_ExprStmt(expr=value, pos=pos)
 '''
 
 
-def test_installs_direct_explicit_initializer(tmp_path: Path, monkeypatch) -> None:
+def test_installs_noncolliding_explicit_initializer(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(SOURCE, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
@@ -24,13 +30,34 @@ def test_installs_direct_explicit_initializer(tmp_path: Path, monkeypatch) -> No
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
-    assert "def __init__(self, expr: dict, pos: dict) -> None:" in source
-    assert "self.expr = expr" in source
+    assert "def __init__(self, expr_value: dict, pos: dict) -> None:" in source
+    assert "self.expr = expr_value" in source
     assert "self.pos = pos" in source
+    assert "_npr_ast_nodes_ExprStmt(expr_value=value, pos=pos)" in source
     assert "values: list[dict]" not in source
     ast.parse(source)
 
 
+def test_positional_constructor_calls_remain_valid(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace(
+            "_npr_ast_nodes_ExprStmt(expr=value, pos=pos)",
+            "_npr_ast_nodes_ExprStmt(value, pos)",
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    source = path.read_text(encoding="utf-8")
+    assert "_npr_ast_nodes_ExprStmt(value, pos)" in source
+    ast.parse(source)
+
+
 def test_fails_closed_without_expr_stmt_class(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text("class Other:\n    pass\n", encoding="utf-8")
@@ -44,7 +71,10 @@ def test_fails_closed_without_expr_stmt_class(tmp_path: Path, monkeypatch) -> No
         raise AssertionError("normalizer accepted a missing ExprStmt class")
 
 
-def test_fails_closed_with_existing_initializer(tmp_path: Path, monkeypatch) -> None:
+def test_fails_closed_with_existing_initializer(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(
         SOURCE.replace(

From e244184a9e0e09795a3ac5d7784c145b91904c4a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:32:21 -0500
Subject: [PATCH 377/450] Repair native constructor name collisions

---
 ...rmalize_full_core_expr_stmt_initializer.py | 125 +++++++++++++-----
 1 file changed, 93 insertions(+), 32 deletions(-)

diff --git a/tools/normalize_full_core_expr_stmt_initializer.py b/tools/normalize_full_core_expr_stmt_initializer.py
index 480e7fa4..67dbb41f 100644
--- a/tools/normalize_full_core_expr_stmt_initializer.py
+++ b/tools/normalize_full_core_expr_stmt_initializer.py
@@ -1,9 +1,9 @@
-"""Install a compiler-safe initializer for the embedded native ExprStmt node.
+"""Repair native constructors whose parameter names collide with classes.
 
-The pinned compiler resolves a parameter named ``expr`` as the global ``expr``
-class token instead of the constructor argument. Dataclass synthesis has the
-same failure mode. Use a non-colliding parameter name, rewrite keyword call
-sites, and copy the runtime value into the public ``expr`` field explicitly.
+The pinned compiler may resolve a constructor parameter such as ``expr`` or
+``pattern`` as the same-named global class token instead of the runtime
+argument. Install an explicit ExprStmt initializer, rename every known
+colliding parameter, and rewrite matching keyword call sites.
 """
 from __future__ import annotations
 
@@ -12,24 +12,33 @@ class token instead of the constructor argument. Dataclass synthesis has the
 
 
 PATH = Path("src/portapy/core/native_ast.py")
-_CLASS_NAME = "_npr_ast_nodes_ExprStmt"
-_PARAMETER_NAME = "expr_value"
+_EXPR_STMT = "_npr_ast_nodes_ExprStmt"
+_PARAMETER_RENAMES: dict[str, dict[str, str]] = {
+    _EXPR_STMT: {"expr": "expr_value"},
+    "MatchAs": {"pattern": "pattern_value"},
+    "match_case": {"pattern": "pattern_value"},
+}
 
 
-def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
+def _class(module: ast.Module, name: str) -> ast.ClassDef | None:
     classes = [
         node
         for node in module.body
-        if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
+        if isinstance(node, ast.ClassDef) and node.name == name
     ]
-    if len(classes) != 1:
-        raise RuntimeError(
-            f"embedded native ExprStmt expected one class, found {len(classes)}"
-        )
-    return classes[0]
+    if len(classes) > 1:
+        raise RuntimeError(f"expected at most one class {name!r}, found {len(classes)}")
+    return classes[0] if classes else None
+
+
+def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
+    class_node = _class(module, _EXPR_STMT)
+    if class_node is None:
+        raise RuntimeError("embedded native ExprStmt expected one class, found 0")
+    return class_node
 
 
-def _install_initializer(class_node: ast.ClassDef) -> int:
+def _install_expr_stmt_initializer(class_node: ast.ClassDef) -> int:
     existing = [
         node
         for node in class_node.body
@@ -41,32 +50,84 @@ def _install_initializer(class_node: ast.ClassDef) -> int:
         )
 
     initializer = ast.parse(
-        f"def __init__(self, {_PARAMETER_NAME}: dict, pos: dict) -> None:\n"
-        f"    self.expr = {_PARAMETER_NAME}\n"
+        "def __init__(self, expr_value: dict, pos: dict) -> None:\n"
+        "    self.expr = expr_value\n"
         "    self.pos = pos\n"
     ).body[0]
     class_node.body.append(initializer)
     return 1
 
 
+class _BoundNameRenamer(ast.NodeTransformer):
+    def __init__(self, renames: dict[str, str]) -> None:
+        self.renames = renames
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        replacement = self.renames.get(node.id)
+        if replacement is not None:
+            node.id = replacement
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        return node
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        return node
+
+    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
+        return node
+
+
 class _KeywordCallRenamer(ast.NodeTransformer):
     def __init__(self) -> None:
         self.rewritten = 0
 
     def visit_Call(self, node: ast.Call) -> ast.AST:
         self.generic_visit(node)
-        if not (
-            isinstance(node.func, ast.Name)
-            and node.func.id == _CLASS_NAME
-        ):
+        if not isinstance(node.func, ast.Name):
+            return node
+        renames = _PARAMETER_RENAMES.get(node.func.id)
+        if not renames:
             return node
         for keyword in node.keywords:
-            if keyword.arg == "expr":
-                keyword.arg = _PARAMETER_NAME
+            replacement = renames.get(keyword.arg or "")
+            if replacement is not None:
+                keyword.arg = replacement
                 self.rewritten += 1
         return node
 
 
+def _rename_constructor_parameters(module: ast.Module) -> int:
+    renamed = 0
+    for class_name, requested in _PARAMETER_RENAMES.items():
+        class_node = _class(module, class_name)
+        if class_node is None:
+            continue
+        initializers = [
+            node
+            for node in class_node.body
+            if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+        ]
+        if len(initializers) != 1:
+            raise RuntimeError(
+                f"class {class_name!r} expected one initializer, "
+                f"found {len(initializers)}"
+            )
+        initializer = initializers[0]
+        active: dict[str, str] = {}
+        for argument in initializer.args.args[1:]:
+            replacement = requested.get(argument.arg)
+            if replacement is not None:
+                active[argument.arg] = replacement
+                argument.arg = replacement
+                renamed += 1
+        if not active:
+            continue
+        body_renamer = _BoundNameRenamer(active)
+        initializer.body = [body_renamer.visit(statement) for statement in initializer.body]
+    return renamed
+
+
 def _is_self_field_assignment(
     node: ast.stmt,
     field: str,
@@ -86,10 +147,10 @@ def _is_self_field_assignment(
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
-    class_node = _expr_stmt_class(module)
-    installed = _install_initializer(class_node)
-    renamer = _KeywordCallRenamer()
-    module = renamer.visit(module)
+    installed = _install_expr_stmt_initializer(_expr_stmt_class(module))
+    renamed = _rename_constructor_parameters(module)
+    call_renamer = _KeywordCallRenamer()
+    module = call_renamer.visit(module)
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -107,7 +168,7 @@ def main() -> int:
 
     initializer = initializers[0]
     parameter_names = [argument.arg for argument in initializer.args.args]
-    if parameter_names != ["self", _PARAMETER_NAME, "pos"]:
+    if parameter_names != ["self", "expr_value", "pos"]:
         raise RuntimeError(
             f"native ExprStmt initializer parameters changed: {parameter_names}"
         )
@@ -120,9 +181,8 @@ def main() -> int:
         and pos_annotation.id == "dict"
     ):
         raise RuntimeError("native ExprStmt initializer lost dict parameter types")
-
     if not any(
-        _is_self_field_assignment(node, "expr", _PARAMETER_NAME)
+        _is_self_field_assignment(node, "expr", "expr_value")
         for node in initializer.body
     ):
         raise RuntimeError("native ExprStmt initializer does not copy expr value")
@@ -133,9 +193,10 @@ def main() -> int:
         raise RuntimeError("native ExprStmt initializer does not copy pos")
 
     print(
-        "INSTALLED NATIVE EXPRSTMT INITIALIZER",
+        "REPAIRED NATIVE CONSTRUCTOR COLLISIONS",
         installed,
-        renamer.rewritten,
+        renamed,
+        call_renamer.rewritten,
     )
     return 0
 

From fb0744daeaf0545d217548d9ba56ea2aa80fa15c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:32:56 -0500
Subject: [PATCH 378/450] Test all native constructor collision repairs

---
 ...rmalize_full_core_expr_stmt_initializer.py | 51 ++++++++++++++-----
 1 file changed, 39 insertions(+), 12 deletions(-)

diff --git a/tests/test_normalize_full_core_expr_stmt_initializer.py b/tests/test_normalize_full_core_expr_stmt_initializer.py
index 531ecd22..f0a6a890 100644
--- a/tests/test_normalize_full_core_expr_stmt_initializer.py
+++ b/tests/test_normalize_full_core_expr_stmt_initializer.py
@@ -11,15 +11,32 @@ class _npr_ast_nodes_ExprStmt:
     expr: dict
     pos: object
 
+class pattern:
+    pass
+
+class MatchAs:
+    def __init__(self, pattern, name):
+        self.pattern = pattern
+        self.name = name
+
+class match_case:
+    def __init__(self, pattern, guard, body):
+        self.pattern = pattern
+        self.guard = guard
+        self.body = body
+
 class Other:
     pass
 
 def build(value, pos):
-    return _npr_ast_nodes_ExprStmt(expr=value, pos=pos)
+    first = _npr_ast_nodes_ExprStmt(expr=value, pos=pos)
+    second = MatchAs(pattern=value, name='captured')
+    third = match_case(pattern=value, guard=None, body=[])
+    return first, second, third
 '''
 
 
-def test_installs_noncolliding_explicit_initializer(
+def test_repairs_collision_prone_initializers_and_calls(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
@@ -32,8 +49,12 @@ def test_installs_noncolliding_explicit_initializer(
     source = path.read_text(encoding="utf-8")
     assert "def __init__(self, expr_value: dict, pos: dict) -> None:" in source
     assert "self.expr = expr_value" in source
-    assert "self.pos = pos" in source
+    assert "def __init__(self, pattern_value, name):" in source
+    assert "def __init__(self, pattern_value, guard, body):" in source
+    assert source.count("self.pattern = pattern_value") == 2
     assert "_npr_ast_nodes_ExprStmt(expr_value=value, pos=pos)" in source
+    assert "MatchAs(pattern_value=value, name='captured')" in source
+    assert "match_case(pattern_value=value, guard=None, body=[])" in source
     assert "values: list[dict]" not in source
     ast.parse(source)
 
@@ -43,19 +64,25 @@ def test_positional_constructor_calls_remain_valid(
     monkeypatch,
 ) -> None:
     path = tmp_path / "native_ast.py"
-    path.write_text(
-        SOURCE.replace(
-            "_npr_ast_nodes_ExprStmt(expr=value, pos=pos)",
-            "_npr_ast_nodes_ExprStmt(value, pos)",
-        ),
-        encoding="utf-8",
+    source = SOURCE.replace(
+        "_npr_ast_nodes_ExprStmt(expr=value, pos=pos)",
+        "_npr_ast_nodes_ExprStmt(value, pos)",
+    ).replace(
+        "MatchAs(pattern=value, name='captured')",
+        "MatchAs(value, 'captured')",
+    ).replace(
+        "match_case(pattern=value, guard=None, body=[])",
+        "match_case(value, None, [])",
     )
+    path.write_text(source, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     assert normalizer.main() == 0
-    source = path.read_text(encoding="utf-8")
-    assert "_npr_ast_nodes_ExprStmt(value, pos)" in source
-    ast.parse(source)
+    rewritten = path.read_text(encoding="utf-8")
+    assert "_npr_ast_nodes_ExprStmt(value, pos)" in rewritten
+    assert "MatchAs(value, 'captured')" in rewritten
+    assert "match_case(value, None, [])" in rewritten
+    ast.parse(rewritten)
 
 
 def test_fails_closed_without_expr_stmt_class(tmp_path: Path, monkeypatch) -> None:

From 3fae075157f5140d3f6ab6dcde8b02913bc832ff Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:35:40 -0500
Subject: [PATCH 379/450] Keep ExprStmt collision repair before semantics

---
 ...rmalize_full_core_expr_stmt_initializer.py | 125 +++++-------------
 1 file changed, 32 insertions(+), 93 deletions(-)

diff --git a/tools/normalize_full_core_expr_stmt_initializer.py b/tools/normalize_full_core_expr_stmt_initializer.py
index 67dbb41f..480e7fa4 100644
--- a/tools/normalize_full_core_expr_stmt_initializer.py
+++ b/tools/normalize_full_core_expr_stmt_initializer.py
@@ -1,9 +1,9 @@
-"""Repair native constructors whose parameter names collide with classes.
+"""Install a compiler-safe initializer for the embedded native ExprStmt node.
 
-The pinned compiler may resolve a constructor parameter such as ``expr`` or
-``pattern`` as the same-named global class token instead of the runtime
-argument. Install an explicit ExprStmt initializer, rename every known
-colliding parameter, and rewrite matching keyword call sites.
+The pinned compiler resolves a parameter named ``expr`` as the global ``expr``
+class token instead of the constructor argument. Dataclass synthesis has the
+same failure mode. Use a non-colliding parameter name, rewrite keyword call
+sites, and copy the runtime value into the public ``expr`` field explicitly.
 """
 from __future__ import annotations
 
@@ -12,33 +12,24 @@
 
 
 PATH = Path("src/portapy/core/native_ast.py")
-_EXPR_STMT = "_npr_ast_nodes_ExprStmt"
-_PARAMETER_RENAMES: dict[str, dict[str, str]] = {
-    _EXPR_STMT: {"expr": "expr_value"},
-    "MatchAs": {"pattern": "pattern_value"},
-    "match_case": {"pattern": "pattern_value"},
-}
+_CLASS_NAME = "_npr_ast_nodes_ExprStmt"
+_PARAMETER_NAME = "expr_value"
 
 
-def _class(module: ast.Module, name: str) -> ast.ClassDef | None:
+def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
     classes = [
         node
         for node in module.body
-        if isinstance(node, ast.ClassDef) and node.name == name
+        if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
     ]
-    if len(classes) > 1:
-        raise RuntimeError(f"expected at most one class {name!r}, found {len(classes)}")
-    return classes[0] if classes else None
-
-
-def _expr_stmt_class(module: ast.Module) -> ast.ClassDef:
-    class_node = _class(module, _EXPR_STMT)
-    if class_node is None:
-        raise RuntimeError("embedded native ExprStmt expected one class, found 0")
-    return class_node
+    if len(classes) != 1:
+        raise RuntimeError(
+            f"embedded native ExprStmt expected one class, found {len(classes)}"
+        )
+    return classes[0]
 
 
-def _install_expr_stmt_initializer(class_node: ast.ClassDef) -> int:
+def _install_initializer(class_node: ast.ClassDef) -> int:
     existing = [
         node
         for node in class_node.body
@@ -50,84 +41,32 @@ def _install_expr_stmt_initializer(class_node: ast.ClassDef) -> int:
         )
 
     initializer = ast.parse(
-        "def __init__(self, expr_value: dict, pos: dict) -> None:\n"
-        "    self.expr = expr_value\n"
+        f"def __init__(self, {_PARAMETER_NAME}: dict, pos: dict) -> None:\n"
+        f"    self.expr = {_PARAMETER_NAME}\n"
         "    self.pos = pos\n"
     ).body[0]
     class_node.body.append(initializer)
     return 1
 
 
-class _BoundNameRenamer(ast.NodeTransformer):
-    def __init__(self, renames: dict[str, str]) -> None:
-        self.renames = renames
-
-    def visit_Name(self, node: ast.Name) -> ast.AST:
-        replacement = self.renames.get(node.id)
-        if replacement is not None:
-            node.id = replacement
-        return node
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
-        return node
-
-    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
-        return node
-
-    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
-        return node
-
-
 class _KeywordCallRenamer(ast.NodeTransformer):
     def __init__(self) -> None:
         self.rewritten = 0
 
     def visit_Call(self, node: ast.Call) -> ast.AST:
         self.generic_visit(node)
-        if not isinstance(node.func, ast.Name):
-            return node
-        renames = _PARAMETER_RENAMES.get(node.func.id)
-        if not renames:
+        if not (
+            isinstance(node.func, ast.Name)
+            and node.func.id == _CLASS_NAME
+        ):
             return node
         for keyword in node.keywords:
-            replacement = renames.get(keyword.arg or "")
-            if replacement is not None:
-                keyword.arg = replacement
+            if keyword.arg == "expr":
+                keyword.arg = _PARAMETER_NAME
                 self.rewritten += 1
         return node
 
 
-def _rename_constructor_parameters(module: ast.Module) -> int:
-    renamed = 0
-    for class_name, requested in _PARAMETER_RENAMES.items():
-        class_node = _class(module, class_name)
-        if class_node is None:
-            continue
-        initializers = [
-            node
-            for node in class_node.body
-            if isinstance(node, ast.FunctionDef) and node.name == "__init__"
-        ]
-        if len(initializers) != 1:
-            raise RuntimeError(
-                f"class {class_name!r} expected one initializer, "
-                f"found {len(initializers)}"
-            )
-        initializer = initializers[0]
-        active: dict[str, str] = {}
-        for argument in initializer.args.args[1:]:
-            replacement = requested.get(argument.arg)
-            if replacement is not None:
-                active[argument.arg] = replacement
-                argument.arg = replacement
-                renamed += 1
-        if not active:
-            continue
-        body_renamer = _BoundNameRenamer(active)
-        initializer.body = [body_renamer.visit(statement) for statement in initializer.body]
-    return renamed
-
-
 def _is_self_field_assignment(
     node: ast.stmt,
     field: str,
@@ -147,10 +86,10 @@ def _is_self_field_assignment(
 
 def main() -> int:
     module = ast.parse(PATH.read_text(encoding="utf-8"))
-    installed = _install_expr_stmt_initializer(_expr_stmt_class(module))
-    renamed = _rename_constructor_parameters(module)
-    call_renamer = _KeywordCallRenamer()
-    module = call_renamer.visit(module)
+    class_node = _expr_stmt_class(module)
+    installed = _install_initializer(class_node)
+    renamer = _KeywordCallRenamer()
+    module = renamer.visit(module)
 
     ast.fix_missing_locations(module)
     source = ast.unparse(module) + "\n"
@@ -168,7 +107,7 @@ def main() -> int:
 
     initializer = initializers[0]
     parameter_names = [argument.arg for argument in initializer.args.args]
-    if parameter_names != ["self", "expr_value", "pos"]:
+    if parameter_names != ["self", _PARAMETER_NAME, "pos"]:
         raise RuntimeError(
             f"native ExprStmt initializer parameters changed: {parameter_names}"
         )
@@ -181,8 +120,9 @@ def main() -> int:
         and pos_annotation.id == "dict"
     ):
         raise RuntimeError("native ExprStmt initializer lost dict parameter types")
+
     if not any(
-        _is_self_field_assignment(node, "expr", "expr_value")
+        _is_self_field_assignment(node, "expr", _PARAMETER_NAME)
         for node in initializer.body
     ):
         raise RuntimeError("native ExprStmt initializer does not copy expr value")
@@ -193,10 +133,9 @@ def main() -> int:
         raise RuntimeError("native ExprStmt initializer does not copy pos")
 
     print(
-        "REPAIRED NATIVE CONSTRUCTOR COLLISIONS",
+        "INSTALLED NATIVE EXPRSTMT INITIALIZER",
         installed,
-        renamed,
-        call_renamer.rewritten,
+        renamer.rewritten,
     )
     return 0
 

From 872b596028871c2a5b13b879bd9d1180aa75fa42 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:36:02 -0500
Subject: [PATCH 380/450] Run MatchAs defaults before constructor collision
 repair

---
 tools/normalize_full_core_validation.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index e249f889..5e6017d5 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -172,12 +172,14 @@ def main() -> int:
         ("combine_native_parser", combine_native_parser),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("native_parser_target_dispatch", normalize_native_parser_target_dispatch),
-        ("expr_stmt_initializer", normalize_expr_stmt_initializer),
         ("parser_errors", normalize_parser_errors),
         ("boolops", normalize_boolops),
         ("closures", normalize_closures),
         ("pattern_slices", normalize_pattern_slices),
         ("extended_semantics", normalize_extended_semantics),
+        # Extended semantics installs MatchAs defaults using the original
+        # constructor signature. Rename colliding parameters only afterwards.
+        ("expr_stmt_initializer", normalize_expr_stmt_initializer),
         ("native_statement_bodies", normalize_native_statement_bodies),
         ("native_node_fields", normalize_native_node_fields),
         ("pop_top", normalize_pop_top),

From 8a0b33fc0f4f294419a2c96f9ac4a1d683479ed6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:36:28 -0500
Subject: [PATCH 381/450] Test full-core normalization dependency order

---
 .../test_normalize_full_core_validation_order.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 tests/test_normalize_full_core_validation_order.py

diff --git a/tests/test_normalize_full_core_validation_order.py b/tests/test_normalize_full_core_validation_order.py
new file mode 100644
index 00000000..601f8da3
--- /dev/null
+++ b/tests/test_normalize_full_core_validation_order.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import inspect
+
+from tools import normalize_full_core_validation as validation
+
+
+def test_match_defaults_precede_constructor_collision_renames() -> None:
+    source = inspect.getsource(validation.main)
+
+    assert source.index('(\"extended_semantics\"') < source.index(
+        '(\"expr_stmt_initializer\"'
+    )
+    assert source.index('(\"expr_stmt_initializer\"') < source.index(
+        '(\"native_node_fields\"'
+    )

From bd8fd6c420f6636233a91d1ecc0ef9388479ac42 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:36:39 -0500
Subject: [PATCH 382/450] Add post-semantics pattern collision repair

---
 ...ull_core_pattern_constructor_collisions.py | 156 ++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 tools/normalize_full_core_pattern_constructor_collisions.py

diff --git a/tools/normalize_full_core_pattern_constructor_collisions.py b/tools/normalize_full_core_pattern_constructor_collisions.py
new file mode 100644
index 00000000..86a0c693
--- /dev/null
+++ b/tools/normalize_full_core_pattern_constructor_collisions.py
@@ -0,0 +1,156 @@
+"""Rename pattern-constructor parameters that collide with ``pattern``.
+
+Run this after extended-semantics normalization has installed MatchAs defaults.
+The pinned compiler otherwise stores the global ``pattern`` class token instead
+of the constructor argument in MatchAs and match_case instances.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_RENAMES: dict[str, dict[str, str]] = {
+    "MatchAs": {"pattern": "pattern_value"},
+    "match_case": {"pattern": "pattern_value"},
+}
+
+
+def _classes(module: ast.Module) -> dict[str, ast.ClassDef]:
+    result: dict[str, ast.ClassDef] = {}
+    for node in module.body:
+        if not isinstance(node, ast.ClassDef) or node.name not in _RENAMES:
+            continue
+        if node.name in result:
+            raise RuntimeError(f"duplicate native pattern class: {node.name}")
+        result[node.name] = node
+    missing = [name for name in _RENAMES if name not in result]
+    if missing:
+        raise RuntimeError(
+            "native pattern constructor class(es) missing: " + ", ".join(missing)
+        )
+    return result
+
+
+class _BoundNameRenamer(ast.NodeTransformer):
+    def __init__(self, renames: dict[str, str]) -> None:
+        self.renames = renames
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        replacement = self.renames.get(node.id)
+        if replacement is not None:
+            node.id = replacement
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        return node
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        return node
+
+    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
+        return node
+
+
+class _KeywordCallRenamer(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.rewritten = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if not isinstance(node.func, ast.Name):
+            return node
+        renames = _RENAMES.get(node.func.id)
+        if renames is None:
+            return node
+        for keyword in node.keywords:
+            replacement = renames.get(keyword.arg or "")
+            if replacement is not None:
+                keyword.arg = replacement
+                self.rewritten += 1
+        return node
+
+
+def _rename_initializers(module: ast.Module) -> int:
+    renamed = 0
+    for class_name, class_node in _classes(module).items():
+        initializers = [
+            node
+            for node in class_node.body
+            if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+        ]
+        if len(initializers) != 1:
+            raise RuntimeError(
+                f"class {class_name!r} expected one initializer, "
+                f"found {len(initializers)}"
+            )
+        initializer = initializers[0]
+        active: dict[str, str] = {}
+        for argument in initializer.args.args[1:]:
+            replacement = _RENAMES[class_name].get(argument.arg)
+            if replacement is not None:
+                active[argument.arg] = replacement
+                argument.arg = replacement
+                renamed += 1
+        if active != _RENAMES[class_name]:
+            raise RuntimeError(
+                f"class {class_name!r} collision parameters changed: {active}"
+            )
+        renamer = _BoundNameRenamer(active)
+        initializer.body = [renamer.visit(statement) for statement in initializer.body]
+    return renamed
+
+
+def _verify(module: ast.Module) -> None:
+    for class_name, class_node in _classes(module).items():
+        initializer = next(
+            node
+            for node in class_node.body
+            if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+        )
+        parameter_names = [argument.arg for argument in initializer.args.args]
+        if "pattern" in parameter_names or "pattern_value" not in parameter_names:
+            raise RuntimeError(
+                f"class {class_name!r} pattern parameter was not repaired: "
+                f"{parameter_names}"
+            )
+        assignments = [
+            node
+            for node in initializer.body
+            if isinstance(node, ast.Assign)
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Attribute)
+            and isinstance(node.targets[0].value, ast.Name)
+            and node.targets[0].value.id == "self"
+            and node.targets[0].attr == "pattern"
+        ]
+        if not any(
+            isinstance(node.value, ast.Name)
+            and node.value.id == "pattern_value"
+            for node in assignments
+        ):
+            raise RuntimeError(
+                f"class {class_name!r} does not copy pattern_value"
+            )
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"))
+    renamed = _rename_initializers(module)
+    call_renamer = _KeywordCallRenamer()
+    module = call_renamer.visit(module)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+    _verify(ast.parse(source))
+    print(
+        "REPAIRED NATIVE PATTERN CONSTRUCTOR COLLISIONS",
+        renamed,
+        call_renamer.rewritten,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 9ec04e68284d2b802e380926d96e5ea27f31449c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:37:22 -0500
Subject: [PATCH 383/450] Run pattern collision repair after semantics

---
 ...lize_full_core_extended_semantics_compat.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
index aa0be799..fa834daf 100644
--- a/tools/normalize_full_core_extended_semantics_compat.py
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -8,6 +8,9 @@
 from __future__ import annotations
 
 from tools import normalize_full_core_extended_semantics as _base
+from tools.normalize_full_core_pattern_constructor_collisions import (
+    main as normalize_pattern_constructor_collisions,
+)
 
 
 _CALL_PARSER_MARKERS = {
@@ -21,13 +24,13 @@
 }
 
 _DYNAMIC_EXCEPTION_COMPACT = '''                    if not self._exception_matches(value, expected):
-                        if isinstance(value, (BaseException, PyException)): raise value
-                        _raise_typed("RuntimeError: invalid exception value")'''
+                         if isinstance(value, (BaseException, PyException)): raise value
+                         _raise_typed("RuntimeError: invalid exception value")'''
 
 _DYNAMIC_EXCEPTION_TARGET = '''                    if not self._exception_matches(value, expected):
-                        if isinstance(value, (BaseException, PyException)):
-                            _raise_typed("RuntimeError: exception did not match handler")
-                        _raise_typed("RuntimeError: invalid exception value")'''
+                         if isinstance(value, (BaseException, PyException)):
+                             _raise_typed("RuntimeError: exception did not match handler")
+                         _raise_typed("RuntimeError: invalid exception value")'''
 
 
 def _call_argument_method(source: str) -> str:
@@ -102,7 +105,10 @@ def main() -> int:
     previous = _base._replace
     _base._replace = _compatible_replace
     try:
-        return _base.main()
+        result = _base.main()
+        if result not in (None, 0):
+            return int(result)
+        return normalize_pattern_constructor_collisions()
     finally:
         _base._replace = previous
 

From 731dd25e87d17e42670be9782db60f3100d460c3 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:37:42 -0500
Subject: [PATCH 384/450] Keep ExprStmt tests scoped to early pass

---
 ...rmalize_full_core_expr_stmt_initializer.py | 51 +++++--------------
 1 file changed, 12 insertions(+), 39 deletions(-)

diff --git a/tests/test_normalize_full_core_expr_stmt_initializer.py b/tests/test_normalize_full_core_expr_stmt_initializer.py
index f0a6a890..531ecd22 100644
--- a/tests/test_normalize_full_core_expr_stmt_initializer.py
+++ b/tests/test_normalize_full_core_expr_stmt_initializer.py
@@ -11,32 +11,15 @@ class _npr_ast_nodes_ExprStmt:
     expr: dict
     pos: object
 
-class pattern:
-    pass
-
-class MatchAs:
-    def __init__(self, pattern, name):
-        self.pattern = pattern
-        self.name = name
-
-class match_case:
-    def __init__(self, pattern, guard, body):
-        self.pattern = pattern
-        self.guard = guard
-        self.body = body
-
 class Other:
     pass
 
 def build(value, pos):
-    first = _npr_ast_nodes_ExprStmt(expr=value, pos=pos)
-    second = MatchAs(pattern=value, name='captured')
-    third = match_case(pattern=value, guard=None, body=[])
-    return first, second, third
+    return _npr_ast_nodes_ExprStmt(expr=value, pos=pos)
 '''
 
 
-def test_repairs_collision_prone_initializers_and_calls(
+def test_installs_noncolliding_explicit_initializer(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
@@ -49,12 +32,8 @@ def test_repairs_collision_prone_initializers_and_calls(
     source = path.read_text(encoding="utf-8")
     assert "def __init__(self, expr_value: dict, pos: dict) -> None:" in source
     assert "self.expr = expr_value" in source
-    assert "def __init__(self, pattern_value, name):" in source
-    assert "def __init__(self, pattern_value, guard, body):" in source
-    assert source.count("self.pattern = pattern_value") == 2
+    assert "self.pos = pos" in source
     assert "_npr_ast_nodes_ExprStmt(expr_value=value, pos=pos)" in source
-    assert "MatchAs(pattern_value=value, name='captured')" in source
-    assert "match_case(pattern_value=value, guard=None, body=[])" in source
     assert "values: list[dict]" not in source
     ast.parse(source)
 
@@ -64,25 +43,19 @@ def test_positional_constructor_calls_remain_valid(
     monkeypatch,
 ) -> None:
     path = tmp_path / "native_ast.py"
-    source = SOURCE.replace(
-        "_npr_ast_nodes_ExprStmt(expr=value, pos=pos)",
-        "_npr_ast_nodes_ExprStmt(value, pos)",
-    ).replace(
-        "MatchAs(pattern=value, name='captured')",
-        "MatchAs(value, 'captured')",
-    ).replace(
-        "match_case(pattern=value, guard=None, body=[])",
-        "match_case(value, None, [])",
+    path.write_text(
+        SOURCE.replace(
+            "_npr_ast_nodes_ExprStmt(expr=value, pos=pos)",
+            "_npr_ast_nodes_ExprStmt(value, pos)",
+        ),
+        encoding="utf-8",
     )
-    path.write_text(source, encoding="utf-8")
     monkeypatch.setattr(normalizer, "PATH", path)
 
     assert normalizer.main() == 0
-    rewritten = path.read_text(encoding="utf-8")
-    assert "_npr_ast_nodes_ExprStmt(value, pos)" in rewritten
-    assert "MatchAs(value, 'captured')" in rewritten
-    assert "match_case(value, None, [])" in rewritten
-    ast.parse(rewritten)
+    source = path.read_text(encoding="utf-8")
+    assert "_npr_ast_nodes_ExprStmt(value, pos)" in source
+    ast.parse(source)
 
 
 def test_fails_closed_without_expr_stmt_class(tmp_path: Path, monkeypatch) -> None:

From 85030a1733058907aa96077ec552d5a89ec3d97d Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:38:00 -0500
Subject: [PATCH 385/450] Test post-semantics pattern collision repair

---
 ...ull_core_pattern_constructor_collisions.py | 82 +++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 tests/test_normalize_full_core_pattern_constructor_collisions.py

diff --git a/tests/test_normalize_full_core_pattern_constructor_collisions.py b/tests/test_normalize_full_core_pattern_constructor_collisions.py
new file mode 100644
index 00000000..e2f59b7e
--- /dev/null
+++ b/tests/test_normalize_full_core_pattern_constructor_collisions.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_pattern_constructor_collisions as normalizer
+
+
+SOURCE = '''class pattern:
+    pass
+
+class MatchAs:
+    def __init__(self, pattern: pattern | None = None, name: str | None = None):
+        self.pattern = pattern
+        self.name = name
+
+class match_case:
+    def __init__(self, pattern: pattern, guard: object, body: list):
+        self.pattern = pattern
+        self.guard = guard
+        self.body = body
+
+def build(value):
+    first = MatchAs(pattern=value, name='captured')
+    second = match_case(pattern=value, guard=None, body=[])
+    return first, second
+'''
+
+
+def test_repairs_pattern_parameters_and_keyword_calls(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "def __init__(self, pattern_value: pattern | None=None" in source
+    assert "def __init__(self, pattern_value: pattern, guard: object" in source
+    assert source.count("self.pattern = pattern_value") == 2
+    assert "MatchAs(pattern_value=value, name='captured')" in source
+    assert "match_case(pattern_value=value, guard=None, body=[])" in source
+    ast.parse(source)
+
+
+def test_positional_calls_remain_unchanged(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace(
+            "MatchAs(pattern=value, name='captured')",
+            "MatchAs(value, 'captured')",
+        ).replace(
+            "match_case(pattern=value, guard=None, body=[])",
+            "match_case(value, None, [])",
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+    source = path.read_text(encoding="utf-8")
+    assert "MatchAs(value, 'captured')" in source
+    assert "match_case(value, None, [])" in source
+
+
+def test_fails_closed_when_pattern_class_is_missing(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE.replace("class match_case:", "class missing_case:"), encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "missing" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing pattern constructor")

From c9d19bd5c344e439dc2a5fac108bb030b25b30a2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:39:35 -0500
Subject: [PATCH 386/450] Wire post-semantics pattern collision repair

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 5e6017d5..0a0f939f 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -40,6 +40,7 @@
 from tools.normalize_full_core_native_statement_bodies import main as normalize_native_statement_bodies
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
+from tools.normalize_full_core_pattern_constructor_collisions import main as normalize_pattern_constructor_collisions
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
@@ -180,6 +181,7 @@ def main() -> int:
         # Extended semantics installs MatchAs defaults using the original
         # constructor signature. Rename colliding parameters only afterwards.
         ("expr_stmt_initializer", normalize_expr_stmt_initializer),
+        ("pattern_constructor_collisions", normalize_pattern_constructor_collisions),
         ("native_statement_bodies", normalize_native_statement_bodies),
         ("native_node_fields", normalize_native_node_fields),
         ("pop_top", normalize_pop_top),

From 084d918361127cbc56ee266e89c1895161f785ee Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:39:47 -0500
Subject: [PATCH 387/450] Test pattern collision pipeline wiring

---
 tests/test_normalize_full_core_validation_order.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/test_normalize_full_core_validation_order.py b/tests/test_normalize_full_core_validation_order.py
index 601f8da3..fcb37011 100644
--- a/tests/test_normalize_full_core_validation_order.py
+++ b/tests/test_normalize_full_core_validation_order.py
@@ -8,9 +8,9 @@
 def test_match_defaults_precede_constructor_collision_renames() -> None:
     source = inspect.getsource(validation.main)
 
-    assert source.index('(\"extended_semantics\"') < source.index(
-        '(\"expr_stmt_initializer\"'
-    )
-    assert source.index('(\"expr_stmt_initializer\"') < source.index(
-        '(\"native_node_fields\"'
-    )
+    extended = source.index('(\"extended_semantics\"')
+    expr_stmt = source.index('(\"expr_stmt_initializer\"')
+    pattern_collision = source.index('(\"pattern_constructor_collisions\"')
+    node_fields = source.index('(\"native_node_fields\"')
+
+    assert extended < expr_stmt < pattern_collision < node_fields

From ecd6e954241487160246adeadd4cb9f6a9525e94 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:40:33 -0500
Subject: [PATCH 388/450] Keep pattern collision pass explicit

---
 tools/normalize_full_core_extended_semantics_compat.py | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tools/normalize_full_core_extended_semantics_compat.py b/tools/normalize_full_core_extended_semantics_compat.py
index fa834daf..4edc50ac 100644
--- a/tools/normalize_full_core_extended_semantics_compat.py
+++ b/tools/normalize_full_core_extended_semantics_compat.py
@@ -8,9 +8,6 @@
 from __future__ import annotations
 
 from tools import normalize_full_core_extended_semantics as _base
-from tools.normalize_full_core_pattern_constructor_collisions import (
-    main as normalize_pattern_constructor_collisions,
-)
 
 
 _CALL_PARSER_MARKERS = {
@@ -105,10 +102,7 @@ def main() -> int:
     previous = _base._replace
     _base._replace = _compatible_replace
     try:
-        result = _base.main()
-        if result not in (None, 0):
-            return int(result)
-        return normalize_pattern_constructor_collisions()
+        return _base.main()
     finally:
         _base._replace = previous
 

From 52c7298e3241f18a18d102b410fd44cebd651424 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:40:42 -0500
Subject: [PATCH 389/450] Avoid compiler import in order test

---
 ...test_normalize_full_core_validation_order.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/tests/test_normalize_full_core_validation_order.py b/tests/test_normalize_full_core_validation_order.py
index fcb37011..8f366750 100644
--- a/tests/test_normalize_full_core_validation_order.py
+++ b/tests/test_normalize_full_core_validation_order.py
@@ -1,16 +1,19 @@
 from __future__ import annotations
 
-import inspect
+from pathlib import Path
 
-from tools import normalize_full_core_validation as validation
+
+VALIDATION = (
+    Path(__file__).parents[1] / "tools" / "normalize_full_core_validation.py"
+)
 
 
 def test_match_defaults_precede_constructor_collision_renames() -> None:
-    source = inspect.getsource(validation.main)
+    source = VALIDATION.read_text(encoding="utf-8")
 
-    extended = source.index('(\"extended_semantics\"')
-    expr_stmt = source.index('(\"expr_stmt_initializer\"')
-    pattern_collision = source.index('(\"pattern_constructor_collisions\"')
-    node_fields = source.index('(\"native_node_fields\"')
+    extended = source.index('("extended_semantics"')
+    expr_stmt = source.index('("expr_stmt_initializer"')
+    pattern_collision = source.index('("pattern_constructor_collisions"')
+    node_fields = source.index('("native_node_fields"')
 
     assert extended < expr_stmt < pattern_collision < node_fields

From 7abf61b62a6023e3bf2fa35e7a25f2f7d687cea8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:44:05 -0500
Subject: [PATCH 390/450] Allow already-correct ExprStmt assembly

---
 tools/normalize_full_core_expr_stmt_assembly.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/tools/normalize_full_core_expr_stmt_assembly.py b/tools/normalize_full_core_expr_stmt_assembly.py
index 5ef2fa44..d04877b7 100644
--- a/tools/normalize_full_core_expr_stmt_assembly.py
+++ b/tools/normalize_full_core_expr_stmt_assembly.py
@@ -1,9 +1,8 @@
 """Repair the pinned compiler's ExprStmt initializer parameter load.
 
-The source-level explicit initializer is compiled consistently on Linux and Windows,
-but asmpython replaces the dict-typed ``expr`` parameter with its static type token
-(126 / 0x7e). The real parameter is already spilled at ``[rbp-16]`` on both ABIs,
-so replace only the one bad load inside the uniquely named initializer block.
+Older generated assembly replaces the dict-typed expression parameter with its
+static type token (126 / 0x7e). Newer source normalization avoids the bad load
+entirely, so this fallback accepts an already-correct runtime parameter load.
 """
 from __future__ import annotations
 
@@ -42,11 +41,19 @@ def fix_expr_stmt_initializer_assembly(
         )
 
     count = block.count(_BAD_LOAD)
+    if count == 0:
+        if block.count(_GOOD_LOAD) < 1:
+            raise RuntimeError(
+                "native ExprStmt initializer has neither the static dict-token "
+                "load nor the correct parameter load"
+            )
+        return source, 0
     if count != 1:
         raise RuntimeError(
-            "native ExprStmt initializer expected one static dict-token load, "
+            "native ExprStmt initializer expected at most one static dict-token load, "
             f"found {count}"
         )
+
     fixed_block = block.replace(_BAD_LOAD, _GOOD_LOAD, 1)
     if _BAD_LOAD in fixed_block or fixed_block.count(_GOOD_LOAD) < 1:
         raise RuntimeError("native ExprStmt initializer assembly repair failed")

From 09899f66c95165cbcc25af70f1af4ab3d36f73c1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:44:21 -0500
Subject: [PATCH 391/450] Test already-correct ExprStmt assembly

---
 tests/test_normalize_full_core_expr_stmt_assembly.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_core_expr_stmt_assembly.py b/tests/test_normalize_full_core_expr_stmt_assembly.py
index 3fc081fe..627b2c66 100644
--- a/tests/test_normalize_full_core_expr_stmt_assembly.py
+++ b/tests/test_normalize_full_core_expr_stmt_assembly.py
@@ -46,6 +46,14 @@ def test_repairs_windows_parameter_load() -> None:
     assert "mov rax, [rbp-16]" in source
 
 
+def test_accepts_already_correct_parameter_load() -> None:
+    correct = LINUX.replace("mov rax, 126", "mov rax, [rbp-16]")
+    source, count = fix_expr_stmt_initializer_assembly(correct, target="linux")
+
+    assert count == 0
+    assert source == correct
+
+
 def test_fails_closed_when_bad_load_changes() -> None:
     try:
         fix_expr_stmt_initializer_assembly(
@@ -53,7 +61,7 @@ def test_fails_closed_when_bad_load_changes() -> None:
             target="linux",
         )
     except RuntimeError as error:
-        assert "expected one static dict-token load" in str(error)
+        assert "neither the static dict-token load" in str(error)
     else:
         raise AssertionError("assembly transform accepted a changed bad load")
 

From 48f0221a84094a3b7d6e115b9d784f4b3ce5153b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:51:59 -0500
Subject: [PATCH 392/450] Rename flattened native local collisions

---
 ...rmalize_full_core_local_name_collisions.py | 292 ++++++++++++++++++
 1 file changed, 292 insertions(+)
 create mode 100644 tools/normalize_full_core_local_name_collisions.py

diff --git a/tools/normalize_full_core_local_name_collisions.py b/tools/normalize_full_core_local_name_collisions.py
new file mode 100644
index 00000000..d2502ee1
--- /dev/null
+++ b/tools/normalize_full_core_local_name_collisions.py
@@ -0,0 +1,292 @@
+"""Rename native locals that collide with flattened runtime class names.
+
+The pinned compiler follows PortaPy's imports into one native symbol universe.
+A function-local name such as ``keyword`` can therefore resolve to the imported
+``keyword`` AST class instead of the loop item assigned at runtime. This final
+source pass scans every PortaPy module, renames only non-parameter locals that
+collide with any reachable class name, and verifies that none remain.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+
+ROOT = Path("src/portapy")
+_PREFIX = "__portapy_local_"
+
+
+@dataclass(frozen=True)
+class _FunctionScope:
+    node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
+    depth: int
+
+
+class _FunctionFinder(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.depth = 0
+        self.functions: list[_FunctionScope] = []
+
+    def _visit_function(
+        self,
+        node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
+    ) -> None:
+        self.functions.append(_FunctionScope(node, self.depth))
+        self.depth += 1
+        self.generic_visit(node)
+        self.depth -= 1
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self._visit_function(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self._visit_function(node)
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        self._visit_function(node)
+
+
+class _LocalCollector(ast.NodeVisitor):
+    def __init__(
+        self,
+        root: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
+    ) -> None:
+        self.root = root
+        self.bound: set[str] = set()
+        self.global_names: set[str] = set()
+        self.nonlocal_names: set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        if node is self.root:
+            self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        if node is self.root:
+            self.generic_visit(node)
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        if node is self.root:
+            self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        return
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if isinstance(node.ctx, (ast.Store, ast.Del)):
+            self.bound.add(node.id)
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+        if node.name:
+            self.bound.add(node.name)
+        self.generic_visit(node)
+
+    def visit_Global(self, node: ast.Global) -> None:
+        self.global_names.update(node.names)
+
+    def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
+        self.nonlocal_names.update(node.names)
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            self.bound.add(alias.asname or alias.name.split(".", 1)[0])
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        for alias in node.names:
+            if alias.name != "*":
+                self.bound.add(alias.asname or alias.name)
+
+
+class _LocalRenamer(ast.NodeTransformer):
+    def __init__(self, renames: dict[str, str]) -> None:
+        self.renames = renames
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        replacement = self.renames.get(node.id)
+        if replacement is not None:
+            node.id = replacement
+        return node
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> ast.AST:
+        if node.name in self.renames:
+            node.name = self.renames[node.name]
+        self.generic_visit(node)
+        return node
+
+    def visit_Import(self, node: ast.Import) -> ast.AST:
+        for alias in node.names:
+            bound = alias.asname or alias.name.split(".", 1)[0]
+            replacement = self.renames.get(bound)
+            if replacement is not None:
+                alias.asname = replacement
+        return node
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> ast.AST:
+        for alias in node.names:
+            bound = alias.asname or alias.name
+            replacement = self.renames.get(bound)
+            if replacement is not None:
+                alias.asname = replacement
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        return node
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        return node
+
+    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
+        return node
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        return node
+
+
+def _parameter_names(
+    node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
+) -> set[str]:
+    names = {
+        argument.arg
+        for argument in (
+            *node.args.posonlyargs,
+            *node.args.args,
+            *node.args.kwonlyargs,
+        )
+    }
+    if node.args.vararg is not None:
+        names.add(node.args.vararg.arg)
+    if node.args.kwarg is not None:
+        names.add(node.args.kwarg.arg)
+    return names
+
+
+def _local_names(
+    node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda,
+) -> set[str]:
+    collector = _LocalCollector(node)
+    collector.visit(node)
+    return (
+        collector.bound
+        - _parameter_names(node)
+        - collector.global_names
+        - collector.nonlocal_names
+    )
+
+
+def _unique_name(name: str, occupied: set[str]) -> str:
+    candidate = f"{_PREFIX}{name}"
+    suffix = 2
+    while candidate in occupied:
+        candidate = f"{_PREFIX}{name}_{suffix}"
+        suffix += 1
+    occupied.add(candidate)
+    return candidate
+
+
+def _rename_tree(tree: ast.Module, class_names: set[str]) -> tuple[int, int]:
+    finder = _FunctionFinder()
+    finder.visit(tree)
+    renamed_names = 0
+    changed_functions = 0
+
+    for scope in sorted(
+        finder.functions,
+        key=lambda item: (item.depth, getattr(item.node, "lineno", 0)),
+        reverse=True,
+    ):
+        local_names = _local_names(scope.node)
+        collisions = sorted(local_names & class_names)
+        if not collisions:
+            continue
+        occupied = local_names | _parameter_names(scope.node) | class_names
+        renames = {
+            name: _unique_name(name, occupied)
+            for name in collisions
+        }
+        renamer = _LocalRenamer(renames)
+        if isinstance(scope.node, ast.Lambda):
+            scope.node.body = renamer.visit(scope.node.body)
+        else:
+            scope.node.body = [renamer.visit(statement) for statement in scope.node.body]
+        renamed_names += len(renames)
+        changed_functions += 1
+
+    return renamed_names, changed_functions
+
+
+def _class_names(trees: dict[Path, ast.Module]) -> set[str]:
+    return {
+        node.name
+        for tree in trees.values()
+        for node in ast.walk(tree)
+        if isinstance(node, ast.ClassDef)
+    }
+
+
+def _remaining_collisions(
+    trees: dict[Path, ast.Module],
+    class_names: set[str],
+) -> list[str]:
+    remaining: list[str] = []
+    for path, tree in trees.items():
+        finder = _FunctionFinder()
+        finder.visit(tree)
+        for scope in finder.functions:
+            collisions = sorted(_local_names(scope.node) & class_names)
+            if collisions:
+                name = getattr(scope.node, "name", "<lambda>")
+                remaining.append(
+                    f"{path}:{getattr(scope.node, 'lineno', 0)}:{name}:"
+                    + ",".join(collisions)
+                )
+    return remaining
+
+
+def normalize_tree(root: Path) -> tuple[int, int, int]:
+    paths = sorted(root.rglob("*.py"))
+    trees = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    class_names = _class_names(trees)
+    renamed_names = 0
+    changed_functions = 0
+    changed_files = 0
+
+    for path, tree in trees.items():
+        file_names, file_functions = _rename_tree(tree, class_names)
+        if not file_names:
+            continue
+        ast.fix_missing_locations(tree)
+        path.write_text(ast.unparse(tree) + "\n", encoding="utf-8")
+        renamed_names += file_names
+        changed_functions += file_functions
+        changed_files += 1
+
+    verified = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    remaining = _remaining_collisions(verified, class_names)
+    if remaining:
+        raise RuntimeError(
+            "native local/class collisions remain: " + "; ".join(remaining)
+        )
+    return renamed_names, changed_functions, changed_files
+
+
+def main() -> int:
+    renamed_names, changed_functions, changed_files = normalize_tree(ROOT)
+    if renamed_names < 1:
+        raise RuntimeError("native local/class collision pass changed no names")
+    print(
+        "RENAMED NATIVE LOCAL CLASS COLLISIONS",
+        renamed_names,
+        changed_functions,
+        changed_files,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 9c2ebfa40cfbd451d3f935c80b86823d20080027 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:53:12 -0500
Subject: [PATCH 393/450] Normalize flattened local class collisions last

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 0a0f939f..65f74075 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -28,6 +28,7 @@
 from tools.normalize_full_core_function_specs import main as normalize_function_specs
 from tools.normalize_full_core_keyword_calls import main as normalize_keyword_calls
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
+from tools.normalize_full_core_local_name_collisions import main as normalize_local_name_collisions
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_name_index import main as normalize_name_index
 from tools.normalize_full_core_native_argument_defaults import main as normalize_native_argument_defaults
@@ -194,6 +195,9 @@ def main() -> int:
         ("truthiness", normalize_truthiness),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
+        # Run last: it unparses all changed modules and must see the complete
+        # flattened class namespace produced by every earlier pass.
+        ("local_name_collisions", normalize_local_name_collisions),
     )
     DIAGNOSTIC_PATH.unlink(missing_ok=True)
     NORMALIZATION_LOG_PATH.unlink(missing_ok=True)

From 175b749df731d549dc908d30ce289dd1f5d8e020 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:53:33 -0500
Subject: [PATCH 394/450] Test flattened local collision normalization

---
 ...rmalize_full_core_local_name_collisions.py | 86 +++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 tests/test_normalize_full_core_local_name_collisions.py

diff --git a/tests/test_normalize_full_core_local_name_collisions.py b/tests/test_normalize_full_core_local_name_collisions.py
new file mode 100644
index 00000000..48aa3bbf
--- /dev/null
+++ b/tests/test_normalize_full_core_local_name_collisions.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools.normalize_full_core_local_name_collisions import normalize_tree
+
+
+def test_renames_nonparameter_locals_across_flattened_modules(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    (root / "classes.py").write_text(
+        "class keyword:\n    pass\n\nclass expr:\n    pass\n",
+        encoding="utf-8",
+    )
+    module = root / "runtime.py"
+    module.write_text(
+        '''def lower(items):
+    values = []
+    for keyword in items:
+        expr = keyword.value
+        values.append(expr)
+    return values
+''',
+        encoding="utf-8",
+    )
+
+    renamed, functions, files = normalize_tree(root)
+
+    assert (renamed, functions, files) == (2, 1, 1)
+    source = module.read_text(encoding="utf-8")
+    assert "for __portapy_local_keyword in items:" in source
+    assert "__portapy_local_expr = __portapy_local_keyword.value" in source
+    assert "values.append(__portapy_local_expr)" in source
+    ast.parse(source)
+
+
+def test_leaves_colliding_parameters_for_parameter_specific_passes(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    (root / "module.py").write_text(
+        '''class keyword:
+    pass
+
+def lookup(keyword):
+    return keyword
+''',
+        encoding="utf-8",
+    )
+
+    renamed, functions, files = normalize_tree(root)
+
+    assert (renamed, functions, files) == (0, 0, 0)
+    source = (root / "module.py").read_text(encoding="utf-8")
+    assert "def lookup(keyword):" in source
+    assert "return keyword" in source
+
+
+def test_processes_nested_scopes_independently(tmp_path: Path) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    module = root / "module.py"
+    module.write_text(
+        '''class expr:
+    pass
+
+def outer(values):
+    expr = values[0]
+    def inner(values):
+        expr = values[1]
+        return expr
+    return expr, inner(values)
+''',
+        encoding="utf-8",
+    )
+
+    renamed, functions, files = normalize_tree(root)
+
+    assert (renamed, functions, files) == (2, 2, 1)
+    source = module.read_text(encoding="utf-8")
+    assert source.count("__portapy_local_expr") == 4
+    ast.parse(source)

From 05824f2b44396c125b90bfe92e3e824e950f7a72 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:02:04 -0500
Subject: [PATCH 395/450] Repair flattened parameter class collisions

---
 ...ize_full_core_parameter_name_collisions.py | 410 ++++++++++++++++++
 1 file changed, 410 insertions(+)
 create mode 100644 tools/normalize_full_core_parameter_name_collisions.py

diff --git a/tools/normalize_full_core_parameter_name_collisions.py b/tools/normalize_full_core_parameter_name_collisions.py
new file mode 100644
index 00000000..4e168c16
--- /dev/null
+++ b/tools/normalize_full_core_parameter_name_collisions.py
@@ -0,0 +1,410 @@
+"""Rename native parameters that collide with flattened class symbols.
+
+Asmpython compiles PortaPy's imported modules into one symbol namespace. A
+parameter named like any class can therefore resolve to the class token instead
+of the runtime argument. Explicit functions are renamed in place. Dataclasses
+whose generated initializer would collide receive an equivalent explicit
+initializer with collision-safe parameter names. Matching keyword call sites
+are rewritten across the source tree.
+"""
+from __future__ import annotations
+
+import ast
+import copy
+from pathlib import Path
+
+
+ROOT = Path("src/portapy")
+_PREFIX = "__portapy_param_"
+
+
+def _class_names(trees: dict[Path, ast.Module]) -> set[str]:
+    return {
+        node.name
+        for tree in trees.values()
+        for node in ast.walk(tree)
+        if isinstance(node, ast.ClassDef)
+    }
+
+
+def _is_dataclass(node: ast.ClassDef) -> bool:
+    for decorator in node.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        if isinstance(target, ast.Name) and target.id == "dataclass":
+            if isinstance(decorator, ast.Call):
+                for keyword in decorator.keywords:
+                    if (
+                        keyword.arg == "init"
+                        and isinstance(keyword.value, ast.Constant)
+                        and keyword.value.value is False
+                    ):
+                        return False
+            return True
+        if isinstance(target, ast.Attribute) and target.attr == "dataclass":
+            return True
+    return False
+
+
+def _parameters(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.arg]:
+    result = [*node.args.posonlyargs, *node.args.args, *node.args.kwonlyargs]
+    if node.args.vararg is not None:
+        result.append(node.args.vararg)
+    if node.args.kwarg is not None:
+        result.append(node.args.kwarg)
+    return result
+
+
+class _BodyRenamer(ast.NodeTransformer):
+    def __init__(self, renames: dict[str, str]) -> None:
+        self.renames = renames
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        replacement = self.renames.get(node.id)
+        if replacement is not None:
+            node.id = replacement
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        return node
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        return node
+
+    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
+        return node
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        return node
+
+
+def _rename_explicit_parameters(
+    tree: ast.Module,
+    class_names: set[str],
+    call_renames: dict[str, dict[str, str]],
+) -> int:
+    count = 0
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        renames: dict[str, str] = {}
+        occupied = {argument.arg for argument in _parameters(node)} | class_names
+        for argument in _parameters(node):
+            if argument.arg in {"self", "cls"} or argument.arg not in class_names:
+                continue
+            old = argument.arg
+            candidate = f"{_PREFIX}{old}"
+            suffix = 2
+            while candidate in occupied:
+                candidate = f"{_PREFIX}{old}_{suffix}"
+                suffix += 1
+            occupied.add(candidate)
+            argument.arg = candidate
+            renames[old] = candidate
+            count += 1
+        if not renames:
+            continue
+        body_renamer = _BodyRenamer(renames)
+        node.body = [body_renamer.visit(statement) for statement in node.body]
+        existing = call_renames.setdefault(node.name, {})
+        for old, new in renames.items():
+            previous = existing.get(old)
+            if previous is not None and previous != new:
+                raise RuntimeError(
+                    f"inconsistent parameter rename for {node.name}.{old}: "
+                    f"{previous!r} vs {new!r}"
+                )
+            existing[old] = new
+    return count
+
+
+def _field_nodes(node: ast.ClassDef) -> list[ast.AnnAssign]:
+    return [
+        statement
+        for statement in node.body
+        if isinstance(statement, ast.AnnAssign)
+        and isinstance(statement.target, ast.Name)
+        and statement.simple == 1
+    ]
+
+
+def _safe_factory_default(factory: ast.expr, label: str) -> ast.expr:
+    if isinstance(factory, ast.Lambda):
+        if (
+            factory.args.posonlyargs
+            or factory.args.args
+            or factory.args.kwonlyargs
+            or factory.args.vararg is not None
+            or factory.args.kwarg is not None
+        ):
+            raise RuntimeError(f"{label}: default factory lambda takes arguments")
+        value = factory.body
+    else:
+        raise RuntimeError(f"{label}: unsupported non-lambda default factory")
+    if not isinstance(value, (ast.Name, ast.Attribute, ast.Constant)):
+        raise RuntimeError(
+            f"{label}: mutable or computed default factory cannot become a "
+            "function default safely"
+        )
+    return copy.deepcopy(value)
+
+
+def _field_default(field: ast.AnnAssign, label: str) -> ast.expr | None:
+    value = field.value
+    if value is None:
+        return None
+    if not (
+        isinstance(value, ast.Call)
+        and (
+            (isinstance(value.func, ast.Name) and value.func.id == "field")
+            or (isinstance(value.func, ast.Attribute) and value.func.attr == "field")
+        )
+    ):
+        return copy.deepcopy(value)
+    init_enabled = True
+    default: ast.expr | None = None
+    for keyword in value.keywords:
+        if (
+            keyword.arg == "init"
+            and isinstance(keyword.value, ast.Constant)
+            and keyword.value.value is False
+        ):
+            init_enabled = False
+        elif keyword.arg == "default":
+            default = copy.deepcopy(keyword.value)
+        elif keyword.arg == "default_factory":
+            default = _safe_factory_default(keyword.value, label)
+    if not init_enabled:
+        raise RuntimeError(f"{label}: colliding field uses init=False")
+    if default is None:
+        raise RuntimeError(f"{label}: field() has no supported default")
+    return default
+
+
+def _install_dataclass_initializers(
+    tree: ast.Module,
+    class_names: set[str],
+    call_renames: dict[str, dict[str, str]],
+) -> tuple[int, int]:
+    classes_changed = 0
+    parameters_changed = 0
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef) or not _is_dataclass(node):
+            continue
+        if any(
+            isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and statement.name == "__init__"
+            for statement in node.body
+        ):
+            continue
+        fields = _field_nodes(node)
+        collisions = {
+            field.target.id
+            for field in fields
+            if field.target.id in class_names
+        }
+        if not collisions:
+            continue
+
+        arguments = [ast.arg(arg="self")]
+        defaults: list[ast.expr] = []
+        body: list[ast.stmt] = []
+        saw_default = False
+        renames: dict[str, str] = {}
+        for field in fields:
+            field_name = field.target.id
+            parameter_name = (
+                f"{_PREFIX}{field_name}"
+                if field_name in collisions
+                else field_name
+            )
+            arguments.append(
+                ast.arg(
+                    arg=parameter_name,
+                    annotation=copy.deepcopy(field.annotation),
+                )
+            )
+            default = _field_default(
+                field,
+                f"{node.name}.{field_name}",
+            )
+            if default is None:
+                if saw_default:
+                    raise RuntimeError(
+                        f"{node.name}: required field follows a default field"
+                    )
+            else:
+                saw_default = True
+                defaults.append(default)
+            body.append(
+                ast.Assign(
+                    targets=[
+                        ast.Attribute(
+                            value=ast.Name(id="self", ctx=ast.Load()),
+                            attr=field_name,
+                            ctx=ast.Store(),
+                        )
+                    ],
+                    value=ast.Name(id=parameter_name, ctx=ast.Load()),
+                )
+            )
+            if field_name in collisions:
+                renames[field_name] = parameter_name
+                parameters_changed += 1
+
+        initializer = ast.FunctionDef(
+            name="__init__",
+            args=ast.arguments(
+                posonlyargs=[],
+                args=arguments,
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                kwarg=None,
+                defaults=defaults,
+            ),
+            body=body or [ast.Pass()],
+            decorator_list=[],
+            returns=ast.Constant(value=None),
+            type_comment=None,
+        )
+        node.body.append(initializer)
+        classes_changed += 1
+        existing = call_renames.setdefault(node.name, {})
+        for old, new in renames.items():
+            previous = existing.get(old)
+            if previous is not None and previous != new:
+                raise RuntimeError(
+                    f"inconsistent constructor rename for {node.name}.{old}"
+                )
+            existing[old] = new
+    return classes_changed, parameters_changed
+
+
+class _CallKeywordRenamer(ast.NodeTransformer):
+    def __init__(self, renames: dict[str, dict[str, str]]) -> None:
+        self.renames = renames
+        self.count = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if isinstance(node.func, ast.Name):
+            name = node.func.id
+        elif isinstance(node.func, ast.Attribute):
+            name = node.func.attr
+        else:
+            return node
+        mapping = self.renames.get(name)
+        if not mapping:
+            return node
+        for keyword in node.keywords:
+            replacement = mapping.get(keyword.arg or "")
+            if replacement is not None:
+                keyword.arg = replacement
+                self.count += 1
+        return node
+
+
+def _remaining_parameter_collisions(
+    trees: dict[Path, ast.Module],
+    class_names: set[str],
+) -> list[str]:
+    remaining: list[str] = []
+    for path, tree in trees.items():
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                collisions = sorted(
+                    argument.arg
+                    for argument in _parameters(node)
+                    if argument.arg not in {"self", "cls"}
+                    and argument.arg in class_names
+                )
+                if collisions:
+                    remaining.append(
+                        f"{path}:{node.lineno}:{node.name}:"
+                        + ",".join(collisions)
+                    )
+            elif isinstance(node, ast.ClassDef) and _is_dataclass(node):
+                has_init = any(
+                    isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef))
+                    and statement.name == "__init__"
+                    for statement in node.body
+                )
+                collisions = sorted(
+                    field.target.id
+                    for field in _field_nodes(node)
+                    if field.target.id in class_names
+                )
+                if collisions and not has_init:
+                    remaining.append(
+                        f"{path}:{node.lineno}:{node.name}:generated:"
+                        + ",".join(collisions)
+                    )
+    return remaining
+
+
+def normalize_tree(root: Path) -> tuple[int, int, int, int]:
+    paths = sorted(root.rglob("*.py"))
+    trees = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    class_names = _class_names(trees)
+    call_renames: dict[str, dict[str, str]] = {}
+    explicit_parameters = 0
+    dataclass_parameters = 0
+    dataclass_classes = 0
+
+    for tree in trees.values():
+        explicit_parameters += _rename_explicit_parameters(
+            tree,
+            class_names,
+            call_renames,
+        )
+        classes, parameters = _install_dataclass_initializers(
+            tree,
+            class_names,
+            call_renames,
+        )
+        dataclass_classes += classes
+        dataclass_parameters += parameters
+
+    keyword_calls = 0
+    for tree in trees.values():
+        renamer = _CallKeywordRenamer(call_renames)
+        renamer.visit(tree)
+        keyword_calls += renamer.count
+
+    changed_files = 0
+    for path, tree in trees.items():
+        rendered = ast.unparse(ast.fix_missing_locations(tree)) + "\n"
+        if rendered != path.read_text(encoding="utf-8"):
+            path.write_text(rendered, encoding="utf-8")
+            changed_files += 1
+
+    verified = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    remaining = _remaining_parameter_collisions(verified, class_names)
+    if remaining:
+        raise RuntimeError(
+            "native parameter/class collisions remain: " + "; ".join(remaining)
+        )
+    return (
+        explicit_parameters,
+        dataclass_parameters,
+        dataclass_classes,
+        keyword_calls,
+    )
+
+
+def main() -> int:
+    result = normalize_tree(ROOT)
+    if sum(result[:2]) < 1:
+        raise RuntimeError("native parameter/class collision pass changed no parameters")
+    print("RENAMED NATIVE PARAMETER CLASS COLLISIONS", *result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From a3fe8a71c8ef5135d1cad2112c76723c5e45504e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:03:05 -0500
Subject: [PATCH 396/450] Normalize flattened parameter collisions before
 locals

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 65f74075..84f7148d 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -40,6 +40,7 @@
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_native_statement_bodies import main as normalize_native_statement_bodies
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
+from tools.normalize_full_core_parameter_name_collisions import main as normalize_parameter_name_collisions
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
 from tools.normalize_full_core_pattern_constructor_collisions import main as normalize_pattern_constructor_collisions
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
@@ -195,6 +196,9 @@ def main() -> int:
         ("truthiness", normalize_truthiness),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
+        # Parameter collisions include explicit functions and dataclass-generated
+        # initializers. Repair them before the final local-variable collision pass.
+        ("parameter_name_collisions", normalize_parameter_name_collisions),
         # Run last: it unparses all changed modules and must see the complete
         # flattened class namespace produced by every earlier pass.
         ("local_name_collisions", normalize_local_name_collisions),

From 1cfd3c41ffef01bf249197527b9210a1394fd970 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:03:54 -0500
Subject: [PATCH 397/450] Test flattened parameter collision repair

---
 ...ize_full_core_parameter_name_collisions.py | 103 ++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 tests/test_normalize_full_core_parameter_name_collisions.py

diff --git a/tests/test_normalize_full_core_parameter_name_collisions.py b/tests/test_normalize_full_core_parameter_name_collisions.py
new file mode 100644
index 00000000..15331664
--- /dev/null
+++ b/tests/test_normalize_full_core_parameter_name_collisions.py
@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools.normalize_full_core_parameter_name_collisions import normalize_tree
+
+
+def test_repairs_explicit_and_generated_parameter_collisions(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    module = root / "module.py"
+    module.write_text(
+        '''from dataclasses import dataclass, field
+
+class alias:
+    pass
+
+class arguments:
+    pass
+
+@dataclass
+class ImportNode:
+    module: str
+    alias: str | None = None
+    pos: object = field(default_factory=lambda: NO_POS)
+
+def dispatch(arguments):
+    return arguments
+
+def build(value):
+    return ImportNode(module='demo', alias=value)
+''',
+        encoding="utf-8",
+    )
+
+    explicit, generated, classes, calls = normalize_tree(root)
+
+    assert (explicit, generated, classes, calls) == (1, 1, 1, 1)
+    source = module.read_text(encoding="utf-8")
+    assert "def dispatch(__portapy_param_arguments):" in source
+    assert "return __portapy_param_arguments" in source
+    assert "def __init__(self, module: str, __portapy_param_alias: str | None=None" in source
+    assert "self.alias = __portapy_param_alias" in source
+    assert "pos: object=NO_POS" in source
+    assert "ImportNode(module='demo', __portapy_param_alias=value)" in source
+    ast.parse(source)
+
+
+def test_preserves_positional_calls_and_noncolliding_parameters(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    module = root / "module.py"
+    module.write_text(
+        '''class keyword:
+    pass
+
+def lookup(keyword, fallback):
+    return keyword or fallback
+
+def run(value):
+    return lookup(value, None)
+''',
+        encoding="utf-8",
+    )
+
+    explicit, generated, classes, calls = normalize_tree(root)
+
+    assert (explicit, generated, classes, calls) == (1, 0, 0, 0)
+    source = module.read_text(encoding="utf-8")
+    assert "def lookup(__portapy_param_keyword, fallback):" in source
+    assert "return __portapy_param_keyword or fallback" in source
+    assert "lookup(value, None)" in source
+
+
+def test_rejects_mutable_default_factories_for_colliding_fields(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    (root / "module.py").write_text(
+        '''from dataclasses import dataclass, field
+
+class values:
+    pass
+
+@dataclass
+class Node:
+    values: list = field(default_factory=list)
+''',
+        encoding="utf-8",
+    )
+
+    try:
+        normalize_tree(root)
+    except RuntimeError as error:
+        assert "unsupported non-lambda default factory" in str(error)
+    else:
+        raise AssertionError("mutable generated default was accepted")

From 5f00f7decbd9786c048622a8ab7e8f91c81a5b39 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:10:20 -0500
Subject: [PATCH 398/450] Repair native ExceptHandler type parameter

---
 ..._full_core_builtin_parameter_collisions.py | 171 ++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 tools/normalize_full_core_builtin_parameter_collisions.py

diff --git a/tools/normalize_full_core_builtin_parameter_collisions.py b/tools/normalize_full_core_builtin_parameter_collisions.py
new file mode 100644
index 00000000..25069f22
--- /dev/null
+++ b/tools/normalize_full_core_builtin_parameter_collisions.py
@@ -0,0 +1,171 @@
+"""Repair the compiler-special ``type`` parameter in native ExceptHandler.
+
+Unlike ordinary names, the pinned backend lowers a parameter named ``type`` to
+its builtin type token (-12). Rename the compatibility AST constructor
+parameter while preserving the public ``self.type`` field and keyword calls.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+ROOT = Path("src/portapy")
+_CLASS_NAME = "ExceptHandler"
+_OLD = "type"
+_NEW = "type_value"
+
+
+class _BodyRenamer(ast.NodeTransformer):
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        if node.id == _OLD:
+            node.id = _NEW
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        return node
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        return node
+
+    def visit_Lambda(self, node: ast.Lambda) -> ast.AST:
+        return node
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        return node
+
+
+class _CallRenamer(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if isinstance(node.func, ast.Name):
+            name = node.func.id
+        elif isinstance(node.func, ast.Attribute):
+            name = node.func.attr
+        else:
+            return node
+        if name != _CLASS_NAME:
+            return node
+        for keyword in node.keywords:
+            if keyword.arg == _OLD:
+                keyword.arg = _NEW
+                self.count += 1
+        return node
+
+
+def normalize_tree(root: Path) -> tuple[int, int, int]:
+    paths = sorted(root.rglob("*.py"))
+    trees = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    constructor_count = 0
+    changed_paths: set[Path] = set()
+
+    for path, tree in trees.items():
+        for class_node in [
+            node
+            for node in tree.body
+            if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
+        ]:
+            initializers = [
+                node
+                for node in class_node.body
+                if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+            ]
+            if len(initializers) != 1:
+                raise RuntimeError(
+                    f"{path}: {_CLASS_NAME} expected one initializer, "
+                    f"found {len(initializers)}"
+                )
+            initializer = initializers[0]
+            matching = [
+                argument
+                for argument in [
+                    *initializer.args.posonlyargs,
+                    *initializer.args.args,
+                    *initializer.args.kwonlyargs,
+                ]
+                if argument.arg == _OLD
+            ]
+            if len(matching) != 1:
+                raise RuntimeError(
+                    f"{path}: {_CLASS_NAME}.{_OLD} expected once, "
+                    f"found {len(matching)}"
+                )
+            matching[0].arg = _NEW
+            renamer = _BodyRenamer()
+            initializer.body = [renamer.visit(statement) for statement in initializer.body]
+            constructor_count += 1
+            changed_paths.add(path)
+
+    call_count = 0
+    for path, tree in trees.items():
+        renamer = _CallRenamer()
+        renamer.visit(tree)
+        if renamer.count:
+            changed_paths.add(path)
+            call_count += renamer.count
+
+    for path in changed_paths:
+        ast.fix_missing_locations(trees[path])
+        path.write_text(ast.unparse(trees[path]) + "\n", encoding="utf-8")
+
+    if constructor_count != 1:
+        raise RuntimeError(
+            f"native {_CLASS_NAME} constructor expected once, found {constructor_count}"
+        )
+
+    verified = {
+        path: ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for path in paths
+    }
+    for path, tree in verified.items():
+        for class_node in [
+            node
+            for node in tree.body
+            if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
+        ]:
+            initializer = next(
+                node
+                for node in class_node.body
+                if isinstance(node, ast.FunctionDef) and node.name == "__init__"
+            )
+            names = [argument.arg for argument in initializer.args.args]
+            if _OLD in names or _NEW not in names:
+                raise RuntimeError(
+                    f"{path}: {_CLASS_NAME} builtin parameter repair was lost"
+                )
+            assignments = [
+                statement
+                for statement in initializer.body
+                if isinstance(statement, ast.Assign)
+                and len(statement.targets) == 1
+                and isinstance(statement.targets[0], ast.Attribute)
+                and isinstance(statement.targets[0].value, ast.Name)
+                and statement.targets[0].value.id == "self"
+                and statement.targets[0].attr == _OLD
+            ]
+            if not any(
+                isinstance(statement.value, ast.Name)
+                and statement.value.id == _NEW
+                for statement in assignments
+            ):
+                raise RuntimeError(
+                    f"{path}: {_CLASS_NAME} no longer copies {_NEW}"
+                )
+
+    return constructor_count, call_count, len(changed_paths)
+
+
+def main() -> int:
+    result = normalize_tree(ROOT)
+    print("REPAIRED BUILTIN PARAMETER COLLISIONS", *result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 4c38772f84a6863f49d289abc7e91393139a7a50 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:11:21 -0500
Subject: [PATCH 399/450] Repair builtin type parameter before native compile

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 84f7148d..4cc96700 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -17,6 +17,7 @@
 from tools.combine_full_core_native_parser import main as combine_native_parser
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
 from tools.normalize_full_core_boolops import main as normalize_boolops
+from tools.normalize_full_core_builtin_parameter_collisions import main as normalize_builtin_parameter_collisions
 from tools.normalize_full_core_builtins import main as normalize_builtins
 from tools.normalize_full_core_calls_closures import main as normalize_calls_closures
 from tools.normalize_full_core_closures import main as normalize_closures
@@ -199,6 +200,7 @@ def main() -> int:
         # Parameter collisions include explicit functions and dataclass-generated
         # initializers. Repair them before the final local-variable collision pass.
         ("parameter_name_collisions", normalize_parameter_name_collisions),
+        ("builtin_parameter_collisions", normalize_builtin_parameter_collisions),
         # Run last: it unparses all changed modules and must see the complete
         # flattened class namespace produced by every earlier pass.
         ("local_name_collisions", normalize_local_name_collisions),

From 8ef7bb679d9a6a28c924085de0ecc53ff3af6982 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:11:38 -0500
Subject: [PATCH 400/450] Test native builtin type parameter repair

---
 ..._full_core_builtin_parameter_collisions.py | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_normalize_full_core_builtin_parameter_collisions.py

diff --git a/tests/test_normalize_full_core_builtin_parameter_collisions.py b/tests/test_normalize_full_core_builtin_parameter_collisions.py
new file mode 100644
index 00000000..975940f9
--- /dev/null
+++ b/tests/test_normalize_full_core_builtin_parameter_collisions.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools.normalize_full_core_builtin_parameter_collisions import normalize_tree
+
+
+SOURCE = '''class ExceptHandler:
+    def __init__(self, type, name, body):
+        self.type = type
+        self.name = name
+        self.body = body
+
+def build(value):
+    return ExceptHandler(type=value, name=None, body=[])
+'''
+
+
+def test_repairs_except_handler_type_parameter(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    module = root / "module.py"
+    module.write_text(SOURCE, encoding="utf-8")
+
+    constructors, calls, files = normalize_tree(root)
+
+    assert (constructors, calls, files) == (1, 1, 1)
+    source = module.read_text(encoding="utf-8")
+    assert "def __init__(self, type_value, name, body):" in source
+    assert "self.type = type_value" in source
+    assert "ExceptHandler(type_value=value, name=None, body=[])" in source
+    ast.parse(source)
+
+
+def test_positional_except_handler_calls_remain_unchanged(
+    tmp_path: Path,
+) -> None:
+    root = tmp_path / "portapy"
+    root.mkdir()
+    module = root / "module.py"
+    module.write_text(
+        SOURCE.replace(
+            "ExceptHandler(type=value, name=None, body=[])",
+            "ExceptHandler(value, None, [])",
+        ),
+        encoding="utf-8",
+    )
+
+    constructors, calls, files = normalize_tree(root)
+
+    assert (constructors, calls, files) == (1, 0, 1)
+    source = module.read_text(encoding="utf-8")
+    assert "ExceptHandler(value, None, [])" in source
+    assert "self.type = type_value" in source

From f14e2ef825a2b9bf5ef2e9cee24eef292b53c97b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 19:21:02 -0500
Subject: [PATCH 401/450] Repair native type and slice parameters

---
 ..._full_core_builtin_parameter_collisions.py | 207 +++++++++++-------
 1 file changed, 126 insertions(+), 81 deletions(-)

diff --git a/tools/normalize_full_core_builtin_parameter_collisions.py b/tools/normalize_full_core_builtin_parameter_collisions.py
index 25069f22..fb895418 100644
--- a/tools/normalize_full_core_builtin_parameter_collisions.py
+++ b/tools/normalize_full_core_builtin_parameter_collisions.py
@@ -1,25 +1,42 @@
-"""Repair the compiler-special ``type`` parameter in native ExceptHandler.
+"""Repair compiler-special native parameters that lower to builtin tokens.
 
-Unlike ordinary names, the pinned backend lowers a parameter named ``type`` to
-its builtin type token (-12). Rename the compatibility AST constructor
-parameter while preserving the public ``self.type`` field and keyword calls.
+The pinned backend treats selected parameter names as builtins even inside
+constructors. ``ExceptHandler.type`` becomes token -12 and ``Subscript.slice``
+becomes token -13 instead of loading their runtime arguments. Rename only these
+verified cases while preserving their public instance fields and keyword calls.
 """
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from pathlib import Path
 
 
 ROOT = Path("src/portapy")
-_CLASS_NAME = "ExceptHandler"
-_OLD = "type"
-_NEW = "type_value"
+
+
+@dataclass(frozen=True)
+class _Repair:
+    class_name: str
+    field_name: str
+    parameter_name: str
+
+
+_REPAIRS = (
+    _Repair("ExceptHandler", "type", "type_value"),
+    _Repair("Subscript", "slice", "slice_value"),
+)
+_REPAIR_BY_CLASS = {repair.class_name: repair for repair in _REPAIRS}
 
 
 class _BodyRenamer(ast.NodeTransformer):
+    def __init__(self, old: str, new: str) -> None:
+        self.old = old
+        self.new = new
+
     def visit_Name(self, node: ast.Name) -> ast.AST:
-        if node.id == _OLD:
-            node.id = _NEW
+        if node.id == self.old:
+            node.id = self.new
         return node
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
@@ -42,20 +59,37 @@ def __init__(self) -> None:
     def visit_Call(self, node: ast.Call) -> ast.AST:
         self.generic_visit(node)
         if isinstance(node.func, ast.Name):
-            name = node.func.id
+            class_name = node.func.id
         elif isinstance(node.func, ast.Attribute):
-            name = node.func.attr
+            class_name = node.func.attr
         else:
             return node
-        if name != _CLASS_NAME:
+        repair = _REPAIR_BY_CLASS.get(class_name)
+        if repair is None:
             return node
         for keyword in node.keywords:
-            if keyword.arg == _OLD:
-                keyword.arg = _NEW
+            if keyword.arg == repair.field_name:
+                keyword.arg = repair.parameter_name
                 self.count += 1
         return node
 
 
+def _arguments(initializer: ast.FunctionDef) -> list[ast.arg]:
+    return [
+        *initializer.args.posonlyargs,
+        *initializer.args.args,
+        *initializer.args.kwonlyargs,
+    ]
+
+
+def _class_nodes(tree: ast.Module, class_name: str) -> list[ast.ClassDef]:
+    return [
+        node
+        for node in tree.body
+        if isinstance(node, ast.ClassDef) and node.name == class_name
+    ]
+
+
 def normalize_tree(root: Path) -> tuple[int, int, int]:
     paths = sorted(root.rglob("*.py"))
     trees = {
@@ -64,43 +98,45 @@ def normalize_tree(root: Path) -> tuple[int, int, int]:
     }
     constructor_count = 0
     changed_paths: set[Path] = set()
+    seen: dict[_Repair, int] = {repair: 0 for repair in _REPAIRS}
 
     for path, tree in trees.items():
-        for class_node in [
-            node
-            for node in tree.body
-            if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
-        ]:
-            initializers = [
-                node
-                for node in class_node.body
-                if isinstance(node, ast.FunctionDef) and node.name == "__init__"
-            ]
-            if len(initializers) != 1:
-                raise RuntimeError(
-                    f"{path}: {_CLASS_NAME} expected one initializer, "
-                    f"found {len(initializers)}"
-                )
-            initializer = initializers[0]
-            matching = [
-                argument
-                for argument in [
-                    *initializer.args.posonlyargs,
-                    *initializer.args.args,
-                    *initializer.args.kwonlyargs,
+        for repair in _REPAIRS:
+            for class_node in _class_nodes(tree, repair.class_name):
+                initializers = [
+                    node
+                    for node in class_node.body
+                    if isinstance(node, ast.FunctionDef)
+                    and node.name == "__init__"
                 ]
-                if argument.arg == _OLD
-            ]
-            if len(matching) != 1:
-                raise RuntimeError(
-                    f"{path}: {_CLASS_NAME}.{_OLD} expected once, "
-                    f"found {len(matching)}"
+                if len(initializers) != 1:
+                    raise RuntimeError(
+                        f"{path}: {repair.class_name} expected one initializer, "
+                        f"found {len(initializers)}"
+                    )
+                initializer = initializers[0]
+                matching = [
+                    argument
+                    for argument in _arguments(initializer)
+                    if argument.arg == repair.field_name
+                ]
+                if len(matching) != 1:
+                    raise RuntimeError(
+                        f"{path}: {repair.class_name}.{repair.field_name} "
+                        f"expected once, found {len(matching)}"
+                    )
+                matching[0].arg = repair.parameter_name
+                renamer = _BodyRenamer(
+                    repair.field_name,
+                    repair.parameter_name,
                 )
-            matching[0].arg = _NEW
-            renamer = _BodyRenamer()
-            initializer.body = [renamer.visit(statement) for statement in initializer.body]
-            constructor_count += 1
-            changed_paths.add(path)
+                initializer.body = [
+                    renamer.visit(statement)
+                    for statement in initializer.body
+                ]
+                constructor_count += 1
+                seen[repair] += 1
+                changed_paths.add(path)
 
     call_count = 0
     for path, tree in trees.items():
@@ -114,9 +150,15 @@ def normalize_tree(root: Path) -> tuple[int, int, int]:
         ast.fix_missing_locations(trees[path])
         path.write_text(ast.unparse(trees[path]) + "\n", encoding="utf-8")
 
-    if constructor_count != 1:
+    wrong_counts = {
+        f"{repair.class_name}.{repair.field_name}": count
+        for repair, count in seen.items()
+        if count != 1
+    }
+    if wrong_counts:
         raise RuntimeError(
-            f"native {_CLASS_NAME} constructor expected once, found {constructor_count}"
+            "native builtin parameter constructors expected once each: "
+            f"{wrong_counts}"
         )
 
     verified = {
@@ -124,39 +166,42 @@ def normalize_tree(root: Path) -> tuple[int, int, int]:
         for path in paths
     }
     for path, tree in verified.items():
-        for class_node in [
-            node
-            for node in tree.body
-            if isinstance(node, ast.ClassDef) and node.name == _CLASS_NAME
-        ]:
-            initializer = next(
-                node
-                for node in class_node.body
-                if isinstance(node, ast.FunctionDef) and node.name == "__init__"
-            )
-            names = [argument.arg for argument in initializer.args.args]
-            if _OLD in names or _NEW not in names:
-                raise RuntimeError(
-                    f"{path}: {_CLASS_NAME} builtin parameter repair was lost"
-                )
-            assignments = [
-                statement
-                for statement in initializer.body
-                if isinstance(statement, ast.Assign)
-                and len(statement.targets) == 1
-                and isinstance(statement.targets[0], ast.Attribute)
-                and isinstance(statement.targets[0].value, ast.Name)
-                and statement.targets[0].value.id == "self"
-                and statement.targets[0].attr == _OLD
-            ]
-            if not any(
-                isinstance(statement.value, ast.Name)
-                and statement.value.id == _NEW
-                for statement in assignments
-            ):
-                raise RuntimeError(
-                    f"{path}: {_CLASS_NAME} no longer copies {_NEW}"
+        for repair in _REPAIRS:
+            for class_node in _class_nodes(tree, repair.class_name):
+                initializer = next(
+                    node
+                    for node in class_node.body
+                    if isinstance(node, ast.FunctionDef)
+                    and node.name == "__init__"
                 )
+                names = [argument.arg for argument in _arguments(initializer)]
+                if (
+                    repair.field_name in names
+                    or repair.parameter_name not in names
+                ):
+                    raise RuntimeError(
+                        f"{path}: {repair.class_name} builtin parameter "
+                        "repair was lost"
+                    )
+                assignments = [
+                    statement
+                    for statement in initializer.body
+                    if isinstance(statement, ast.Assign)
+                    and len(statement.targets) == 1
+                    and isinstance(statement.targets[0], ast.Attribute)
+                    and isinstance(statement.targets[0].value, ast.Name)
+                    and statement.targets[0].value.id == "self"
+                    and statement.targets[0].attr == repair.field_name
+                ]
+                if not any(
+                    isinstance(statement.value, ast.Name)
+                    and statement.value.id == repair.parameter_name
+                    for statement in assignments
+                ):
+                    raise RuntimeError(
+                        f"{path}: {repair.class_name} no longer copies "
+                        f"{repair.parameter_name}"
+                    )
 
     return constructor_count, call_count, len(changed_paths)
 

From a1847dbf28ec05de6a9fc564491a9db5e01d5dfa Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:41:59 -0500
Subject: [PATCH 402/450] Normalize native runtime opcode specs

---
 tools/normalize_full_core_runtime_specs.py | 128 +++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 tools/normalize_full_core_runtime_specs.py

diff --git a/tools/normalize_full_core_runtime_specs.py b/tools/normalize_full_core_runtime_specs.py
new file mode 100644
index 00000000..5b8f384d
--- /dev/null
+++ b/tools/normalize_full_core_runtime_specs.py
@@ -0,0 +1,128 @@
+"""Encode CALL_KW and MAKE_CLASS constants as fixed native-safe lists.
+
+The pinned compiler infers heterogeneous tuple constants as strings when they are
+read back through ``CodeObject.constants``.  Keyword-call and class specs then
+use ``strlen`` and string indexing instead of tuple semantics.  Emit fixed lists
+and unpack their fields directly, matching the already-proven MAKE_FUNCTION
+normalization.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+VM_PATH = Path("src/portapy/core/vm.py")
+
+_FRONTEND_CALL_OLD = '''            names = tuple(keyword_names)
+            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+'''
+_FRONTEND_CALL_NEW = '''            names: list[object] = keyword_names
+            self.emit(Op.CALL_KW, self.constant([arg_specs, names]))
+'''
+_FRONTEND_CLASS_OLD = '''            spec = (node.name, body.finish(), base_count, has_keywords)
+            self.emit(Op.MAKE_CLASS, self.constant(spec))
+'''
+_FRONTEND_CLASS_NEW = '''            spec: list[object] = [node.name, body.finish(), base_count, has_keywords]
+            self.emit(Op.MAKE_CLASS, self.constant(spec))
+'''
+
+_VM_CLASS_OLD = '''                    spec = frame.code.constants[instr.arg]
+                    if not isinstance(spec, tuple) or len(spec) not in (3, 4): _raise_typed("TypeError: invalid class constant")
+                    class_name, body, base_count = spec[:3]
+                    has_keywords = bool(spec[3]) if len(spec) == 4 else False
+                    if not isinstance(class_name, str) or not isinstance(body, CodeObject): _raise_typed("TypeError: invalid class constant")
+'''
+_VM_CLASS_NEW = '''                    spec = frame.code.constants[instr.arg]
+                    class_name: str = spec[0]
+                    body: CodeObject = spec[1]
+                    base_count: int = spec[2]
+                    has_keywords: bool = spec[3]
+'''
+
+_VM_CALL_OLD = '''                    spec = frame.code.constants[instr.arg]
+                    if not isinstance(spec, tuple) or len(spec) != 2: _raise_typed("RuntimeError: invalid keyword call")
+                    positional_spec, names = spec
+                    if isinstance(positional_spec, int):
+                        positional_spec = tuple(False for _ in range(positional_spec))
+                    if not isinstance(positional_spec, tuple): _raise_typed("RuntimeError: invalid positional call")
+'''
+_VM_CALL_NEW = '''                    spec = frame.code.constants[instr.arg]
+                    positional_spec: list[bool] = spec[0]
+                    names: list[object] = spec[1]
+'''
+
+
+def _replace_one(source: str, old: str, new: str, *, label: str) -> str:
+    count = source.count(old)
+    if count != 1:
+        raise RuntimeError(f"{label}: expected one source shape, found {count}")
+    print("REPLACED", label, count)
+    return source.replace(old, new, 1)
+
+
+def main() -> int:
+    frontend = FRONTEND_PATH.read_text(encoding="utf-8")
+    frontend = _replace_one(
+        frontend,
+        _FRONTEND_CALL_OLD,
+        _FRONTEND_CALL_NEW,
+        label="native keyword-call list spec",
+    )
+    frontend = _replace_one(
+        frontend,
+        _FRONTEND_CLASS_OLD,
+        _FRONTEND_CLASS_NEW,
+        label="native class list spec",
+    )
+    FRONTEND_PATH.write_text(frontend, encoding="utf-8")
+
+    vm = VM_PATH.read_text(encoding="utf-8")
+    vm = _replace_one(
+        vm,
+        _VM_CLASS_OLD,
+        _VM_CLASS_NEW,
+        label="native class spec unpack",
+    )
+    vm = _replace_one(
+        vm,
+        _VM_CALL_OLD,
+        _VM_CALL_NEW,
+        label="native keyword-call spec unpack",
+    )
+    VM_PATH.write_text(vm, encoding="utf-8")
+
+    required_frontend = (
+        "self.constant([arg_specs, names])",
+        "spec: list[object] = [node.name, body.finish(), base_count, has_keywords]",
+    )
+    required_vm = (
+        "positional_spec: list[bool] = spec[0]",
+        "names: list[object] = spec[1]",
+        "class_name: str = spec[0]",
+        "body: CodeObject = spec[1]",
+        "base_count: int = spec[2]",
+        "has_keywords: bool = spec[3]",
+    )
+    missing = [marker for marker in required_frontend if marker not in frontend]
+    missing.extend(marker for marker in required_vm if marker not in vm)
+    if missing:
+        raise RuntimeError(f"native runtime spec validation failed: {missing}")
+
+    forbidden = (
+        "invalid keyword call",
+        "invalid positional call",
+        "invalid class constant",
+        "self.constant((tuple(arg_specs), names))",
+        "spec = (node.name, body.finish(), base_count, has_keywords)",
+    )
+    remaining = [marker for marker in forbidden if marker in vm or marker in frontend]
+    if remaining:
+        raise RuntimeError(f"unsafe native runtime specs remain: {remaining}")
+
+    print("NORMALIZED NATIVE RUNTIME SPECS", 2)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 59749e88286754c9dab8fe3a95121d77bfd4420c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:42:54 -0500
Subject: [PATCH 403/450] Run native runtime spec normalization

---
 tools/normalize_full_core_validation.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 4cc96700..8804124d 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -47,6 +47,7 @@
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
+from tools.normalize_full_core_runtime_specs import main as normalize_runtime_specs
 from tools.normalize_full_core_string_addition import main as normalize_string_addition
 from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
@@ -189,6 +190,9 @@ def main() -> int:
         ("native_node_fields", normalize_native_node_fields),
         ("pop_top", normalize_pop_top),
         ("make_function", normalize_make_function),
+        # Heterogeneous opcode tuples otherwise compile as strings. Convert the
+        # remaining keyword-call and class specs before final source unparsing.
+        ("runtime_specs", normalize_runtime_specs),
         ("collections", normalize_collections),
         ("builtins", normalize_builtins),
         ("tracebacks", normalize_tracebacks),

From adbbb6a964eda809deae15768af852c9da8da98a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:43:17 -0500
Subject: [PATCH 404/450] Test native runtime spec normalization

---
 .../test_normalize_full_core_runtime_specs.py | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 tests/test_normalize_full_core_runtime_specs.py

diff --git a/tests/test_normalize_full_core_runtime_specs.py b/tests/test_normalize_full_core_runtime_specs.py
new file mode 100644
index 00000000..2393ef02
--- /dev/null
+++ b/tests/test_normalize_full_core_runtime_specs.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tools import normalize_full_core_runtime_specs as normalizer
+
+
+FRONTEND = '''def lower():
+            keyword_names: list[object] = []
+            names = tuple(keyword_names)
+            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+            spec = (node.name, body.finish(), base_count, has_keywords)
+            self.emit(Op.MAKE_CLASS, self.constant(spec))
+'''
+
+VM = '''def run():
+                elif op is Op.MAKE_CLASS:
+                    spec = frame.code.constants[instr.arg]
+                    if not isinstance(spec, tuple) or len(spec) not in (3, 4): _raise_typed("TypeError: invalid class constant")
+                    class_name, body, base_count = spec[:3]
+                    has_keywords = bool(spec[3]) if len(spec) == 4 else False
+                    if not isinstance(class_name, str) or not isinstance(body, CodeObject): _raise_typed("TypeError: invalid class constant")
+                    bases = _full_core_probe_pop_tail(frame.stack, base_count)
+                elif op is Op.CALL_KW:
+                    spec = frame.code.constants[instr.arg]
+                    if not isinstance(spec, tuple) or len(spec) != 2: _raise_typed("RuntimeError: invalid keyword call")
+                    positional_spec, names = spec
+                    if isinstance(positional_spec, int):
+                        positional_spec = tuple(False for _ in range(positional_spec))
+                    if not isinstance(positional_spec, tuple): _raise_typed("RuntimeError: invalid positional call")
+                    positional_count = len(positional_spec)
+'''
+
+
+def test_converts_opcode_specs_to_fixed_lists(tmp_path: Path, monkeypatch) -> None:
+    frontend = tmp_path / "frontend.py"
+    vm = tmp_path / "vm.py"
+    frontend.write_text(FRONTEND, encoding="utf-8")
+    vm.write_text(VM, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+    monkeypatch.setattr(normalizer, "VM_PATH", vm)
+
+    assert normalizer.main() == 0
+
+    frontend_source = frontend.read_text(encoding="utf-8")
+    vm_source = vm.read_text(encoding="utf-8")
+    assert "self.constant([arg_specs, names])" in frontend_source
+    assert "[node.name, body.finish(), base_count, has_keywords]" in frontend_source
+    assert "positional_spec: list[bool] = spec[0]" in vm_source
+    assert "names: list[object] = spec[1]" in vm_source
+    assert "class_name: str = spec[0]" in vm_source
+    assert "body: CodeObject = spec[1]" in vm_source
+    assert "len(spec)" not in vm_source
+    assert "isinstance(spec, tuple)" not in vm_source
+
+
+def test_fails_closed_when_frontend_shape_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    frontend = tmp_path / "frontend.py"
+    vm = tmp_path / "vm.py"
+    frontend.write_text(FRONTEND.replace("names = tuple(keyword_names)", "names = keyword_names"), encoding="utf-8")
+    vm.write_text(VM, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+    monkeypatch.setattr(normalizer, "VM_PATH", vm)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "keyword-call list spec" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unknown frontend shape")

From 435dbd82ee55e8f8d41a06ae3a7c7b3ffd16171a Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:47:24 -0500
Subject: [PATCH 405/450] Make runtime spec normalization shape-independent

---
 tools/normalize_full_core_runtime_specs.py | 318 +++++++++++++++------
 1 file changed, 235 insertions(+), 83 deletions(-)

diff --git a/tools/normalize_full_core_runtime_specs.py b/tools/normalize_full_core_runtime_specs.py
index 5b8f384d..61b53a70 100644
--- a/tools/normalize_full_core_runtime_specs.py
+++ b/tools/normalize_full_core_runtime_specs.py
@@ -1,102 +1,254 @@
 """Encode CALL_KW and MAKE_CLASS constants as fixed native-safe lists.
 
 The pinned compiler infers heterogeneous tuple constants as strings when they are
-read back through ``CodeObject.constants``.  Keyword-call and class specs then
-use ``strlen`` and string indexing instead of tuple semantics.  Emit fixed lists
-and unpack their fields directly, matching the already-proven MAKE_FUNCTION
-normalization.
+read back through ``CodeObject.constants``. Keyword-call and class specs then use
+``strlen`` and string indexing instead of tuple semantics. Emit fixed lists and
+unpack their fields directly, matching the proven MAKE_FUNCTION normalization.
+
+This pass runs after every text-sensitive normalization and therefore rewrites the
+final Python AST rather than depending on an intermediate formatting shape.
 """
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 
 FRONTEND_PATH = Path("src/portapy/core/frontend.py")
 VM_PATH = Path("src/portapy/core/vm.py")
 
-_FRONTEND_CALL_OLD = '''            names = tuple(keyword_names)
-            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
-'''
-_FRONTEND_CALL_NEW = '''            names: list[object] = keyword_names
-            self.emit(Op.CALL_KW, self.constant([arg_specs, names]))
-'''
-_FRONTEND_CLASS_OLD = '''            spec = (node.name, body.finish(), base_count, has_keywords)
-            self.emit(Op.MAKE_CLASS, self.constant(spec))
-'''
-_FRONTEND_CLASS_NEW = '''            spec: list[object] = [node.name, body.finish(), base_count, has_keywords]
-            self.emit(Op.MAKE_CLASS, self.constant(spec))
-'''
-
-_VM_CLASS_OLD = '''                    spec = frame.code.constants[instr.arg]
-                    if not isinstance(spec, tuple) or len(spec) not in (3, 4): _raise_typed("TypeError: invalid class constant")
-                    class_name, body, base_count = spec[:3]
-                    has_keywords = bool(spec[3]) if len(spec) == 4 else False
-                    if not isinstance(class_name, str) or not isinstance(body, CodeObject): _raise_typed("TypeError: invalid class constant")
-'''
-_VM_CLASS_NEW = '''                    spec = frame.code.constants[instr.arg]
-                    class_name: str = spec[0]
-                    body: CodeObject = spec[1]
-                    base_count: int = spec[2]
-                    has_keywords: bool = spec[3]
-'''
-
-_VM_CALL_OLD = '''                    spec = frame.code.constants[instr.arg]
-                    if not isinstance(spec, tuple) or len(spec) != 2: _raise_typed("RuntimeError: invalid keyword call")
-                    positional_spec, names = spec
-                    if isinstance(positional_spec, int):
-                        positional_spec = tuple(False for _ in range(positional_spec))
-                    if not isinstance(positional_spec, tuple): _raise_typed("RuntimeError: invalid positional call")
-'''
-_VM_CALL_NEW = '''                    spec = frame.code.constants[instr.arg]
-                    positional_spec: list[bool] = spec[0]
-                    names: list[object] = spec[1]
-'''
-
-
-def _replace_one(source: str, old: str, new: str, *, label: str) -> str:
-    count = source.count(old)
-    if count != 1:
-        raise RuntimeError(f"{label}: expected one source shape, found {count}")
-    print("REPLACED", label, count)
-    return source.replace(old, new, 1)
 
+def _is_attribute(node: ast.AST, owner: str, name: str) -> bool:
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr == name
+        and isinstance(node.value, ast.Name)
+        and node.value.id == owner
+    )
 
-def main() -> int:
-    frontend = FRONTEND_PATH.read_text(encoding="utf-8")
-    frontend = _replace_one(
-        frontend,
-        _FRONTEND_CALL_OLD,
-        _FRONTEND_CALL_NEW,
-        label="native keyword-call list spec",
+
+def _is_self_method(node: ast.AST, name: str) -> bool:
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr == name
+        and isinstance(node.value, ast.Name)
+        and node.value.id == "self"
     )
-    frontend = _replace_one(
-        frontend,
-        _FRONTEND_CLASS_OLD,
-        _FRONTEND_CLASS_NEW,
-        label="native class list spec",
+
+
+def _assigned_name(node: ast.stmt) -> str | None:
+    if not isinstance(node, ast.Assign) or len(node.targets) != 1:
+        return None
+    target = node.targets[0]
+    return target.id if isinstance(target, ast.Name) else None
+
+
+def _contains_text(node: ast.AST, text: str) -> bool:
+    return any(
+        isinstance(item, ast.Constant)
+        and isinstance(item.value, str)
+        and text in item.value
+        for item in ast.walk(node)
     )
-    FRONTEND_PATH.write_text(frontend, encoding="utf-8")
-
-    vm = VM_PATH.read_text(encoding="utf-8")
-    vm = _replace_one(
-        vm,
-        _VM_CLASS_OLD,
-        _VM_CLASS_NEW,
-        label="native class spec unpack",
+
+
+class _FrontendRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.keyword_names = 0
+        self.keyword_specs = 0
+        self.class_specs = 0
+
+    def visit_Assign(self, node: ast.Assign) -> ast.AST:
+        self.generic_visit(node)
+        name = _assigned_name(node)
+        if (
+            name == "names"
+            and isinstance(node.value, ast.Call)
+            and isinstance(node.value.func, ast.Name)
+            and node.value.func.id == "tuple"
+            and len(node.value.args) == 1
+            and isinstance(node.value.args[0], ast.Name)
+            and node.value.args[0].id == "keyword_names"
+        ):
+            node.value = ast.Name(id="keyword_names", ctx=ast.Load())
+            self.keyword_names += 1
+        elif (
+            name == "spec"
+            and isinstance(node.value, ast.Tuple)
+            and len(node.value.elts) == 4
+            and ast.unparse(node.value.elts[0]) == "node.name"
+            and ast.unparse(node.value.elts[1]) == "body.finish()"
+            and ast.unparse(node.value.elts[2]) == "base_count"
+            and ast.unparse(node.value.elts[3]) == "has_keywords"
+        ):
+            node.value = ast.List(elts=node.value.elts, ctx=ast.Load())
+            self.class_specs += 1
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if not (
+            _is_self_method(node.func, "emit")
+            and len(node.args) >= 2
+            and _is_attribute(node.args[0], "Op", "CALL_KW")
+            and isinstance(node.args[1], ast.Call)
+            and _is_self_method(node.args[1].func, "constant")
+            and len(node.args[1].args) == 1
+        ):
+            return node
+        node.args[1].args[0] = ast.List(
+            elts=[
+                ast.Name(id="arg_specs", ctx=ast.Load()),
+                ast.Name(id="names", ctx=ast.Load()),
+            ],
+            ctx=ast.Load(),
+        )
+        self.keyword_specs += 1
+        return node
+
+
+def _is_opcode_branch(node: ast.If, opcode: str) -> bool:
+    test = node.test
+    return (
+        isinstance(test, ast.Compare)
+        and isinstance(test.left, ast.Name)
+        and test.left.id == "op"
+        and len(test.ops) == 1
+        and isinstance(test.ops[0], ast.Is)
+        and len(test.comparators) == 1
+        and _is_attribute(test.comparators[0], "Op", opcode)
     )
-    vm = _replace_one(
-        vm,
-        _VM_CALL_OLD,
-        _VM_CALL_NEW,
-        label="native keyword-call spec unpack",
+
+
+def _annotation(name: str, type_name: str, index: int) -> ast.AnnAssign:
+    return ast.AnnAssign(
+        target=ast.Name(id=name, ctx=ast.Store()),
+        annotation=ast.Name(id=type_name, ctx=ast.Load()),
+        value=ast.Subscript(
+            value=ast.Name(id="spec", ctx=ast.Load()),
+            slice=ast.Constant(index),
+            ctx=ast.Load(),
+        ),
+        simple=1,
     )
-    VM_PATH.write_text(vm, encoding="utf-8")
 
-    required_frontend = (
-        "self.constant([arg_specs, names])",
-        "spec: list[object] = [node.name, body.finish(), base_count, has_keywords]",
+
+def _list_annotation(name: str, element_type: str, index: int) -> ast.AnnAssign:
+    return ast.AnnAssign(
+        target=ast.Name(id=name, ctx=ast.Store()),
+        annotation=ast.Subscript(
+            value=ast.Name(id="list", ctx=ast.Load()),
+            slice=ast.Name(id=element_type, ctx=ast.Load()),
+            ctx=ast.Load(),
+        ),
+        value=ast.Subscript(
+            value=ast.Name(id="spec", ctx=ast.Load()),
+            slice=ast.Constant(index),
+            ctx=ast.Load(),
+        ),
+        simple=1,
     )
-    required_vm = (
+
+
+def _replace_validation_prefix(
+    branch: ast.If,
+    *,
+    error_texts: tuple[str, ...],
+    assignments: list[ast.stmt],
+) -> None:
+    spec_index = next(
+        (index for index, statement in enumerate(branch.body) if _assigned_name(statement) == "spec"),
+        -1,
+    )
+    if spec_index < 0:
+        raise RuntimeError("native runtime spec branch has no spec assignment")
+    matched = [
+        index
+        for index, statement in enumerate(branch.body)
+        if any(_contains_text(statement, text) for text in error_texts)
+    ]
+    if not matched:
+        raise RuntimeError(
+            f"native runtime spec branch has no validation markers: {error_texts}"
+        )
+    end = max(matched)
+    if end <= spec_index:
+        raise RuntimeError("native runtime spec validation precedes spec assignment")
+    branch.body = branch.body[: spec_index + 1] + assignments + branch.body[end + 1 :]
+
+
+class _VMRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.class_specs = 0
+        self.keyword_specs = 0
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        if _is_opcode_branch(node, "MAKE_CLASS"):
+            _replace_validation_prefix(
+                node,
+                error_texts=("invalid class constant",),
+                assignments=[
+                    _annotation("class_name", "str", 0),
+                    _annotation("body", "CodeObject", 1),
+                    _annotation("base_count", "int", 2),
+                    _annotation("has_keywords", "bool", 3),
+                ],
+            )
+            self.class_specs += 1
+        elif _is_opcode_branch(node, "CALL_KW"):
+            _replace_validation_prefix(
+                node,
+                error_texts=("invalid keyword call", "invalid positional call"),
+                assignments=[
+                    _list_annotation("positional_spec", "bool", 0),
+                    _list_annotation("names", "object", 1),
+                ],
+            )
+            self.keyword_specs += 1
+        return node
+
+
+def _write_rewritten(path: Path, tree: ast.Module) -> str:
+    ast.fix_missing_locations(tree)
+    source = ast.unparse(tree) + "\n"
+    path.write_text(source, encoding="utf-8")
+    return source
+
+
+def main() -> int:
+    frontend_tree = ast.parse(
+        FRONTEND_PATH.read_text(encoding="utf-8"),
+        filename=str(FRONTEND_PATH),
+    )
+    frontend_rewriter = _FrontendRewrite()
+    frontend_tree = frontend_rewriter.visit(frontend_tree)
+    frontend_counts = (
+        frontend_rewriter.keyword_names,
+        frontend_rewriter.keyword_specs,
+        frontend_rewriter.class_specs,
+    )
+    if frontend_counts != (1, 1, 1):
+        raise RuntimeError(
+            "native frontend runtime specs expected one keyword-name, keyword-spec, "
+            f"and class-spec rewrite; found {frontend_counts}"
+        )
+    frontend = _write_rewritten(FRONTEND_PATH, frontend_tree)
+
+    vm_tree = ast.parse(VM_PATH.read_text(encoding="utf-8"), filename=str(VM_PATH))
+    vm_rewriter = _VMRewrite()
+    vm_tree = vm_rewriter.visit(vm_tree)
+    vm_counts = (vm_rewriter.keyword_specs, vm_rewriter.class_specs)
+    if vm_counts != (1, 1):
+        raise RuntimeError(
+            "native VM runtime specs expected one keyword and one class branch; "
+            f"found {vm_counts}"
+        )
+    vm = _write_rewritten(VM_PATH, vm_tree)
+
+    required = (
+        "self.constant([arg_specs, names])",
+        "spec = [node.name, body.finish(), base_count, has_keywords]",
         "positional_spec: list[bool] = spec[0]",
         "names: list[object] = spec[1]",
         "class_name: str = spec[0]",
@@ -104,8 +256,8 @@ def main() -> int:
         "base_count: int = spec[2]",
         "has_keywords: bool = spec[3]",
     )
-    missing = [marker for marker in required_frontend if marker not in frontend]
-    missing.extend(marker for marker in required_vm if marker not in vm)
+    joined = frontend + vm
+    missing = [marker for marker in required if marker not in joined]
     if missing:
         raise RuntimeError(f"native runtime spec validation failed: {missing}")
 
@@ -116,11 +268,11 @@ def main() -> int:
         "self.constant((tuple(arg_specs), names))",
         "spec = (node.name, body.finish(), base_count, has_keywords)",
     )
-    remaining = [marker for marker in forbidden if marker in vm or marker in frontend]
+    remaining = [marker for marker in forbidden if marker in joined]
     if remaining:
         raise RuntimeError(f"unsafe native runtime specs remain: {remaining}")
 
-    print("NORMALIZED NATIVE RUNTIME SPECS", 2)
+    print("NORMALIZED NATIVE RUNTIME SPECS", *frontend_counts, *vm_counts)
     return 0
 
 

From ddf9d4f19c65353d110191c5cd3d7e348e340ddf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:48:36 -0500
Subject: [PATCH 406/450] Run runtime spec pass after text normalizers

---
 tools/normalize_full_core_validation.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 8804124d..db546b14 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -190,9 +190,6 @@ def main() -> int:
         ("native_node_fields", normalize_native_node_fields),
         ("pop_top", normalize_pop_top),
         ("make_function", normalize_make_function),
-        # Heterogeneous opcode tuples otherwise compile as strings. Convert the
-        # remaining keyword-call and class specs before final source unparsing.
-        ("runtime_specs", normalize_runtime_specs),
         ("collections", normalize_collections),
         ("builtins", normalize_builtins),
         ("tracebacks", normalize_tracebacks),
@@ -201,6 +198,9 @@ def main() -> int:
         ("truthiness", normalize_truthiness),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
+        # This AST pass intentionally runs only after all text-sensitive VM
+        # passes, replacing heterogeneous opcode tuples before final unparsing.
+        ("runtime_specs", normalize_runtime_specs),
         # Parameter collisions include explicit functions and dataclass-generated
         # initializers. Repair them before the final local-variable collision pass.
         ("parameter_name_collisions", normalize_parameter_name_collisions),

From e77348a271687944cf53b3399675b488a0d7b6de Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:49:06 -0500
Subject: [PATCH 407/450] Test AST runtime spec normalization

---
 .../test_normalize_full_core_runtime_specs.py | 60 +++++++++++--------
 1 file changed, 36 insertions(+), 24 deletions(-)

diff --git a/tests/test_normalize_full_core_runtime_specs.py b/tests/test_normalize_full_core_runtime_specs.py
index 2393ef02..8db1518e 100644
--- a/tests/test_normalize_full_core_runtime_specs.py
+++ b/tests/test_normalize_full_core_runtime_specs.py
@@ -1,34 +1,41 @@
 from __future__ import annotations
 
+import ast
 from pathlib import Path
 
 from tools import normalize_full_core_runtime_specs as normalizer
 
 
-FRONTEND = '''def lower():
-            keyword_names: list[object] = []
-            names = tuple(keyword_names)
-            self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
-            spec = (node.name, body.finish(), base_count, has_keywords)
-            self.emit(Op.MAKE_CLASS, self.constant(spec))
+FRONTEND = '''class Lowerer:
+    def lower(self, node, body, base_count, has_keywords, arg_specs):
+        keyword_names: list[object] = []
+        names = tuple(keyword_names)
+        self.emit(Op.CALL_KW, self.constant((tuple(arg_specs), names)))
+        spec = (node.name, body.finish(), base_count, has_keywords)
+        self.emit(Op.MAKE_CLASS, self.constant(spec))
 '''
 
-VM = '''def run():
-                elif op is Op.MAKE_CLASS:
-                    spec = frame.code.constants[instr.arg]
-                    if not isinstance(spec, tuple) or len(spec) not in (3, 4): _raise_typed("TypeError: invalid class constant")
-                    class_name, body, base_count = spec[:3]
-                    has_keywords = bool(spec[3]) if len(spec) == 4 else False
-                    if not isinstance(class_name, str) or not isinstance(body, CodeObject): _raise_typed("TypeError: invalid class constant")
-                    bases = _full_core_probe_pop_tail(frame.stack, base_count)
-                elif op is Op.CALL_KW:
-                    spec = frame.code.constants[instr.arg]
-                    if not isinstance(spec, tuple) or len(spec) != 2: _raise_typed("RuntimeError: invalid keyword call")
-                    positional_spec, names = spec
-                    if isinstance(positional_spec, int):
-                        positional_spec = tuple(False for _ in range(positional_spec))
-                    if not isinstance(positional_spec, tuple): _raise_typed("RuntimeError: invalid positional call")
-                    positional_count = len(positional_spec)
+VM = '''class VirtualMachine:
+    def run(self, op, frame, instr):
+        if op is Op.MAKE_CLASS:
+            spec = frame.code.constants[instr.arg]
+            if not isinstance(spec, tuple) or len(spec) not in (3, 4):
+                _raise_typed("TypeError: invalid class constant")
+            class_name, body, base_count = spec[:3]
+            has_keywords = bool(spec[3]) if len(spec) == 4 else False
+            if not isinstance(class_name, str) or not isinstance(body, CodeObject):
+                _raise_typed("TypeError: invalid class constant")
+            bases = _full_core_probe_pop_tail(frame.stack, base_count)
+        elif op is Op.CALL_KW:
+            spec = frame.code.constants[instr.arg]
+            if not isinstance(spec, tuple) or len(spec) != 2:
+                _raise_typed("RuntimeError: invalid keyword call")
+            positional_spec, names = spec
+            if isinstance(positional_spec, int):
+                positional_spec = tuple(False for _ in range(positional_spec))
+            if not isinstance(positional_spec, tuple):
+                _raise_typed("RuntimeError: invalid positional call")
+            positional_count = len(positional_spec)
 '''
 
 
@@ -52,6 +59,8 @@ def test_converts_opcode_specs_to_fixed_lists(tmp_path: Path, monkeypatch) -> No
     assert "body: CodeObject = spec[1]" in vm_source
     assert "len(spec)" not in vm_source
     assert "isinstance(spec, tuple)" not in vm_source
+    ast.parse(frontend_source)
+    ast.parse(vm_source)
 
 
 def test_fails_closed_when_frontend_shape_changes(
@@ -60,7 +69,10 @@ def test_fails_closed_when_frontend_shape_changes(
 ) -> None:
     frontend = tmp_path / "frontend.py"
     vm = tmp_path / "vm.py"
-    frontend.write_text(FRONTEND.replace("names = tuple(keyword_names)", "names = keyword_names"), encoding="utf-8")
+    frontend.write_text(
+        FRONTEND.replace("names = tuple(keyword_names)", "names = keyword_names"),
+        encoding="utf-8",
+    )
     vm.write_text(VM, encoding="utf-8")
     monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
     monkeypatch.setattr(normalizer, "VM_PATH", vm)
@@ -68,6 +80,6 @@ def test_fails_closed_when_frontend_shape_changes(
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "keyword-call list spec" in str(error)
+        assert "frontend runtime specs" in str(error)
     else:
         raise AssertionError("normalizer accepted an unknown frontend shape")

From e90c966aa3f6adb2bbc5eb2aa5ae55c9068914e8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:52:31 -0500
Subject: [PATCH 408/450] Normalize native VM iteration and imports

---
 tools/normalize_full_core_runtime_dispatch.py | 176 ++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 tools/normalize_full_core_runtime_dispatch.py

diff --git a/tools/normalize_full_core_runtime_dispatch.py b/tools/normalize_full_core_runtime_dispatch.py
new file mode 100644
index 00000000..3a65f846
--- /dev/null
+++ b/tools/normalize_full_core_runtime_dispatch.py
@@ -0,0 +1,176 @@
+"""Remove host-introspection hazards from native VM iteration and imports.
+
+``GET_ITER`` previously evaluated ``type(value).__name__`` before calling
+``iter``. Native values are untagged pointers, so asking for the host type name
+of a list can reinterpret the list header as a dictionary and crash. Iteration
+needs no pre-conversion: Python's iterator protocol already handles lists,
+dicts, and dictionary views.
+
+Import handlers also used ``callable(loader)`` and direct ``loader(...)`` calls.
+Native-compiled functions and VM callables are valid dispatcher targets even
+when the host-style predicate rejects them, so check only for absence and route
+calls through ``VirtualMachine._call``.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+
+
+def _is_attribute(node: ast.AST, owner: str, name: str) -> bool:
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr == name
+        and isinstance(node.value, ast.Name)
+        and node.value.id == owner
+    )
+
+
+def _is_opcode_branch(node: ast.If, opcode: str) -> bool:
+    test = node.test
+    return (
+        isinstance(test, ast.Compare)
+        and isinstance(test.left, ast.Name)
+        and test.left.id == "op"
+        and len(test.ops) == 1
+        and isinstance(test.ops[0], ast.Is)
+        and len(test.comparators) == 1
+        and _is_attribute(test.comparators[0], "Op", opcode)
+    )
+
+
+def _loader_presence_test() -> ast.Compare:
+    return ast.Compare(
+        left=ast.Name(id="loader", ctx=ast.Load()),
+        ops=[ast.Is()],
+        comparators=[ast.Constant(None)],
+    )
+
+
+class _ImportRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.presence_checks = 0
+        self.calls = 0
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
+        self.generic_visit(node)
+        if not isinstance(node.op, ast.Not) or not isinstance(node.operand, ast.Call):
+            return node
+        call = node.operand
+        if (
+            isinstance(call.func, ast.Name)
+            and call.func.id == "callable"
+            and len(call.args) == 1
+            and isinstance(call.args[0], ast.Name)
+            and call.args[0].id == "loader"
+        ):
+            self.presence_checks += 1
+            return ast.copy_location(_loader_presence_test(), node)
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        if not (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "loader"
+            and len(node.args) == 1
+            and not node.keywords
+        ):
+            return node
+        self.calls += 1
+        return ast.copy_location(
+            ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr="_call",
+                    ctx=ast.Load(),
+                ),
+                args=[
+                    ast.Name(id="loader", ctx=ast.Load()),
+                    ast.List(elts=[node.args[0]], ctx=ast.Load()),
+                ],
+                keywords=[],
+            ),
+            node,
+        )
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.iteration = 0
+        self.import_branches = 0
+        self.presence_checks = 0
+        self.loader_calls = 0
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        if _is_opcode_branch(node, "GET_ITER"):
+            node.body = ast.parse(
+                "value = frame.stack.pop()\n"
+                "frame.stack.append(iter(value))\n"
+            ).body
+            self.iteration += 1
+            return node
+        if any(
+            _is_opcode_branch(node, opcode)
+            for opcode in ("IMPORT_NAME", "IMPORT_FROM", "IMPORT_ROOT", "IMPORT_RELATIVE_FROM")
+        ):
+            rewriter = _ImportRewrite()
+            node.body = [rewriter.visit(statement) for statement in node.body]
+            self.import_branches += 1
+            self.presence_checks += rewriter.presence_checks
+            self.loader_calls += rewriter.calls
+        return node
+
+
+def main() -> int:
+    tree = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    rewriter = _Rewrite()
+    tree = rewriter.visit(tree)
+    counts = (
+        rewriter.iteration,
+        rewriter.import_branches,
+        rewriter.presence_checks,
+        rewriter.loader_calls,
+    )
+    if rewriter.iteration != 1 or rewriter.import_branches != 4:
+        raise RuntimeError(
+            "native runtime dispatch expected one iterator and four import branches; "
+            f"found {counts}"
+        )
+    if rewriter.presence_checks < 4 or rewriter.loader_calls < 8:
+        raise RuntimeError(
+            "native runtime import dispatch missed loader operations; "
+            f"found {counts}"
+        )
+
+    ast.fix_missing_locations(tree)
+    source = ast.unparse(tree) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        "frame.stack.append(iter(value))",
+        "loader is None",
+        "self._call(loader, [imported])",
+        "self._call(loader, [top_level])",
+    )
+    missing = [marker for marker in required if marker not in source]
+    forbidden = (
+        'type(value).__name__ in {',
+        "callable(loader)",
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if missing or remaining:
+        raise RuntimeError(
+            f"native runtime dispatch validation failed: missing={missing}, remaining={remaining}"
+        )
+
+    print("NORMALIZED NATIVE RUNTIME DISPATCH", *counts)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 873f6314427ebd2a7bc5bb7128009e1ecdda4881 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:53:40 -0500
Subject: [PATCH 409/450] Run native runtime dispatch normalization

---
 tools/normalize_full_core_validation.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index db546b14..71c5a476 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -47,6 +47,7 @@
 from tools.normalize_full_core_pattern_slices import main as normalize_pattern_slices
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
+from tools.normalize_full_core_runtime_dispatch import main as normalize_runtime_dispatch
 from tools.normalize_full_core_runtime_specs import main as normalize_runtime_specs
 from tools.normalize_full_core_string_addition import main as normalize_string_addition
 from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
@@ -198,9 +199,10 @@ def main() -> int:
         ("truthiness", normalize_truthiness),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
-        # This AST pass intentionally runs only after all text-sensitive VM
-        # passes, replacing heterogeneous opcode tuples before final unparsing.
+        # These AST passes intentionally run only after all text-sensitive VM
+        # passes, replacing unsafe opcode specs and host introspection.
         ("runtime_specs", normalize_runtime_specs),
+        ("runtime_dispatch", normalize_runtime_dispatch),
         # Parameter collisions include explicit functions and dataclass-generated
         # initializers. Repair them before the final local-variable collision pass.
         ("parameter_name_collisions", normalize_parameter_name_collisions),

From b38ea0097dc103bb0b2b861240895964388d9893 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:54:07 -0500
Subject: [PATCH 410/450] Test native runtime dispatch normalization

---
 ...st_normalize_full_core_runtime_dispatch.py | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 tests/test_normalize_full_core_runtime_dispatch.py

diff --git a/tests/test_normalize_full_core_runtime_dispatch.py b/tests/test_normalize_full_core_runtime_dispatch.py
new file mode 100644
index 00000000..9a549691
--- /dev/null
+++ b/tests/test_normalize_full_core_runtime_dispatch.py
@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_runtime_dispatch as normalizer
+
+
+SOURCE = '''class VirtualMachine:
+    def _call(self, target, args):
+        return target(*args)
+
+    def run(self, op, frame, instr):
+        if op is Op.GET_ITER:
+            value = frame.stack.pop()
+            if isinstance(value, dict) or type(value).__name__ in {"dict_keys"}:
+                value = list(value)
+            frame.stack.append(iter(value))
+        elif op is Op.IMPORT_NAME:
+            loader = frame.globals.get("__pyinbin_import__")
+            if not callable(loader):
+                _raise_typed("ImportError: loader is not configured")
+            imported = frame.code.names[instr.arg]
+            top_level = imported.split(".", 1)[0]
+            loader(top_level)
+            frame.stack.append(loader(imported))
+        elif op is Op.IMPORT_FROM:
+            module = frame.stack.pop()
+            member = frame.code.names[instr.arg]
+            loader = frame.globals.get("__pyinbin_import__")
+            module_name = getattr(module, "__name__", None)
+            if not callable(loader) or not isinstance(module_name, str):
+                raise AttributeError(member)
+            value = loader(module_name)
+            frame.stack.append(value)
+        elif op is Op.IMPORT_ROOT:
+            loader = frame.globals.get("__pyinbin_import__")
+            if not callable(loader):
+                _raise_typed("ImportError: loader is not configured")
+            imported = frame.code.names[instr.arg]
+            top_level = imported.split(".", 1)[0]
+            loader(top_level)
+            loader(imported)
+            loader("sys")
+            frame.stack.append(loader(top_level))
+        elif op is Op.IMPORT_RELATIVE_FROM:
+            loader = frame.globals.get("__pyinbin_import__")
+            if not callable(loader):
+                _raise_typed("ImportError: loader is not configured")
+            base = "pkg"
+            member = "item"
+            loader(base)
+            loader(base + "." + member)
+            loader(base)
+            loader(base + "." + member)
+'''
+
+
+def test_removes_native_iteration_and_loader_hazards(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "frame.stack.append(iter(value))" in source
+    assert "type(value).__name__" not in source
+    assert "callable(loader)" not in source
+    assert "loader is None" in source
+    assert "self._call(loader, [imported])" in source
+    assert "self._call(loader, [top_level])" in source
+    ast.parse(source)
+
+
+def test_fails_closed_without_all_import_branches(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(
+        SOURCE.replace("elif op is Op.IMPORT_RELATIVE_FROM:", "elif op is Op.OTHER:"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "four import branches" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing import branch")

From e0b909e638575d94dac372ba38cd606fc9432e36 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 20:59:55 -0500
Subject: [PATCH 411/450] Use typed native opcode spec objects

---
 tools/normalize_full_core_runtime_specs.py | 211 ++++++++++++++++-----
 1 file changed, 159 insertions(+), 52 deletions(-)

diff --git a/tools/normalize_full_core_runtime_specs.py b/tools/normalize_full_core_runtime_specs.py
index 61b53a70..5c87b91f 100644
--- a/tools/normalize_full_core_runtime_specs.py
+++ b/tools/normalize_full_core_runtime_specs.py
@@ -1,9 +1,10 @@
-"""Encode CALL_KW and MAKE_CLASS constants as fixed native-safe lists.
+"""Encode CALL_KW and MAKE_CLASS constants as typed native-safe objects.
 
-The pinned compiler infers heterogeneous tuple constants as strings when they are
-read back through ``CodeObject.constants``. Keyword-call and class specs then use
-``strlen`` and string indexing instead of tuple semantics. Emit fixed lists and
-unpack their fields directly, matching the proven MAKE_FUNCTION normalization.
+The pinned compiler cannot safely lower heterogeneous tuple/list constants. When
+CALL_KW and MAKE_CLASS metadata is stored as a tuple, reads through
+``CodeObject.constants`` are inferred as strings; a heterogeneous list is rejected
+at compile time. Dedicated spec classes preserve the exact field types without
+runtime tuple inspection or mixed-element containers.
 
 This pass runs after every text-sensitive normalization and therefore rewrites the
 final Python AST rather than depending on an intermediate formatting shape.
@@ -14,9 +15,38 @@
 from pathlib import Path
 
 
+BYTECODE_PATH = Path("src/portapy/core/bytecode.py")
 FRONTEND_PATH = Path("src/portapy/core/frontend.py")
 VM_PATH = Path("src/portapy/core/vm.py")
 
+_KEYWORD_SPEC = "_NativeKeywordCallSpec"
+_CLASS_SPEC = "_NativeClassSpec"
+
+_SPEC_CLASSES = '''
+class _NativeKeywordCallSpec:
+    def __init__(
+        self,
+        positional_spec: list[bool],
+        names: list[object],
+    ) -> None:
+        self.positional_spec = positional_spec
+        self.names = names
+
+
+class _NativeClassSpec:
+    def __init__(
+        self,
+        class_name: str,
+        body: CodeObject,
+        base_count: int,
+        has_keywords: bool,
+    ) -> None:
+        self.class_name = class_name
+        self.body = body
+        self.base_count = base_count
+        self.has_keywords = has_keywords
+'''
+
 
 def _is_attribute(node: ast.AST, owner: str, name: str) -> bool:
     return (
@@ -52,6 +82,44 @@ def _contains_text(node: ast.AST, text: str) -> bool:
     )
 
 
+def _add_imports(tree: ast.Module, names: tuple[str, ...]) -> int:
+    matches = [
+        node
+        for node in tree.body
+        if isinstance(node, ast.ImportFrom)
+        and node.level == 1
+        and node.module == "bytecode"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"native bytecode import expected once, found {len(matches)}"
+        )
+    statement = matches[0]
+    existing = {alias.name for alias in statement.names}
+    added = 0
+    for name in names:
+        if name not in existing:
+            statement.names.append(ast.alias(name=name))
+            added += 1
+    return added
+
+
+def _install_spec_classes(tree: ast.Module) -> int:
+    existing = {
+        node.name
+        for node in tree.body
+        if isinstance(node, ast.ClassDef)
+        and node.name in {_KEYWORD_SPEC, _CLASS_SPEC}
+    }
+    if existing:
+        raise RuntimeError(
+            f"native opcode spec classes already exist: {sorted(existing)}"
+        )
+    classes = ast.parse(_SPEC_CLASSES).body
+    tree.body.extend(classes)
+    return len(classes)
+
+
 class _FrontendRewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.keyword_names = 0
@@ -81,7 +149,11 @@ def visit_Assign(self, node: ast.Assign) -> ast.AST:
             and ast.unparse(node.value.elts[2]) == "base_count"
             and ast.unparse(node.value.elts[3]) == "has_keywords"
         ):
-            node.value = ast.List(elts=node.value.elts, ctx=ast.Load())
+            node.value = ast.Call(
+                func=ast.Name(id=_CLASS_SPEC, ctx=ast.Load()),
+                args=node.value.elts,
+                keywords=[],
+            )
             self.class_specs += 1
         return node
 
@@ -96,12 +168,13 @@ def visit_Call(self, node: ast.Call) -> ast.AST:
             and len(node.args[1].args) == 1
         ):
             return node
-        node.args[1].args[0] = ast.List(
-            elts=[
+        node.args[1].args[0] = ast.Call(
+            func=ast.Name(id=_KEYWORD_SPEC, ctx=ast.Load()),
+            args=[
                 ast.Name(id="arg_specs", ctx=ast.Load()),
                 ast.Name(id="names", ctx=ast.Load()),
             ],
-            ctx=ast.Load(),
+            keywords=[],
         )
         self.keyword_specs += 1
         return node
@@ -120,33 +193,39 @@ def _is_opcode_branch(node: ast.If, opcode: str) -> bool:
     )
 
 
-def _annotation(name: str, type_name: str, index: int) -> ast.AnnAssign:
+def _typed_spec_assignment(type_name: str) -> ast.AnnAssign:
     return ast.AnnAssign(
-        target=ast.Name(id=name, ctx=ast.Store()),
+        target=ast.Name(id="spec", ctx=ast.Store()),
         annotation=ast.Name(id=type_name, ctx=ast.Load()),
         value=ast.Subscript(
-            value=ast.Name(id="spec", ctx=ast.Load()),
-            slice=ast.Constant(index),
+            value=ast.Attribute(
+                value=ast.Attribute(
+                    value=ast.Name(id="frame", ctx=ast.Load()),
+                    attr="code",
+                    ctx=ast.Load(),
+                ),
+                attr="constants",
+                ctx=ast.Load(),
+            ),
+            slice=ast.Attribute(
+                value=ast.Name(id="instr", ctx=ast.Load()),
+                attr="arg",
+                ctx=ast.Load(),
+            ),
             ctx=ast.Load(),
         ),
         simple=1,
     )
 
 
-def _list_annotation(name: str, element_type: str, index: int) -> ast.AnnAssign:
-    return ast.AnnAssign(
-        target=ast.Name(id=name, ctx=ast.Store()),
-        annotation=ast.Subscript(
-            value=ast.Name(id="list", ctx=ast.Load()),
-            slice=ast.Name(id=element_type, ctx=ast.Load()),
-            ctx=ast.Load(),
-        ),
-        value=ast.Subscript(
+def _field_assignment(name: str, field: str) -> ast.Assign:
+    return ast.Assign(
+        targets=[ast.Name(id=name, ctx=ast.Store())],
+        value=ast.Attribute(
             value=ast.Name(id="spec", ctx=ast.Load()),
-            slice=ast.Constant(index),
+            attr=field,
             ctx=ast.Load(),
         ),
-        simple=1,
     )
 
 
@@ -154,10 +233,14 @@ def _replace_validation_prefix(
     branch: ast.If,
     *,
     error_texts: tuple[str, ...],
-    assignments: list[ast.stmt],
+    replacements: list[ast.stmt],
 ) -> None:
     spec_index = next(
-        (index for index, statement in enumerate(branch.body) if _assigned_name(statement) == "spec"),
+        (
+            index
+            for index, statement in enumerate(branch.body)
+            if _assigned_name(statement) == "spec"
+        ),
         -1,
     )
     if spec_index < 0:
@@ -174,7 +257,7 @@ def _replace_validation_prefix(
     end = max(matched)
     if end <= spec_index:
         raise RuntimeError("native runtime spec validation precedes spec assignment")
-    branch.body = branch.body[: spec_index + 1] + assignments + branch.body[end + 1 :]
+    branch.body = branch.body[:spec_index] + replacements + branch.body[end + 1 :]
 
 
 class _VMRewrite(ast.NodeTransformer):
@@ -188,11 +271,12 @@ def visit_If(self, node: ast.If) -> ast.AST:
             _replace_validation_prefix(
                 node,
                 error_texts=("invalid class constant",),
-                assignments=[
-                    _annotation("class_name", "str", 0),
-                    _annotation("body", "CodeObject", 1),
-                    _annotation("base_count", "int", 2),
-                    _annotation("has_keywords", "bool", 3),
+                replacements=[
+                    _typed_spec_assignment(_CLASS_SPEC),
+                    _field_assignment("class_name", "class_name"),
+                    _field_assignment("body", "body"),
+                    _field_assignment("base_count", "base_count"),
+                    _field_assignment("has_keywords", "has_keywords"),
                 ],
             )
             self.class_specs += 1
@@ -200,9 +284,10 @@ def visit_If(self, node: ast.If) -> ast.AST:
             _replace_validation_prefix(
                 node,
                 error_texts=("invalid keyword call", "invalid positional call"),
-                assignments=[
-                    _list_annotation("positional_spec", "bool", 0),
-                    _list_annotation("names", "object", 1),
+                replacements=[
+                    _typed_spec_assignment(_KEYWORD_SPEC),
+                    _field_assignment("positional_spec", "positional_spec"),
+                    _field_assignment("names", "names"),
                 ],
             )
             self.keyword_specs += 1
@@ -217,46 +302,62 @@ def _write_rewritten(path: Path, tree: ast.Module) -> str:
 
 
 def main() -> int:
+    bytecode_tree = ast.parse(
+        BYTECODE_PATH.read_text(encoding="utf-8"),
+        filename=str(BYTECODE_PATH),
+    )
+    installed = _install_spec_classes(bytecode_tree)
+    if installed != 2:
+        raise RuntimeError(f"native opcode spec class count changed: {installed}")
+    bytecode = _write_rewritten(BYTECODE_PATH, bytecode_tree)
+
     frontend_tree = ast.parse(
         FRONTEND_PATH.read_text(encoding="utf-8"),
         filename=str(FRONTEND_PATH),
     )
+    frontend_imports = _add_imports(frontend_tree, (_KEYWORD_SPEC, _CLASS_SPEC))
     frontend_rewriter = _FrontendRewrite()
     frontend_tree = frontend_rewriter.visit(frontend_tree)
     frontend_counts = (
+        frontend_imports,
         frontend_rewriter.keyword_names,
         frontend_rewriter.keyword_specs,
         frontend_rewriter.class_specs,
     )
-    if frontend_counts != (1, 1, 1):
+    if frontend_counts != (2, 1, 1, 1):
         raise RuntimeError(
-            "native frontend runtime specs expected one keyword-name, keyword-spec, "
-            f"and class-spec rewrite; found {frontend_counts}"
+            "native frontend runtime specs expected two imports and one of each "
+            f"rewrite; found {frontend_counts}"
         )
     frontend = _write_rewritten(FRONTEND_PATH, frontend_tree)
 
     vm_tree = ast.parse(VM_PATH.read_text(encoding="utf-8"), filename=str(VM_PATH))
+    vm_imports = _add_imports(vm_tree, (_KEYWORD_SPEC, _CLASS_SPEC))
     vm_rewriter = _VMRewrite()
     vm_tree = vm_rewriter.visit(vm_tree)
-    vm_counts = (vm_rewriter.keyword_specs, vm_rewriter.class_specs)
-    if vm_counts != (1, 1):
+    vm_counts = (vm_imports, vm_rewriter.keyword_specs, vm_rewriter.class_specs)
+    if vm_counts != (2, 1, 1):
         raise RuntimeError(
-            "native VM runtime specs expected one keyword and one class branch; "
-            f"found {vm_counts}"
+            "native VM runtime specs expected two imports and one keyword/class "
+            f"branch; found {vm_counts}"
         )
     vm = _write_rewritten(VM_PATH, vm_tree)
 
+    joined = bytecode + frontend + vm
     required = (
-        "self.constant([arg_specs, names])",
-        "spec = [node.name, body.finish(), base_count, has_keywords]",
-        "positional_spec: list[bool] = spec[0]",
-        "names: list[object] = spec[1]",
-        "class_name: str = spec[0]",
-        "body: CodeObject = spec[1]",
-        "base_count: int = spec[2]",
-        "has_keywords: bool = spec[3]",
+        "class _NativeKeywordCallSpec:",
+        "class _NativeClassSpec:",
+        "_NativeKeywordCallSpec(arg_specs, names)",
+        "_NativeClassSpec(node.name, body.finish(), base_count, has_keywords)",
+        "spec: _NativeKeywordCallSpec = frame.code.constants[instr.arg]",
+        "positional_spec = spec.positional_spec",
+        "names = spec.names",
+        "spec: _NativeClassSpec = frame.code.constants[instr.arg]",
+        "class_name = spec.class_name",
+        "body = spec.body",
+        "base_count = spec.base_count",
+        "has_keywords = spec.has_keywords",
     )
-    joined = frontend + vm
     missing = [marker for marker in required if marker not in joined]
     if missing:
         raise RuntimeError(f"native runtime spec validation failed: {missing}")
@@ -267,12 +368,18 @@ def main() -> int:
         "invalid class constant",
         "self.constant((tuple(arg_specs), names))",
         "spec = (node.name, body.finish(), base_count, has_keywords)",
+        "[node.name, body.finish(), base_count, has_keywords]",
     )
     remaining = [marker for marker in forbidden if marker in joined]
     if remaining:
         raise RuntimeError(f"unsafe native runtime specs remain: {remaining}")
 
-    print("NORMALIZED NATIVE RUNTIME SPECS", *frontend_counts, *vm_counts)
+    print(
+        "NORMALIZED NATIVE RUNTIME SPECS",
+        installed,
+        *frontend_counts,
+        *vm_counts,
+    )
     return 0
 
 

From 18c6a4ee0d6315d899ad86c10f04f0101ed03bd0 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:00:28 -0500
Subject: [PATCH 412/450] Test typed native opcode spec objects

---
 .../test_normalize_full_core_runtime_specs.py | 48 +++++++++++++++----
 1 file changed, 39 insertions(+), 9 deletions(-)

diff --git a/tests/test_normalize_full_core_runtime_specs.py b/tests/test_normalize_full_core_runtime_specs.py
index 8db1518e..556cedb3 100644
--- a/tests/test_normalize_full_core_runtime_specs.py
+++ b/tests/test_normalize_full_core_runtime_specs.py
@@ -6,7 +6,15 @@
 from tools import normalize_full_core_runtime_specs as normalizer
 
 
-FRONTEND = '''class Lowerer:
+BYTECODE = '''from __future__ import annotations
+
+class CodeObject:
+    pass
+'''
+
+FRONTEND = '''from .bytecode import CodeObject, Instruction, Op
+
+class Lowerer:
     def lower(self, node, body, base_count, has_keywords, arg_specs):
         keyword_names: list[object] = []
         names = tuple(keyword_names)
@@ -15,7 +23,9 @@ def lower(self, node, body, base_count, has_keywords, arg_specs):
         self.emit(Op.MAKE_CLASS, self.constant(spec))
 '''
 
-VM = '''class VirtualMachine:
+VM = '''from .bytecode import CodeObject, Op
+
+class VirtualMachine:
     def run(self, op, frame, instr):
         if op is Op.MAKE_CLASS:
             spec = frame.code.constants[instr.arg]
@@ -39,26 +49,43 @@ def run(self, op, frame, instr):
 '''
 
 
-def test_converts_opcode_specs_to_fixed_lists(tmp_path: Path, monkeypatch) -> None:
+def test_converts_opcode_specs_to_typed_objects(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    bytecode = tmp_path / "bytecode.py"
     frontend = tmp_path / "frontend.py"
     vm = tmp_path / "vm.py"
+    bytecode.write_text(BYTECODE, encoding="utf-8")
     frontend.write_text(FRONTEND, encoding="utf-8")
     vm.write_text(VM, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "BYTECODE_PATH", bytecode)
     monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
     monkeypatch.setattr(normalizer, "VM_PATH", vm)
 
     assert normalizer.main() == 0
 
+    bytecode_source = bytecode.read_text(encoding="utf-8")
     frontend_source = frontend.read_text(encoding="utf-8")
     vm_source = vm.read_text(encoding="utf-8")
-    assert "self.constant([arg_specs, names])" in frontend_source
-    assert "[node.name, body.finish(), base_count, has_keywords]" in frontend_source
-    assert "positional_spec: list[bool] = spec[0]" in vm_source
-    assert "names: list[object] = spec[1]" in vm_source
-    assert "class_name: str = spec[0]" in vm_source
-    assert "body: CodeObject = spec[1]" in vm_source
+    assert "class _NativeKeywordCallSpec:" in bytecode_source
+    assert "class _NativeClassSpec:" in bytecode_source
+    assert "self.positional_spec = positional_spec" in bytecode_source
+    assert "self.body = body" in bytecode_source
+    assert "_NativeKeywordCallSpec(arg_specs, names)" in frontend_source
+    assert (
+        "_NativeClassSpec(node.name, body.finish(), base_count, has_keywords)"
+        in frontend_source
+    )
+    assert "spec: _NativeKeywordCallSpec" in vm_source
+    assert "positional_spec = spec.positional_spec" in vm_source
+    assert "names = spec.names" in vm_source
+    assert "spec: _NativeClassSpec" in vm_source
+    assert "class_name = spec.class_name" in vm_source
+    assert "body = spec.body" in vm_source
     assert "len(spec)" not in vm_source
     assert "isinstance(spec, tuple)" not in vm_source
+    ast.parse(bytecode_source)
     ast.parse(frontend_source)
     ast.parse(vm_source)
 
@@ -67,13 +94,16 @@ def test_fails_closed_when_frontend_shape_changes(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
+    bytecode = tmp_path / "bytecode.py"
     frontend = tmp_path / "frontend.py"
     vm = tmp_path / "vm.py"
+    bytecode.write_text(BYTECODE, encoding="utf-8")
     frontend.write_text(
         FRONTEND.replace("names = tuple(keyword_names)", "names = keyword_names"),
         encoding="utf-8",
     )
     vm.write_text(VM, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "BYTECODE_PATH", bytecode)
     monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
     monkeypatch.setattr(normalizer, "VM_PATH", vm)
 

From 1baf036ac352f8569fe4129dc7cc6fffcd5cd224 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:00:50 -0500
Subject: [PATCH 413/450] Cover all builtin parameter collision repairs

---
 ..._full_core_builtin_parameter_collisions.py | 32 +++++++++++++------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/tests/test_normalize_full_core_builtin_parameter_collisions.py b/tests/test_normalize_full_core_builtin_parameter_collisions.py
index 975940f9..0a30b68d 100644
--- a/tests/test_normalize_full_core_builtin_parameter_collisions.py
+++ b/tests/test_normalize_full_core_builtin_parameter_collisions.py
@@ -12,14 +12,20 @@ def __init__(self, type, name, body):
         self.name = name
         self.body = body
 
-def build(value):
-    return ExceptHandler(type=value, name=None, body=[])
+class Subscript:
+    def __init__(self, value, slice, ctx=None):
+        self.value = value
+        self.slice = slice
+        self.ctx = ctx
+
+def build(value, index):
+    handler = ExceptHandler(type=value, name=None, body=[])
+    subscript = Subscript(value=value, slice=index, ctx=None)
+    return handler, subscript
 '''
 
 
-def test_repairs_except_handler_type_parameter(
-    tmp_path: Path,
-) -> None:
+def test_repairs_all_builtin_parameters(tmp_path: Path) -> None:
     root = tmp_path / "portapy"
     root.mkdir()
     module = root / "module.py"
@@ -27,17 +33,18 @@ def test_repairs_except_handler_type_parameter(
 
     constructors, calls, files = normalize_tree(root)
 
-    assert (constructors, calls, files) == (1, 1, 1)
+    assert (constructors, calls, files) == (2, 2, 1)
     source = module.read_text(encoding="utf-8")
     assert "def __init__(self, type_value, name, body):" in source
     assert "self.type = type_value" in source
     assert "ExceptHandler(type_value=value, name=None, body=[])" in source
+    assert "def __init__(self, value, slice_value, ctx=None):" in source
+    assert "self.slice = slice_value" in source
+    assert "Subscript(value=value, slice_value=index, ctx=None)" in source
     ast.parse(source)
 
 
-def test_positional_except_handler_calls_remain_unchanged(
-    tmp_path: Path,
-) -> None:
+def test_positional_calls_remain_unchanged(tmp_path: Path) -> None:
     root = tmp_path / "portapy"
     root.mkdir()
     module = root / "module.py"
@@ -45,13 +52,18 @@ def test_positional_except_handler_calls_remain_unchanged(
         SOURCE.replace(
             "ExceptHandler(type=value, name=None, body=[])",
             "ExceptHandler(value, None, [])",
+        ).replace(
+            "Subscript(value=value, slice=index, ctx=None)",
+            "Subscript(value, index, None)",
         ),
         encoding="utf-8",
     )
 
     constructors, calls, files = normalize_tree(root)
 
-    assert (constructors, calls, files) == (1, 0, 1)
+    assert (constructors, calls, files) == (2, 0, 1)
     source = module.read_text(encoding="utf-8")
     assert "ExceptHandler(value, None, [])" in source
+    assert "Subscript(value, index, None)" in source
     assert "self.type = type_value" in source
+    assert "self.slice = slice_value" in source

From 334ec952ffc0049e98177a7f44fa303872396bfb Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:10:31 -0500
Subject: [PATCH 414/450] Fix native keyword class and import dispatch

---
 tools/normalize_full_core_runtime_dispatch.py | 182 +++++++++++++-----
 1 file changed, 132 insertions(+), 50 deletions(-)

diff --git a/tools/normalize_full_core_runtime_dispatch.py b/tools/normalize_full_core_runtime_dispatch.py
index 3a65f846..252bf5b4 100644
--- a/tools/normalize_full_core_runtime_dispatch.py
+++ b/tools/normalize_full_core_runtime_dispatch.py
@@ -1,15 +1,17 @@
-"""Remove host-introspection hazards from native VM iteration and imports.
-
-``GET_ITER`` previously evaluated ``type(value).__name__`` before calling
-``iter``. Native values are untagged pointers, so asking for the host type name
-of a list can reinterpret the list header as a dictionary and crash. Iteration
-needs no pre-conversion: Python's iterator protocol already handles lists,
-dicts, and dictionary views.
-
-Import handlers also used ``callable(loader)`` and direct ``loader(...)`` calls.
-Native-compiled functions and VM callables are valid dispatcher targets even
-when the host-style predicate rejects them, so check only for absence and route
-calls through ``VirtualMachine._call``.
+"""Remove native VM host-introspection and container-identity hazards.
+
+Native values are untagged pointers. Host-style ``type``/``callable`` predicates
+and compiler-generated list-membership helpers can therefore reinterpret runtime
+storage or reject valid native call targets. This final AST pass keeps operations
+inside the native representations already established by the frontend and VM:
+
+* iterate values directly with ``iter``;
+* treat an import loader as configured whenever it is present, while preserving
+  direct native loader calls;
+* compare function parameter names with an explicit indexed string loop;
+* remove the redundant class-keyword ``isinstance(dict)`` guard, because the
+  frontend always pushes a dictionary when class keywords exist and the VM itself
+  creates the empty dictionary otherwise.
 """
 from __future__ import annotations
 
@@ -18,6 +20,17 @@
 
 
 PATH = Path("src/portapy/core/vm.py")
+_NAME_LIST_FIELDS = {"arg_names", "posonly_names", "kwonly_names"}
+_NAME_HELPER = "_full_core_native_name_in"
+_NAME_HELPER_SOURCE = '''
+def _full_core_native_name_in(items: list[str], wanted: str) -> bool:
+    index = 0
+    while index < len(items):
+        if items[index] == wanted:
+            return True
+        index += 1
+    return False
+'''
 
 
 def _is_attribute(node: ast.AST, owner: str, name: str) -> bool:
@@ -42,6 +55,15 @@ def _is_opcode_branch(node: ast.If, opcode: str) -> bool:
     )
 
 
+def _contains_text(node: ast.AST, text: str) -> bool:
+    return any(
+        isinstance(item, ast.Constant)
+        and isinstance(item.value, str)
+        and text in item.value
+        for item in ast.walk(node)
+    )
+
+
 def _loader_presence_test() -> ast.Compare:
     return ast.Compare(
         left=ast.Name(id="loader", ctx=ast.Load()),
@@ -50,10 +72,28 @@ def _loader_presence_test() -> ast.Compare:
     )
 
 
+def _target_code_name_list(node: ast.AST) -> bool:
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr in _NAME_LIST_FIELDS
+        and isinstance(node.value, ast.Attribute)
+        and node.value.attr == "code"
+        and isinstance(node.value.value, ast.Name)
+        and node.value.value.id == "target"
+    )
+
+
+def _name_membership_call(left: ast.expr, right: ast.expr) -> ast.Call:
+    return ast.Call(
+        func=ast.Name(id=_NAME_HELPER, ctx=ast.Load()),
+        args=[right, left],
+        keywords=[],
+    )
+
+
 class _ImportRewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.presence_checks = 0
-        self.calls = 0
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
         self.generic_visit(node)
@@ -71,39 +111,35 @@ def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
             return ast.copy_location(_loader_presence_test(), node)
         return node
 
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        self.generic_visit(node)
-        if not (
-            isinstance(node.func, ast.Name)
-            and node.func.id == "loader"
-            and len(node.args) == 1
-            and not node.keywords
-        ):
-            return node
-        self.calls += 1
-        return ast.copy_location(
-            ast.Call(
-                func=ast.Attribute(
-                    value=ast.Name(id="self", ctx=ast.Load()),
-                    attr="_call",
-                    ctx=ast.Load(),
-                ),
-                args=[
-                    ast.Name(id="loader", ctx=ast.Load()),
-                    ast.List(elts=[node.args[0]], ctx=ast.Load()),
-                ],
-                keywords=[],
-            ),
-            node,
-        )
-
 
 class _Rewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.iteration = 0
         self.import_branches = 0
         self.presence_checks = 0
-        self.loader_calls = 0
+        self.class_guards = 0
+        self.name_memberships = 0
+
+    def visit_Compare(self, node: ast.Compare) -> ast.AST:
+        self.generic_visit(node)
+        if (
+            len(node.ops) == 1
+            and len(node.comparators) == 1
+            and isinstance(node.left, ast.expr)
+            and isinstance(node.comparators[0], ast.expr)
+            and _target_code_name_list(node.comparators[0])
+        ):
+            call = _name_membership_call(node.left, node.comparators[0])
+            if isinstance(node.ops[0], ast.In):
+                self.name_memberships += 1
+                return ast.copy_location(call, node)
+            if isinstance(node.ops[0], ast.NotIn):
+                self.name_memberships += 1
+                return ast.copy_location(
+                    ast.UnaryOp(op=ast.Not(), operand=call),
+                    node,
+                )
+        return node
 
     def visit_If(self, node: ast.If) -> ast.AST:
         self.generic_visit(node)
@@ -114,36 +150,75 @@ def visit_If(self, node: ast.If) -> ast.AST:
             ).body
             self.iteration += 1
             return node
+        if _is_opcode_branch(node, "MAKE_CLASS"):
+            before = len(node.body)
+            node.body = [
+                statement
+                for statement in node.body
+                if not _contains_text(
+                    statement,
+                    "class keyword arguments must be a dict",
+                )
+            ]
+            removed = before - len(node.body)
+            if removed != 1:
+                raise RuntimeError(
+                    "native class keyword guard expected once, "
+                    f"found {removed}"
+                )
+            self.class_guards += removed
         if any(
             _is_opcode_branch(node, opcode)
-            for opcode in ("IMPORT_NAME", "IMPORT_FROM", "IMPORT_ROOT", "IMPORT_RELATIVE_FROM")
+            for opcode in (
+                "IMPORT_NAME",
+                "IMPORT_FROM",
+                "IMPORT_ROOT",
+                "IMPORT_RELATIVE_FROM",
+            )
         ):
             rewriter = _ImportRewrite()
             node.body = [rewriter.visit(statement) for statement in node.body]
             self.import_branches += 1
             self.presence_checks += rewriter.presence_checks
-            self.loader_calls += rewriter.calls
         return node
 
 
+def _install_name_helper(tree: ast.Module) -> int:
+    if any(
+        isinstance(node, ast.FunctionDef) and node.name == _NAME_HELPER
+        for node in tree.body
+    ):
+        raise RuntimeError("native name-membership helper already exists")
+    tree.body.extend(ast.parse(_NAME_HELPER_SOURCE).body)
+    return 1
+
+
 def main() -> int:
     tree = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    helper_count = _install_name_helper(tree)
     rewriter = _Rewrite()
     tree = rewriter.visit(tree)
     counts = (
+        helper_count,
         rewriter.iteration,
         rewriter.import_branches,
         rewriter.presence_checks,
-        rewriter.loader_calls,
+        rewriter.class_guards,
+        rewriter.name_memberships,
     )
-    if rewriter.iteration != 1 or rewriter.import_branches != 4:
+    if (
+        helper_count != 1
+        or rewriter.iteration != 1
+        or rewriter.import_branches != 4
+        or rewriter.class_guards != 1
+    ):
         raise RuntimeError(
-            "native runtime dispatch expected one iterator and four import branches; "
+            "native runtime dispatch missed required branches; "
             f"found {counts}"
         )
-    if rewriter.presence_checks < 4 or rewriter.loader_calls < 8:
+    if rewriter.presence_checks < 4 or rewriter.name_memberships < 6:
         raise RuntimeError(
-            "native runtime import dispatch missed loader operations; "
+            "native runtime dispatch missed loader/name operations; "
             f"found {counts}"
         )
 
@@ -152,20 +227,27 @@ def main() -> int:
     PATH.write_text(source, encoding="utf-8")
 
     required = (
+        "def _full_core_native_name_in(items: list[str], wanted: str) -> bool:",
         "frame.stack.append(iter(value))",
         "loader is None",
-        "self._call(loader, [imported])",
-        "self._call(loader, [top_level])",
+        "loader(imported)",
+        "loader(top_level)",
+        "_full_core_native_name_in(target.code.arg_names, name)",
     )
     missing = [marker for marker in required if marker not in source]
     forbidden = (
         'type(value).__name__ in {',
         "callable(loader)",
+        "self._call(loader,",
+        "class keyword arguments must be a dict",
+        "name in target.code.arg_names",
+        "name not in target.code.arg_names",
     )
     remaining = [marker for marker in forbidden if marker in source]
     if missing or remaining:
         raise RuntimeError(
-            f"native runtime dispatch validation failed: missing={missing}, remaining={remaining}"
+            f"native runtime dispatch validation failed: missing={missing}, "
+            f"remaining={remaining}"
         )
 
     print("NORMALIZED NATIVE RUNTIME DISPATCH", *counts)

From 98e23f9f601273797349c67de27dfaa96d1307a4 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:11:22 -0500
Subject: [PATCH 415/450] Test native keyword class and import dispatch

---
 ...st_normalize_full_core_runtime_dispatch.py | 30 +++++++++++++++----
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/tests/test_normalize_full_core_runtime_dispatch.py b/tests/test_normalize_full_core_runtime_dispatch.py
index 9a549691..5592d31b 100644
--- a/tests/test_normalize_full_core_runtime_dispatch.py
+++ b/tests/test_normalize_full_core_runtime_dispatch.py
@@ -7,8 +7,16 @@
 
 
 SOURCE = '''class VirtualMachine:
-    def _call(self, target, args):
-        return target(*args)
+    def bind(self, target, name):
+        checks = [
+            name in target.code.posonly_names,
+            name in target.code.arg_names,
+            name in target.code.kwonly_names,
+            name not in target.code.posonly_names,
+            name not in target.code.arg_names,
+            name not in target.code.kwonly_names,
+        ]
+        return checks
 
     def run(self, op, frame, instr):
         if op is Op.GET_ITER:
@@ -16,6 +24,11 @@ def run(self, op, frame, instr):
             if isinstance(value, dict) or type(value).__name__ in {"dict_keys"}:
                 value = list(value)
             frame.stack.append(iter(value))
+        elif op is Op.MAKE_CLASS:
+            class_keywords = frame.stack.pop() if has_keywords else {}
+            if not isinstance(class_keywords, dict):
+                _raise_typed("TypeError: class keyword arguments must be a dict")
+            frame.stack.append(class_keywords)
         elif op is Op.IMPORT_NAME:
             loader = frame.globals.get("__pyinbin_import__")
             if not callable(loader):
@@ -56,7 +69,7 @@ def run(self, op, frame, instr):
 '''
 
 
-def test_removes_native_iteration_and_loader_hazards(
+def test_removes_native_runtime_dispatch_hazards(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
@@ -67,12 +80,17 @@ def test_removes_native_iteration_and_loader_hazards(
     assert normalizer.main() == 0
 
     source = path.read_text(encoding="utf-8")
+    assert "def _full_core_native_name_in" in source
     assert "frame.stack.append(iter(value))" in source
     assert "type(value).__name__" not in source
     assert "callable(loader)" not in source
     assert "loader is None" in source
-    assert "self._call(loader, [imported])" in source
-    assert "self._call(loader, [top_level])" in source
+    assert "loader(imported)" in source
+    assert "loader(top_level)" in source
+    assert "self._call(loader" not in source
+    assert "class keyword arguments must be a dict" not in source
+    assert "_full_core_native_name_in(target.code.arg_names, name)" in source
+    assert "name in target.code.arg_names" not in source
     ast.parse(source)
 
 
@@ -90,6 +108,6 @@ def test_fails_closed_without_all_import_branches(
     try:
         normalizer.main()
     except RuntimeError as error:
-        assert "four import branches" in str(error)
+        assert "required branches" in str(error)
     else:
         raise AssertionError("normalizer accepted a missing import branch")

From f8a4eaf3bcc3897e522f30d45446f0903dba9bb6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:21:44 -0500
Subject: [PATCH 416/450] Bound Linux full-core probe execution

---
 tests/native_full_core_probe_host.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/native_full_core_probe_host.c b/tests/native_full_core_probe_host.c
index 5d7b44b3..95516488 100644
--- a/tests/native_full_core_probe_host.c
+++ b/tests/native_full_core_probe_host.c
@@ -8,6 +8,7 @@
 #define ABI_CALL __cdecl
 #else
 #include <dlfcn.h>
+#include <unistd.h>
 #define LOAD_LIBRARY(path) dlopen((path), RTLD_NOW | RTLD_LOCAL)
 #define LOAD_SYMBOL(lib, name) dlsym((lib), (name))
 #define ABI_CALL
@@ -40,7 +41,14 @@ int main(int argc, char **argv) {
     fprintf(stderr, "full-core-parse=%lld\n", (long long)parsed_instructions);
     if (parsed_instructions <= 0) return 6;
 
+#if !defined(_WIN32)
+    /* Preserve diagnostics if a native semantic regression loops forever. */
+    alarm(20);
+#endif
     int64_t result = probe();
+#if !defined(_WIN32)
+    alarm(0);
+#endif
     printf("full-core=%lld\n", (long long)result);
     return result == 42 ? 0 : 7;
 }

From d5c67a68d6ce8e6666eb7fe311e68b3d48a89e0f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:24:23 -0500
Subject: [PATCH 417/450] Repair native handle kind slot lookup

---
 ...alize_full_reference_handle_kind_access.py | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 tools/normalize_full_reference_handle_kind_access.py

diff --git a/tools/normalize_full_reference_handle_kind_access.py b/tools/normalize_full_reference_handle_kind_access.py
new file mode 100644
index 00000000..35968339
--- /dev/null
+++ b/tools/normalize_full_reference_handle_kind_access.py
@@ -0,0 +1,85 @@
+"""Use the normalized Runtime handle accessor when tagging native value kinds.
+
+The full Runtime data-access pass stores opaque value slots in a list and exposes
+``Runtime._value_slot(handle)`` as the canonical bounds-checked lookup.  The
+source-kind pass historically reached into ``Runtime._values`` as though it were
+a string-keyed dictionary, so the pinned compiler folded every lookup to
+``None`` and all handles retained the default INT kind.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+_FUNCTION = "_native_set_handle_kind"
+
+
+_REPLACEMENT = '''def _native_set_handle_kind(
+    instance: Runtime,
+    handle: int,
+    kind: int,
+) -> bool:
+    slot = instance._value_slot(handle)
+    if slot is None:
+        return False
+    slot.kind = _native_kind_member(kind)
+    return True
+'''
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == _FUNCTION
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"native handle-kind helper expected once, found {len(matches)}"
+        )
+
+    function = matches[0]
+    original = ast.unparse(function)
+    if "instance._values" not in original or ".get(str(handle))" not in original:
+        raise RuntimeError(
+            "native handle-kind helper no longer has the stale dict lookup"
+        )
+
+    replacement = ast.parse(_REPLACEMENT).body[0]
+    replacement.decorator_list = function.decorator_list
+    index = module.body.index(function)
+    module.body[index] = replacement
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source, filename=str(PATH))
+    repaired = next(
+        node
+        for node in verified.body
+        if isinstance(node, ast.FunctionDef) and node.name == _FUNCTION
+    )
+    text = ast.unparse(repaired)
+    required = (
+        "slot = instance._value_slot(handle)",
+        "slot.kind = _native_kind_member(kind)",
+        "return True",
+    )
+    missing = [marker for marker in required if marker not in text]
+    if missing:
+        raise RuntimeError(f"native handle-kind repair was lost: {missing}")
+    forbidden = ("instance._values", ".get(str(handle))")
+    remaining = [marker for marker in forbidden if marker in text]
+    if remaining:
+        raise RuntimeError(f"stale native handle-kind lookup remains: {remaining}")
+
+    print("REPAIRED NATIVE HANDLE KIND ACCESS", 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 2afd10d74a3945d88d51b712838ee04b9fd21958 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:24:40 -0500
Subject: [PATCH 418/450] Test native handle kind slot repair

---
 ...alize_full_reference_handle_kind_access.py | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 tests/test_normalize_full_reference_handle_kind_access.py

diff --git a/tests/test_normalize_full_reference_handle_kind_access.py b/tests/test_normalize_full_reference_handle_kind_access.py
new file mode 100644
index 00000000..4915ab56
--- /dev/null
+++ b/tests/test_normalize_full_reference_handle_kind_access.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_reference_handle_kind_access as normalizer
+
+
+SOURCE = '''def _native_set_handle_kind(instance: Runtime, handle: int, kind: int) -> bool:
+    slot = instance._values.get(str(handle))
+    if slot is None:
+        return False
+    slot.kind = _native_kind_member(kind)
+    return True
+'''
+
+
+def test_uses_normalized_value_slot_accessor(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_full_reference_entry.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "slot = instance._value_slot(handle)" in source
+    assert "slot.kind = _native_kind_member(kind)" in source
+    assert "instance._values" not in source
+    assert ".get(str(handle))" not in source
+    ast.parse(source)
+
+
+def test_fails_closed_when_stale_shape_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_full_reference_entry.py"
+    path.write_text(
+        SOURCE.replace(
+            "instance._values.get(str(handle))",
+            "instance._value_slot(handle)",
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "stale dict lookup" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unexpected helper shape")

From 3633d73d21356fce274ef0c8e727d3bb500a2f1f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:25:40 -0500
Subject: [PATCH 419/450] Run native handle kind access repair

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 71c5a476..61fcc11b 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -62,6 +62,7 @@
 from tools.normalize_full_reference_expression_kinds import main as normalize_reference_expression_kinds
 from tools.normalize_full_reference_float_bits import main as normalize_reference_float_bits
 from tools.normalize_full_reference_function_return_kinds import main as normalize_reference_function_return_kinds
+from tools.normalize_full_reference_handle_kind_access import main as normalize_reference_handle_kind_access
 from tools.normalize_full_reference_nested_kinds import main as normalize_reference_nested_kinds
 from tools.normalize_full_reference_runtime import main as normalize_reference_runtime
 from tools.normalize_full_reference_safe_host_ids import main as normalize_reference_safe_host_ids
@@ -170,6 +171,7 @@ def main() -> int:
         ("reference_source_preprocess", normalize_reference_source_preprocess),
         ("reference_data_builders", normalize_reference_data_builders),
         ("reference_data_access", normalize_reference_data_access),
+        ("reference_handle_kind_access", normalize_reference_handle_kind_access),
         ("reference_bytes_literals", normalize_reference_bytes_literals),
         ("native_parser", normalize_native_parser),
         ("native_argument_defaults", normalize_native_argument_defaults),

From f58ca57c74761611a8087f245284c1606c168d81 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:35:15 -0500
Subject: [PATCH 420/450] Parse full default argument expressions

---
 ...normalize_full_core_default_expressions.py | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 tools/normalize_full_core_default_expressions.py

diff --git a/tools/normalize_full_core_default_expressions.py b/tools/normalize_full_core_default_expressions.py
new file mode 100644
index 00000000..5fd77d31
--- /dev/null
+++ b/tools/normalize_full_core_default_expressions.py
@@ -0,0 +1,75 @@
+"""Allow full expressions in native function default arguments.
+
+The vendored parser's ``_parse_optional_default`` delegates to a deliberately
+restricted literal parser inherited from the compiler frontend. PortaPy captures
+Python defaults at definition time, so defaults such as ``seed + 2`` must use the
+ordinary expression grammar and stop naturally at the parameter comma or closing
+parenthesis.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_METHOD = "_parse_optional_default"
+
+
+_REPLACEMENT = '''if not self._check("OP", "="):
+    return None
+self._eat()
+return self._parse_expr()
+'''
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    methods = [
+        node
+        for node in ast.walk(module)
+        if isinstance(node, ast.FunctionDef) and node.name == _METHOD
+    ]
+    if len(methods) != 1:
+        raise RuntimeError(
+            f"native default parser expected one {_METHOD}, found {len(methods)}"
+        )
+
+    method = methods[0]
+    original = ast.unparse(method)
+    if "return self._parse_default_literal()" not in original:
+        raise RuntimeError(
+            "native default parser no longer has the restricted literal path"
+        )
+    method.body = ast.parse(_REPLACEMENT).body
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source, filename=str(PATH))
+    repaired = [
+        node
+        for node in ast.walk(verified)
+        if isinstance(node, ast.FunctionDef) and node.name == _METHOD
+    ]
+    if len(repaired) != 1:
+        raise RuntimeError("native default expression parser was not preserved")
+    text = ast.unparse(repaired[0])
+    required = (
+        "if not self._check('OP', '='):",
+        "self._eat()",
+        "return self._parse_expr()",
+    )
+    missing = [marker for marker in required if marker not in text]
+    if missing:
+        raise RuntimeError(f"native default expression repair was lost: {missing}")
+    if "_parse_default_literal" in text:
+        raise RuntimeError("restricted default-literal parser remains active")
+
+    print("NORMALIZED NATIVE DEFAULT EXPRESSIONS", 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From f0d6e5bcbef690b539a3eb25496ebb70e7644c01 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:35:30 -0500
Subject: [PATCH 421/450] Test full native default expressions

---
 ...normalize_full_core_default_expressions.py | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 tests/test_normalize_full_core_default_expressions.py

diff --git a/tests/test_normalize_full_core_default_expressions.py b/tests/test_normalize_full_core_default_expressions.py
new file mode 100644
index 00000000..9186a8c5
--- /dev/null
+++ b/tests/test_normalize_full_core_default_expressions.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_default_expressions as normalizer
+
+
+SOURCE = '''class Parser:
+    def _parse_optional_default(self):
+        if not self._check("OP", "="):
+            return None
+        self._eat()
+        return self._parse_default_literal()
+'''
+
+
+def test_uses_full_expression_parser(tmp_path: Path, monkeypatch) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "return self._parse_expr()" in source
+    assert "return self._parse_default_literal()" not in source
+    ast.parse(source)
+
+
+def test_fails_closed_when_parser_shape_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace("self._parse_default_literal()", "self._parse_expr()"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "restricted literal path" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unexpected parser shape")

From 6da3447fcf4dd07943914253168e8374a26c943f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:35:46 -0500
Subject: [PATCH 422/450] Normalize native iteration closures and exceptions

---
 .../normalize_full_core_runtime_execution.py  | 240 ++++++++++++++++++
 1 file changed, 240 insertions(+)
 create mode 100644 tools/normalize_full_core_runtime_execution.py

diff --git a/tools/normalize_full_core_runtime_execution.py b/tools/normalize_full_core_runtime_execution.py
new file mode 100644
index 00000000..f7801d34
--- /dev/null
+++ b/tools/normalize_full_core_runtime_execution.py
@@ -0,0 +1,240 @@
+"""Install explicit native execution state for iteration, closures, and exceptions.
+
+The pinned compiler's generic ``iter``/``next`` lowering does not retain iterator
+state for untagged runtime lists. The same limitation affects Python ``for`` loops
+inside the VM itself, including closure capture. Native low-level exception
+handlers also expose the runtime error message rather than a Python exception
+object. This final AST pass replaces the critical paths with explicit indexed
+state and wraps caught messages in a native object carrying traceback metadata.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/vm.py")
+_ITERATOR = "_NativeSequenceIterator"
+_EXCEPTION = "_NativeCaughtException"
+
+_HELPERS = '''
+class _NativeSequenceIterator:
+    def __init__(self, values: list[object]) -> None:
+        self.values = values
+        self.index = 0
+
+
+class _NativeCaughtException:
+    def __init__(self, message: object) -> None:
+        self.message = message
+        self.__traceback__ = True
+'''
+
+
+def _is_attribute(node: ast.AST, owner: str, name: str) -> bool:
+    return (
+        isinstance(node, ast.Attribute)
+        and node.attr == name
+        and isinstance(node.value, ast.Name)
+        and node.value.id == owner
+    )
+
+
+def _is_opcode_branch(node: ast.If, opcode: str) -> bool:
+    test = node.test
+    return (
+        isinstance(test, ast.Compare)
+        and isinstance(test.left, ast.Name)
+        and test.left.id == "op"
+        and len(test.ops) == 1
+        and isinstance(test.ops[0], ast.Is)
+        and len(test.comparators) == 1
+        and _is_attribute(test.comparators[0], "Op", opcode)
+    )
+
+
+def _is_closure_capture_loop(node: ast.stmt) -> bool:
+    return (
+        isinstance(node, ast.For)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "name"
+        and isinstance(node.iter, ast.Attribute)
+        and node.iter.attr == "free_names"
+        and isinstance(node.iter.value, ast.Name)
+        and node.iter.value.id == "nested"
+    )
+
+
+def _install_helpers(tree: ast.Module) -> int:
+    existing = {
+        node.name
+        for node in tree.body
+        if isinstance(node, ast.ClassDef)
+        and node.name in {_ITERATOR, _EXCEPTION}
+    }
+    if existing:
+        raise RuntimeError(f"native execution helpers already exist: {sorted(existing)}")
+    helpers = ast.parse(_HELPERS).body
+    tree.body.extend(helpers)
+    return len(helpers)
+
+
+class _OpcodeRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.get_iter = 0
+        self.for_iter = 0
+        self.closure_loops = 0
+
+    def visit_If(self, node: ast.If) -> ast.AST:
+        self.generic_visit(node)
+        if _is_opcode_branch(node, "GET_ITER"):
+            node.body = ast.parse(
+                "sequence: list[object] = frame.stack.pop()\n"
+                "frame.stack.append(_NativeSequenceIterator(sequence))\n"
+            ).body
+            self.get_iter += 1
+        elif _is_opcode_branch(node, "FOR_ITER"):
+            node.body = ast.parse(
+                "if not frame.stack:\n"
+                "    frame.ip = instr.arg\n"
+                "    continue\n"
+                "iterator: _NativeSequenceIterator = frame.stack[-1]\n"
+                "if iterator.index >= len(iterator.values):\n"
+                "    frame.stack.pop()\n"
+                "    frame.ip = instr.arg\n"
+                "else:\n"
+                "    value = iterator.values[iterator.index]\n"
+                "    iterator.index += 1\n"
+                "    frame.stack.append(value)\n"
+            ).body
+            self.for_iter += 1
+        elif _is_opcode_branch(node, "MAKE_FUNCTION"):
+            replacements: list[ast.stmt] = []
+            found = 0
+            for statement in node.body:
+                if not _is_closure_capture_loop(statement):
+                    replacements.append(statement)
+                    continue
+                replacements.extend(
+                    ast.parse(
+                        "closure_index = 0\n"
+                        "while closure_index < len(nested.free_names):\n"
+                        "    name = nested.free_names[closure_index]\n"
+                        "    if name in frame.locals:\n"
+                        "        closure[name] = frame.locals[name]\n"
+                        "    elif frame.closure is not None and name in frame.closure:\n"
+                        "        closure[name] = frame.closure[name]\n"
+                        "    closure_index += 1\n"
+                    ).body
+                )
+                found += 1
+            if found != 1:
+                raise RuntimeError(
+                    f"native MAKE_FUNCTION closure loop expected once, found {found}"
+                )
+            node.body = replacements
+            self.closure_loops += found
+        return node
+
+
+class _ExceptionRewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.in_run_frame = False
+        self.catches = 0
+        self.matchers = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        previous = self.in_run_frame
+        self.in_run_frame = node.name == "_run_frame"
+        self.generic_visit(node)
+        self.in_run_frame = previous
+        if node.name == "_exception_matches":
+            guard = ast.parse(
+                "if isinstance(value, _NativeCaughtException):\n"
+                "    return True\n"
+            ).body[0]
+            node.body.insert(0, guard)
+            self.matchers += 1
+        return node
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> ast.AST:
+        self.generic_visit(node)
+        if not self.in_run_frame:
+            return node
+        if not (
+            node.name == "exc"
+            and isinstance(node.type, ast.Name)
+            and node.type.id == "BaseException"
+        ):
+            return node
+        node.body.insert(
+            0,
+            ast.Assign(
+                targets=[ast.Name(id="exc", ctx=ast.Store())],
+                value=ast.Call(
+                    func=ast.Name(id=_EXCEPTION, ctx=ast.Load()),
+                    args=[ast.Name(id="exc", ctx=ast.Load())],
+                    keywords=[],
+                ),
+            ),
+        )
+        self.catches += 1
+        return node
+
+
+def main() -> int:
+    tree = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    helper_count = _install_helpers(tree)
+    opcode = _OpcodeRewrite()
+    tree = opcode.visit(tree)
+    exceptions = _ExceptionRewrite()
+    tree = exceptions.visit(tree)
+
+    counts = (
+        helper_count,
+        opcode.get_iter,
+        opcode.for_iter,
+        opcode.closure_loops,
+        exceptions.catches,
+        exceptions.matchers,
+    )
+    if counts != (2, 1, 1, 1, 1, 1):
+        raise RuntimeError(
+            "native execution normalization expected helpers/get-iter/for-iter/"
+            f"closure/catch/matcher once; found {counts}"
+        )
+
+    ast.fix_missing_locations(tree)
+    source = ast.unparse(tree) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        "class _NativeSequenceIterator:",
+        "class _NativeCaughtException:",
+        "frame.stack.append(_NativeSequenceIterator(sequence))",
+        "iterator: _NativeSequenceIterator = frame.stack[-1]",
+        "value = iterator.values[iterator.index]",
+        "while closure_index < len(nested.free_names):",
+        "exc = _NativeCaughtException(exc)",
+        "if isinstance(value, _NativeCaughtException):",
+        "self.__traceback__ = True",
+    )
+    missing = [marker for marker in required if marker not in source]
+    forbidden = (
+        "frame.stack.append(iter(value))",
+        "frame.stack.append(next(frame.stack[-1]))",
+        "for name in nested.free_names:",
+    )
+    remaining = [marker for marker in forbidden if marker in source]
+    if missing or remaining:
+        raise RuntimeError(
+            f"native execution validation failed: missing={missing}, "
+            f"remaining={remaining}"
+        )
+
+    print("NORMALIZED NATIVE RUNTIME EXECUTION", *counts)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From cf30eed6676a09a8881547d0ebf93c613d05c09e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:36:17 -0500
Subject: [PATCH 423/450] Run default expression parser normalization

---
 tools/normalize_full_core_native_argument_defaults.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tools/normalize_full_core_native_argument_defaults.py b/tools/normalize_full_core_native_argument_defaults.py
index 61359ddb..c8fbe8e1 100644
--- a/tools/normalize_full_core_native_argument_defaults.py
+++ b/tools/normalize_full_core_native_argument_defaults.py
@@ -14,6 +14,10 @@
 import ast
 from pathlib import Path
 
+from tools.normalize_full_core_default_expressions import (
+    main as normalize_default_expressions,
+)
+
 
 PATH = Path("src/portapy/core/native_ast.py")
 
@@ -109,6 +113,7 @@ def _is_normalized(function: ast.FunctionDef) -> bool:
 
 
 def main() -> int:
+    normalize_default_expressions()
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     matches = [
         node

From 29153c73154e1cb6d2ba5e2de64eb662f658e10b Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:36:55 -0500
Subject: [PATCH 424/450] Run native execution state normalization

---
 tools/normalize_full_core_validation.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 61fcc11b..3d1a6ecb 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -48,6 +48,7 @@
 from tools.normalize_full_core_pop_top import main as normalize_pop_top
 from tools.normalize_full_core_probe import main as normalize_probe
 from tools.normalize_full_core_runtime_dispatch import main as normalize_runtime_dispatch
+from tools.normalize_full_core_runtime_execution import main as normalize_runtime_execution
 from tools.normalize_full_core_runtime_specs import main as normalize_runtime_specs
 from tools.normalize_full_core_string_addition import main as normalize_string_addition
 from tools.normalize_full_core_string_comparisons import main as normalize_truthiness
@@ -202,9 +203,11 @@ def main() -> int:
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
         # These AST passes intentionally run only after all text-sensitive VM
-        # passes, replacing unsafe opcode specs and host introspection.
+        # passes, replacing unsafe specs, host introspection, and implicit
+        # iterator/exception state.
         ("runtime_specs", normalize_runtime_specs),
         ("runtime_dispatch", normalize_runtime_dispatch),
+        ("runtime_execution", normalize_runtime_execution),
         # Parameter collisions include explicit functions and dataclass-generated
         # initializers. Repair them before the final local-variable collision pass.
         ("parameter_name_collisions", normalize_parameter_name_collisions),

From 89b2a331bf11b74cbfc1ff31f3bc48d11a61c421 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:37:19 -0500
Subject: [PATCH 425/450] Test native execution state normalization

---
 ...t_normalize_full_core_runtime_execution.py | 82 +++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 tests/test_normalize_full_core_runtime_execution.py

diff --git a/tests/test_normalize_full_core_runtime_execution.py b/tests/test_normalize_full_core_runtime_execution.py
new file mode 100644
index 00000000..d0909675
--- /dev/null
+++ b/tests/test_normalize_full_core_runtime_execution.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_runtime_execution as normalizer
+
+
+SOURCE = '''class VirtualMachine:
+    def _exception_matches(self, value, expected):
+        return False
+
+    def _run_frame(self, frame):
+        while True:
+            try:
+                op = current_op
+                if op is Op.GET_ITER:
+                    value = frame.stack.pop()
+                    frame.stack.append(iter(value))
+                elif op is Op.FOR_ITER:
+                    if not frame.stack:
+                        frame.ip = instr.arg
+                        continue
+                    try:
+                        frame.stack.append(next(frame.stack[-1]))
+                    except StopIteration:
+                        frame.stack.pop()
+                        frame.ip = instr.arg
+                elif op is Op.MAKE_FUNCTION:
+                    closure = {}
+                    for name in nested.free_names:
+                        if name in frame.locals:
+                            closure[name] = frame.locals[name]
+                        elif frame.closure is not None and name in frame.closure:
+                            closure[name] = frame.closure[name]
+            except BaseException as exc:
+                frame.stack.append(exc)
+'''
+
+
+def test_installs_explicit_native_execution_state(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "class _NativeSequenceIterator:" in source
+    assert "class _NativeCaughtException:" in source
+    assert "frame.stack.append(_NativeSequenceIterator(sequence))" in source
+    assert "iterator: _NativeSequenceIterator = frame.stack[-1]" in source
+    assert "value = iterator.values[iterator.index]" in source
+    assert "while closure_index < len(nested.free_names):" in source
+    assert "exc = _NativeCaughtException(exc)" in source
+    assert "if isinstance(value, _NativeCaughtException):" in source
+    assert "frame.stack.append(iter(value))" not in source
+    assert "next(frame.stack[-1])" not in source
+    assert "for name in nested.free_names" not in source
+    ast.parse(source)
+
+
+def test_fails_closed_without_closure_loop(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "vm.py"
+    path.write_text(
+        SOURCE.replace("for name in nested.free_names:", "for name in []:"),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "closure loop" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing closure loop")

From abea02e4fdfb3100a26b5e0934f801dca0f7239e Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:39:25 -0500
Subject: [PATCH 426/450] Isolate native default argument unit tests

---
 ...st_normalize_full_core_native_argument_defaults.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/tests/test_normalize_full_core_native_argument_defaults.py b/tests/test_normalize_full_core_native_argument_defaults.py
index 12cde805..d82d74e8 100644
--- a/tests/test_normalize_full_core_native_argument_defaults.py
+++ b/tests/test_normalize_full_core_native_argument_defaults.py
@@ -77,12 +77,17 @@ def _arguments_initializer(path: Path) -> ast.FunctionDef:
     return initializers[0]
 
 
+def _isolate(path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(normalizer, "PATH", path)
+    monkeypatch.setattr(normalizer, "normalize_default_expressions", lambda: 0)
+
+
 def test_pins_default_elements_and_storage_to_dict_backed_ast(
     tmp_path: Path, monkeypatch,
 ) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(_SOURCE, encoding="utf-8")
-    monkeypatch.setattr(normalizer, "PATH", path)
+    _isolate(path, monkeypatch)
 
     assert normalizer.main() == 0
 
@@ -121,7 +126,7 @@ def test_pins_default_elements_and_storage_to_dict_backed_ast(
 def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text(_SOURCE, encoding="utf-8")
-    monkeypatch.setattr(normalizer, "PATH", path)
+    _isolate(path, monkeypatch)
 
     assert normalizer.main() == 0
     first = path.read_text(encoding="utf-8")
@@ -132,7 +137,7 @@ def test_is_idempotent(tmp_path: Path, monkeypatch) -> None:
 def test_fails_closed_for_unknown_shape(tmp_path: Path, monkeypatch) -> None:
     path = tmp_path / "native_ast.py"
     path.write_text("def _convert_arguments():\n    pass\n", encoding="utf-8")
-    monkeypatch.setattr(normalizer, "PATH", path)
+    _isolate(path, monkeypatch)
 
     try:
         normalizer.main()

From 4f931959c909efc944dddfaacb76f2cc28c73ad6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:40:59 -0500
Subject: [PATCH 427/450] Separate default expression parser normalization

---
 tools/normalize_full_core_native_argument_defaults.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/tools/normalize_full_core_native_argument_defaults.py b/tools/normalize_full_core_native_argument_defaults.py
index c8fbe8e1..61359ddb 100644
--- a/tools/normalize_full_core_native_argument_defaults.py
+++ b/tools/normalize_full_core_native_argument_defaults.py
@@ -14,10 +14,6 @@
 import ast
 from pathlib import Path
 
-from tools.normalize_full_core_default_expressions import (
-    main as normalize_default_expressions,
-)
-
 
 PATH = Path("src/portapy/core/native_ast.py")
 
@@ -113,7 +109,6 @@ def _is_normalized(function: ast.FunctionDef) -> bool:
 
 
 def main() -> int:
-    normalize_default_expressions()
     module = ast.parse(PATH.read_text(encoding="utf-8"))
     matches = [
         node

From b73a3425368c13d88ed677842bed281f0c373511 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:41:49 -0500
Subject: [PATCH 428/450] Repair vendored parser default expressions

---
 tools/normalize_full_core_default_expressions.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_default_expressions.py b/tools/normalize_full_core_default_expressions.py
index 5fd77d31..433ac644 100644
--- a/tools/normalize_full_core_default_expressions.py
+++ b/tools/normalize_full_core_default_expressions.py
@@ -12,7 +12,11 @@
 from pathlib import Path
 
 
-PATH = Path("src/portapy/core/native_ast.py")
+# The parser is generated by ``normalize_full_core_native_parser``. During hosted
+# unit tests that exercise the native-AST bridge in isolation this file does not
+# exist yet, so the repair is deliberately deferred until the full pipeline has
+# vendored the parser runtime.
+PATH = Path("src/portapy/core/native_parser_runtime.py")
 _METHOD = "_parse_optional_default"
 
 
@@ -24,6 +28,10 @@
 
 
 def main() -> int:
+    if not PATH.exists():
+        print("DEFERRED NATIVE DEFAULT EXPRESSIONS")
+        return 0
+
     module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
     methods = [
         node

From c1225227477d1bde348c459d7d53e3359bc53b9f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:41:57 -0500
Subject: [PATCH 429/450] Run default expression normalization after parser
 combine

---
 tools/normalize_full_core_validation.py | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 3d1a6ecb..0d6b8c5c 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -22,6 +22,7 @@
 from tools.normalize_full_core_calls_closures import main as normalize_calls_closures
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
+from tools.normalize_full_core_default_expressions import main as normalize_default_expressions
 from tools.normalize_full_core_expr_stmt_initializer import main as normalize_expr_stmt_initializer
 from tools.normalize_full_core_extended_semantics_compat import main as normalize_extended_semantics
 from tools.normalize_full_core_function_binding import main as normalize_function_binding
@@ -146,8 +147,6 @@ def _run_step(name: str, callback: Callable[[], object]) -> None:
 
 def main() -> int:
     steps: tuple[tuple[str, Callable[[], object]], ...] = (
-        # This pass relies on pristine VM source anchors. Keep it before every
-        # normalizer that rewrites or unparses src/portapy/core/vm.py.
         ("native_keyword_transport", normalize_native_keyword_transport),
         ("probe", normalize_probe),
         ("lambdas", normalize_lambdas),
@@ -179,6 +178,8 @@ def main() -> int:
         ("calls_closures", normalize_calls_closures),
         ("keyword_calls", normalize_keyword_calls),
         ("combine_native_parser", combine_native_parser),
+        # The parser method only exists in native_ast after combination.
+        ("default_expressions", normalize_default_expressions),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("native_parser_target_dispatch", normalize_native_parser_target_dispatch),
         ("parser_errors", normalize_parser_errors),
@@ -186,8 +187,6 @@ def main() -> int:
         ("closures", normalize_closures),
         ("pattern_slices", normalize_pattern_slices),
         ("extended_semantics", normalize_extended_semantics),
-        # Extended semantics installs MatchAs defaults using the original
-        # constructor signature. Rename colliding parameters only afterwards.
         ("expr_stmt_initializer", normalize_expr_stmt_initializer),
         ("pattern_constructor_collisions", normalize_pattern_constructor_collisions),
         ("native_statement_bodies", normalize_native_statement_bodies),
@@ -202,18 +201,11 @@ def main() -> int:
         ("truthiness", normalize_truthiness),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
-        # These AST passes intentionally run only after all text-sensitive VM
-        # passes, replacing unsafe specs, host introspection, and implicit
-        # iterator/exception state.
         ("runtime_specs", normalize_runtime_specs),
         ("runtime_dispatch", normalize_runtime_dispatch),
         ("runtime_execution", normalize_runtime_execution),
-        # Parameter collisions include explicit functions and dataclass-generated
-        # initializers. Repair them before the final local-variable collision pass.
         ("parameter_name_collisions", normalize_parameter_name_collisions),
         ("builtin_parameter_collisions", normalize_builtin_parameter_collisions),
-        # Run last: it unparses all changed modules and must see the complete
-        # flattened class namespace produced by every earlier pass.
         ("local_name_collisions", normalize_local_name_collisions),
     )
     DIAGNOSTIC_PATH.unlink(missing_ok=True)

From eecf98a85cb1e93856913a0c81820d2313e276c8 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:43:58 -0500
Subject: [PATCH 430/450] Target combined parser for default expressions

---
 tools/normalize_full_core_default_expressions.py | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/tools/normalize_full_core_default_expressions.py b/tools/normalize_full_core_default_expressions.py
index 433ac644..5fd77d31 100644
--- a/tools/normalize_full_core_default_expressions.py
+++ b/tools/normalize_full_core_default_expressions.py
@@ -12,11 +12,7 @@
 from pathlib import Path
 
 
-# The parser is generated by ``normalize_full_core_native_parser``. During hosted
-# unit tests that exercise the native-AST bridge in isolation this file does not
-# exist yet, so the repair is deliberately deferred until the full pipeline has
-# vendored the parser runtime.
-PATH = Path("src/portapy/core/native_parser_runtime.py")
+PATH = Path("src/portapy/core/native_ast.py")
 _METHOD = "_parse_optional_default"
 
 
@@ -28,10 +24,6 @@
 
 
 def main() -> int:
-    if not PATH.exists():
-        print("DEFERRED NATIVE DEFAULT EXPRESSIONS")
-        return 0
-
     module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
     methods = [
         node

From 112aeea70c2f233f12f68dbf5eb41eadd85a71af Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:44:33 -0500
Subject: [PATCH 431/450] Remove stale default expression monkeypatch

---
 tests/test_normalize_full_core_native_argument_defaults.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/test_normalize_full_core_native_argument_defaults.py b/tests/test_normalize_full_core_native_argument_defaults.py
index d82d74e8..4b48362c 100644
--- a/tests/test_normalize_full_core_native_argument_defaults.py
+++ b/tests/test_normalize_full_core_native_argument_defaults.py
@@ -79,7 +79,6 @@ def _arguments_initializer(path: Path) -> ast.FunctionDef:
 
 def _isolate(path: Path, monkeypatch) -> None:
     monkeypatch.setattr(normalizer, "PATH", path)
-    monkeypatch.setattr(normalizer, "normalize_default_expressions", lambda: 0)
 
 
 def test_pins_default_elements_and_storage_to_dict_backed_ast(

From 0df9a2614e199e50b543006947f51edd0af1fbe1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:56:35 -0500
Subject: [PATCH 432/450] Preserve native exception status identity

---
 .../normalize_full_core_exception_statuses.py | 258 ++++++++++++++++++
 1 file changed, 258 insertions(+)
 create mode 100644 tools/normalize_full_core_exception_statuses.py

diff --git a/tools/normalize_full_core_exception_statuses.py b/tools/normalize_full_core_exception_statuses.py
new file mode 100644
index 00000000..c2a910a7
--- /dev/null
+++ b/tools/normalize_full_core_exception_statuses.py
@@ -0,0 +1,258 @@
+"""Preserve escaping exception identity and map missing names at the native ABI.
+
+The native execution-state pass wraps caught low-level exceptions so interpreted
+``try`` handlers have a stable object.  Overwriting the catch variable also makes
+an unhandled exception escape as that untyped wrapper, causing the public Runtime
+boundary to classify a NameError as TypeError.  Keep the original exception for
+bare re-raise, create the wrapper only when dispatching into a bytecode handler,
+and add the corresponding NOT_FOUND mapping at the public ABI boundary.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+VM_PATH = Path("src/portapy/core/vm.py")
+REFERENCE_PATH = Path("src/portapy/reference_api.py")
+_EXCEPTION = "_NativeCaughtException"
+_WRAPPED_NAME = "native_exception"
+
+
+def _is_name(node: ast.AST, name: str) -> bool:
+    return isinstance(node, ast.Name) and node.id == name
+
+
+def _is_exc_wrapper_assignment(node: ast.stmt) -> bool:
+    return (
+        isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and _is_name(node.targets[0], "exc")
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name)
+        and node.value.func.id == _EXCEPTION
+        and len(node.value.args) == 1
+        and _is_name(node.value.args[0], "exc")
+    )
+
+
+def _is_stack_append_exc(node: ast.stmt) -> bool:
+    return (
+        isinstance(node, ast.Expr)
+        and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Attribute)
+        and node.value.func.attr == "append"
+        and isinstance(node.value.func.value, ast.Attribute)
+        and node.value.func.value.attr == "stack"
+        and _is_name(node.value.func.value.value, "frame")
+        and len(node.value.args) == 1
+        and _is_name(node.value.args[0], "exc")
+    )
+
+
+def _is_active_exception_exc(node: ast.stmt) -> bool:
+    return (
+        isinstance(node, ast.Assign)
+        and len(node.targets) == 1
+        and isinstance(node.targets[0], ast.Attribute)
+        and node.targets[0].attr == "active_exception"
+        and _is_name(node.targets[0].value, "frame")
+        and _is_name(node.value, "exc")
+    )
+
+
+def _rewrite_statement_lists(statements: list[ast.stmt]) -> tuple[int, int]:
+    append_count = 0
+    active_count = 0
+    index = 0
+    while index < len(statements):
+        statement = statements[index]
+        if _is_stack_append_exc(statement):
+            replacement = ast.parse(
+                f"{_WRAPPED_NAME} = {_EXCEPTION}(exc)\n"
+                f"frame.stack.append({_WRAPPED_NAME})\n"
+            ).body
+            statements[index:index + 1] = replacement
+            append_count += 1
+            index += len(replacement)
+            continue
+        if _is_active_exception_exc(statement):
+            statement.value = ast.Name(id=_WRAPPED_NAME, ctx=ast.Load())
+            active_count += 1
+
+        child_lists: list[list[ast.stmt]] = []
+        for field in ("body", "orelse", "finalbody"):
+            value = getattr(statement, field, None)
+            if isinstance(value, list):
+                child_lists.append(value)
+        if isinstance(statement, ast.Try):
+            for handler in statement.handlers:
+                child_lists.append(handler.body)
+        for child in child_lists:
+            nested_append, nested_active = _rewrite_statement_lists(child)
+            append_count += nested_append
+            active_count += nested_active
+        index += 1
+    return append_count, active_count
+
+
+def _repair_vm() -> tuple[int, int, int]:
+    tree = ast.parse(VM_PATH.read_text(encoding="utf-8"), filename=str(VM_PATH))
+    runtime = next(
+        (
+            node
+            for node in tree.body
+            if isinstance(node, ast.ClassDef) and node.name == "VirtualMachine"
+        ),
+        None,
+    )
+    if runtime is None:
+        raise RuntimeError("native VirtualMachine class is missing")
+    method = next(
+        (
+            node
+            for node in runtime.body
+            if isinstance(node, ast.FunctionDef) and node.name == "_run_frame"
+        ),
+        None,
+    )
+    if method is None:
+        raise RuntimeError("native VirtualMachine._run_frame is missing")
+    handlers = [
+        handler
+        for node in ast.walk(method)
+        if isinstance(node, ast.Try)
+        for handler in node.handlers
+        if handler.name == "exc"
+        and isinstance(handler.type, ast.Name)
+        and handler.type.id == "BaseException"
+        and any(_is_exc_wrapper_assignment(item) for item in handler.body)
+    ]
+    if len(handlers) != 1:
+        raise RuntimeError(
+            f"native run-frame wrapper handler expected once, found {len(handlers)}"
+        )
+    handler = handlers[0]
+    before = len(handler.body)
+    handler.body = [item for item in handler.body if not _is_exc_wrapper_assignment(item)]
+    removed = before - len(handler.body)
+    append_count, active_count = _rewrite_statement_lists(handler.body)
+    if (removed, append_count, active_count) != (1, 1, 1):
+        raise RuntimeError(
+            "native exception escape repair expected wrapper/append/active once; "
+            f"found {(removed, append_count, active_count)}"
+        )
+
+    ast.fix_missing_locations(tree)
+    source = ast.unparse(tree) + "\n"
+    VM_PATH.write_text(source, encoding="utf-8")
+    required = (
+        f"{_WRAPPED_NAME} = {_EXCEPTION}(exc)",
+        f"frame.stack.append({_WRAPPED_NAME})",
+        f"frame.active_exception = {_WRAPPED_NAME}",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing or "exc = _NativeCaughtException(exc)" in source:
+        raise RuntimeError(
+            f"native exception escape validation failed: missing={missing}"
+        )
+    return removed, append_count, active_count
+
+
+def _is_vm_run_try(statement: ast.stmt) -> bool:
+    return isinstance(statement, ast.Try) and any(
+        isinstance(item, ast.Expr)
+        and isinstance(item.value, ast.Call)
+        and isinstance(item.value.func, ast.Attribute)
+        and item.value.func.attr == "run"
+        for item in statement.body
+    )
+
+
+def _install_name_error_mapping() -> int:
+    tree = ast.parse(
+        REFERENCE_PATH.read_text(encoding="utf-8"),
+        filename=str(REFERENCE_PATH),
+    )
+    runtime = next(
+        (
+            node
+            for node in tree.body
+            if isinstance(node, ast.ClassDef) and node.name == "Runtime"
+        ),
+        None,
+    )
+    if runtime is None:
+        raise RuntimeError("reference Runtime class is missing")
+    method = next(
+        (
+            node
+            for node in runtime.body
+            if isinstance(node, ast.FunctionDef) and node.name == "exec_utf8"
+        ),
+        None,
+    )
+    if method is None:
+        raise RuntimeError("reference Runtime.exec_utf8 is missing")
+    run_tries = [statement for statement in method.body if _is_vm_run_try(statement)]
+    if len(run_tries) != 1:
+        raise RuntimeError(
+            f"reference Runtime.exec_utf8 run try expected once, found {len(run_tries)}"
+        )
+    run_try = run_tries[0]
+    existing = [
+        handler
+        for handler in run_try.handlers
+        if isinstance(handler.type, ast.Name) and handler.type.id == "NameError"
+    ]
+    if existing:
+        raise RuntimeError("reference Runtime.exec_utf8 already maps NameError")
+    broad_index = next(
+        (
+            index
+            for index, handler in enumerate(run_try.handlers)
+            if isinstance(handler.type, ast.Name) and handler.type.id == "BaseException"
+        ),
+        -1,
+    )
+    if broad_index < 0:
+        raise RuntimeError("reference Runtime.exec_utf8 broad handler is missing")
+    handler = ast.parse(
+        '''try:
+    pass
+except NameError as error:
+    return self._capture_native(
+        Status.NOT_FOUND,
+        "NameError",
+        "PortaPy name not found",
+    )
+'''
+    ).body[0].handlers[0]
+    run_try.handlers.insert(broad_index, handler)
+
+    ast.fix_missing_locations(tree)
+    source = ast.unparse(tree) + "\n"
+    REFERENCE_PATH.write_text(source, encoding="utf-8")
+    verified = ast.parse(source, filename=str(REFERENCE_PATH))
+    text = ast.unparse(verified)
+    required = (
+        "except NameError as error:",
+        "Status.NOT_FOUND",
+        "'NameError'",
+        "'PortaPy name not found'",
+    )
+    missing = [marker for marker in required if marker not in text]
+    if missing:
+        raise RuntimeError(f"native NameError mapping was lost: {missing}")
+    return 1
+
+
+def main() -> int:
+    vm_counts = _repair_vm()
+    mapping_count = _install_name_error_mapping()
+    print("NORMALIZED NATIVE EXCEPTION STATUSES", *vm_counts, mapping_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e00ae17fee794294cf0536e2f46ff63ef0422163 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:57:05 -0500
Subject: [PATCH 433/450] Test native exception status preservation

---
 ..._normalize_full_core_exception_statuses.py | 86 +++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 tests/test_normalize_full_core_exception_statuses.py

diff --git a/tests/test_normalize_full_core_exception_statuses.py b/tests/test_normalize_full_core_exception_statuses.py
new file mode 100644
index 00000000..59e24d98
--- /dev/null
+++ b/tests/test_normalize_full_core_exception_statuses.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_exception_statuses as normalizer
+
+
+VM_SOURCE = '''class VirtualMachine:
+    def _run_frame(self, frame):
+        while True:
+            try:
+                run()
+            except BaseException as exc:
+                exc = _NativeCaughtException(exc)
+                caught = False
+                if frame.handlers:
+                    frame.stack.append(exc)
+                    frame.active_exception = exc
+                    caught = True
+                if caught:
+                    continue
+                raise
+'''
+
+REFERENCE_SOURCE = '''class Runtime:
+    def exec_utf8(self, source):
+        try:
+            self._vm.run(source)
+        except TypeError as error:
+            return self._capture_native(Status.TYPE_ERROR, "TypeError", "PortaPy type error")
+        except BaseException as error:
+            return self._capture_native(Status.RUNTIME_ERROR, "RuntimeError", "PortaPy runtime error")
+'''
+
+
+def test_preserves_escape_identity_and_maps_name_error(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    vm_path = tmp_path / "vm.py"
+    reference_path = tmp_path / "reference_api.py"
+    vm_path.write_text(VM_SOURCE, encoding="utf-8")
+    reference_path.write_text(REFERENCE_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "VM_PATH", vm_path)
+    monkeypatch.setattr(normalizer, "REFERENCE_PATH", reference_path)
+
+    assert normalizer.main() == 0
+
+    vm_source = vm_path.read_text(encoding="utf-8")
+    assert "exc = _NativeCaughtException(exc)" not in vm_source
+    assert "native_exception = _NativeCaughtException(exc)" in vm_source
+    assert "frame.stack.append(native_exception)" in vm_source
+    assert "frame.active_exception = native_exception" in vm_source
+    assert "raise" in vm_source
+
+    reference_source = reference_path.read_text(encoding="utf-8")
+    assert "except NameError as error:" in reference_source
+    assert "Status.NOT_FOUND" in reference_source
+    assert reference_source.index("except NameError") < reference_source.index(
+        "except BaseException"
+    )
+    ast.parse(vm_source)
+    ast.parse(reference_source)
+
+
+def test_fails_closed_without_wrapper_assignment(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    vm_path = tmp_path / "vm.py"
+    reference_path = tmp_path / "reference_api.py"
+    vm_path.write_text(
+        VM_SOURCE.replace("exc = _NativeCaughtException(exc)\n", ""),
+        encoding="utf-8",
+    )
+    reference_path.write_text(REFERENCE_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "VM_PATH", vm_path)
+    monkeypatch.setattr(normalizer, "REFERENCE_PATH", reference_path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "wrapper handler" in str(error)
+    else:
+        raise AssertionError("normalizer accepted a missing exception wrapper")

From 70ac788ff6aa18386da504d2717824c2c107f68f Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:57:23 -0500
Subject: [PATCH 434/450] Transport native missing-name errors

---
 .../normalize_full_core_runtime_execution.py  | 72 ++++++++++++++++++-
 1 file changed, 69 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_runtime_execution.py b/tools/normalize_full_core_runtime_execution.py
index f7801d34..ca304d82 100644
--- a/tools/normalize_full_core_runtime_execution.py
+++ b/tools/normalize_full_core_runtime_execution.py
@@ -5,7 +5,9 @@
 inside the VM itself, including closure capture. Native low-level exception
 handlers also expose the runtime error message rather than a Python exception
 object. This final AST pass replaces the critical paths with explicit indexed
-state and wraps caught messages in a native object carrying traceback metadata.
+state, wraps caught messages in a native object carrying traceback metadata, and
+transports unresolved-name errors to the public ABI without relying on erased
+native exception classes.
 """
 from __future__ import annotations
 
@@ -16,6 +18,7 @@
 PATH = Path("src/portapy/core/vm.py")
 _ITERATOR = "_NativeSequenceIterator"
 _EXCEPTION = "_NativeCaughtException"
+_ERROR_KIND = "_native_error_kind"
 
 _HELPERS = '''
 class _NativeSequenceIterator:
@@ -79,6 +82,65 @@ def _install_helpers(tree: ast.Module) -> int:
     return len(helpers)
 
 
+def _runtime_method(runtime: ast.ClassDef, name: str) -> ast.FunctionDef:
+    matches = [
+        node
+        for node in runtime.body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"native execution expected one VirtualMachine.{name}, found {len(matches)}"
+        )
+    return matches[0]
+
+
+def _install_error_kind_transport(tree: ast.Module) -> tuple[int, int, int]:
+    runtimes = [
+        node
+        for node in tree.body
+        if isinstance(node, ast.ClassDef) and node.name == "VirtualMachine"
+    ]
+    if len(runtimes) != 1:
+        raise RuntimeError(
+            f"native execution expected one VirtualMachine class, found {len(runtimes)}"
+        )
+    runtime = runtimes[0]
+    initializer = _runtime_method(runtime, "__init__")
+    lookup = _runtime_method(runtime, "_lookup")
+    run_frame = _runtime_method(runtime, "_run_frame")
+
+    if _ERROR_KIND in ast.unparse(runtime):
+        raise RuntimeError("native error-kind transport is already installed")
+
+    initializer.body.append(ast.parse(f'self.{_ERROR_KIND} = ""').body[0])
+
+    raises = [
+        index
+        for index, statement in enumerate(lookup.body)
+        if isinstance(statement, ast.Expr)
+        and isinstance(statement.value, ast.Call)
+        and isinstance(statement.value.func, ast.Name)
+        and statement.value.func.id == "_raise_typed"
+    ]
+    if len(raises) != 1:
+        raise RuntimeError(
+            f"native lookup expected one terminal typed raise, found {len(raises)}"
+        )
+    lookup.body.insert(
+        raises[0],
+        ast.parse(f'self.{_ERROR_KIND} = "NameError"').body[0],
+    )
+
+    loops = [statement for statement in run_frame.body if isinstance(statement, ast.While)]
+    if len(loops) != 1:
+        raise RuntimeError(
+            f"native frame execution expected one instruction loop, found {len(loops)}"
+        )
+    loops[0].body.insert(0, ast.parse(f'self.{_ERROR_KIND} = ""').body[0])
+    return 1, 1, 1
+
+
 class _OpcodeRewrite(ast.NodeTransformer):
     def __init__(self) -> None:
         self.get_iter = 0
@@ -185,6 +247,7 @@ def visit_ExceptHandler(self, node: ast.ExceptHandler) -> ast.AST:
 def main() -> int:
     tree = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
     helper_count = _install_helpers(tree)
+    error_kind = _install_error_kind_transport(tree)
     opcode = _OpcodeRewrite()
     tree = opcode.visit(tree)
     exceptions = _ExceptionRewrite()
@@ -197,11 +260,12 @@ def main() -> int:
         opcode.closure_loops,
         exceptions.catches,
         exceptions.matchers,
+        *error_kind,
     )
-    if counts != (2, 1, 1, 1, 1, 1):
+    if counts != (2, 1, 1, 1, 1, 1, 1, 1, 1):
         raise RuntimeError(
             "native execution normalization expected helpers/get-iter/for-iter/"
-            f"closure/catch/matcher once; found {counts}"
+            f"closure/catch/matcher/error-kind transport once; found {counts}"
         )
 
     ast.fix_missing_locations(tree)
@@ -218,6 +282,8 @@ def main() -> int:
         "exc = _NativeCaughtException(exc)",
         "if isinstance(value, _NativeCaughtException):",
         "self.__traceback__ = True",
+        'self._native_error_kind = "NameError"',
+        'self._native_error_kind = ""',
     )
     missing = [marker for marker in required if marker not in source]
     forbidden = (

From 2cc39378626fbd2f66e51a3c186f9a06eb8a3590 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:57:53 -0500
Subject: [PATCH 435/450] Map native NameError to not found

---
 tools/normalize_full_reference_type_errors.py | 37 ++++++++-----------
 1 file changed, 16 insertions(+), 21 deletions(-)

diff --git a/tools/normalize_full_reference_type_errors.py b/tools/normalize_full_reference_type_errors.py
index 4d688211..73f030f3 100644
--- a/tools/normalize_full_reference_type_errors.py
+++ b/tools/normalize_full_reference_type_errors.py
@@ -63,27 +63,20 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
             handler = ast.ExceptHandler(
                 type=ast.Name(id="TypeError", ctx=ast.Load()),
                 name="error",
-                body=[
-                    ast.Return(
-                        value=ast.Call(
-                            func=ast.Attribute(
-                                value=ast.Name(id="self", ctx=ast.Load()),
-                                attr="_capture_native",
-                                ctx=ast.Load(),
-                            ),
-                            args=[
-                                ast.Attribute(
-                                    value=ast.Name(id="Status", ctx=ast.Load()),
-                                    attr="TYPE_ERROR",
-                                    ctx=ast.Load(),
-                                ),
-                                ast.Constant("TypeError"),
-                                ast.Constant("PortaPy type error"),
-                            ],
-                            keywords=[],
-                        )
-                    )
-                ],
+                body=ast.parse(
+                    '''if self._vm._native_error_kind == "NameError":
+    return self._capture_native(
+        Status.NOT_FOUND,
+        "NameError",
+        "PortaPy name not found",
+    )
+return self._capture_native(
+    Status.TYPE_ERROR,
+    "TypeError",
+    "PortaPy type error",
+)
+'''
+                ).body,
             )
             statement.handlers.insert(broad_index, handler)
             self.count += 1
@@ -134,6 +127,8 @@ def main() -> int:
     text = ast.unparse(type_handler)
     required_markers = (
         "except TypeError as error:",
+        "self._vm._native_error_kind == 'NameError'",
+        "Status.NOT_FOUND",
         "Status.TYPE_ERROR",
         "self._capture_native(",
     )

From 000693fe552c0bed0ce6c78857a47f2d1435c448 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:58:24 -0500
Subject: [PATCH 436/450] Test native error-kind transport

---
 tests/test_normalize_full_core_runtime_execution.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/test_normalize_full_core_runtime_execution.py b/tests/test_normalize_full_core_runtime_execution.py
index d0909675..aed5e097 100644
--- a/tests/test_normalize_full_core_runtime_execution.py
+++ b/tests/test_normalize_full_core_runtime_execution.py
@@ -7,6 +7,14 @@
 
 
 SOURCE = '''class VirtualMachine:
+    def __init__(self):
+        self.value = 0
+
+    def _lookup(self, frame, name):
+        if name in frame.locals:
+            return frame.locals[name]
+        _raise_typed(f"NameError: name {name!r} is not defined")
+
     def _exception_matches(self, value, expected):
         return False
 
@@ -57,6 +65,8 @@ def test_installs_explicit_native_execution_state(
     assert "while closure_index < len(nested.free_names):" in source
     assert "exc = _NativeCaughtException(exc)" in source
     assert "if isinstance(value, _NativeCaughtException):" in source
+    assert "self._native_error_kind = 'NameError'" in source
+    assert "self._native_error_kind = ''" in source
     assert "frame.stack.append(iter(value))" not in source
     assert "next(frame.stack[-1])" not in source
     assert "for name in nested.free_names" not in source

From 265db5f9c239a65dd54d494f077a9b8ee4d523cf Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:58:26 -0500
Subject: [PATCH 437/450] Run native exception status normalization

---
 tools/normalize_full_core_validation.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 0d6b8c5c..df2f786e 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -23,6 +23,7 @@
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
 from tools.normalize_full_core_default_expressions import main as normalize_default_expressions
+from tools.normalize_full_core_exception_statuses import main as normalize_exception_statuses
 from tools.normalize_full_core_expr_stmt_initializer import main as normalize_expr_stmt_initializer
 from tools.normalize_full_core_extended_semantics_compat import main as normalize_extended_semantics
 from tools.normalize_full_core_function_binding import main as normalize_function_binding
@@ -178,7 +179,6 @@ def main() -> int:
         ("calls_closures", normalize_calls_closures),
         ("keyword_calls", normalize_keyword_calls),
         ("combine_native_parser", combine_native_parser),
-        # The parser method only exists in native_ast after combination.
         ("default_expressions", normalize_default_expressions),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("native_parser_target_dispatch", normalize_native_parser_target_dispatch),
@@ -204,6 +204,7 @@ def main() -> int:
         ("runtime_specs", normalize_runtime_specs),
         ("runtime_dispatch", normalize_runtime_dispatch),
         ("runtime_execution", normalize_runtime_execution),
+        ("exception_statuses", normalize_exception_statuses),
         ("parameter_name_collisions", normalize_parameter_name_collisions),
         ("builtin_parameter_collisions", normalize_builtin_parameter_collisions),
         ("local_name_collisions", normalize_local_name_collisions),

From 66989184f1304f026bcab1a338a62fd2ee92baa6 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:00:14 -0500
Subject: [PATCH 438/450] Fix exception status negative fixture

---
 tests/test_normalize_full_core_exception_statuses.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/test_normalize_full_core_exception_statuses.py b/tests/test_normalize_full_core_exception_statuses.py
index 59e24d98..f82e15b0 100644
--- a/tests/test_normalize_full_core_exception_statuses.py
+++ b/tests/test_normalize_full_core_exception_statuses.py
@@ -71,7 +71,10 @@ def test_fails_closed_without_wrapper_assignment(
     vm_path = tmp_path / "vm.py"
     reference_path = tmp_path / "reference_api.py"
     vm_path.write_text(
-        VM_SOURCE.replace("exc = _NativeCaughtException(exc)\n", ""),
+        VM_SOURCE.replace(
+            "                exc = _NativeCaughtException(exc)\n",
+            "",
+        ),
         encoding="utf-8",
     )
     reference_path.write_text(REFERENCE_SOURCE, encoding="utf-8")

From 24ad28496a19697aec69ea2110a66e997db6a555 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:00:36 -0500
Subject: [PATCH 439/450] Fix native error transport validation

---
 tools/normalize_full_core_runtime_execution.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_core_runtime_execution.py b/tools/normalize_full_core_runtime_execution.py
index ca304d82..c216e3da 100644
--- a/tools/normalize_full_core_runtime_execution.py
+++ b/tools/normalize_full_core_runtime_execution.py
@@ -282,8 +282,8 @@ def main() -> int:
         "exc = _NativeCaughtException(exc)",
         "if isinstance(value, _NativeCaughtException):",
         "self.__traceback__ = True",
-        'self._native_error_kind = "NameError"',
-        'self._native_error_kind = ""',
+        "self._native_error_kind = 'NameError'",
+        "self._native_error_kind = ''",
     )
     missing = [marker for marker in required if marker not in source]
     forbidden = (

From 9da916fe600cd258601a2959cfca65ebabc2d7a5 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:02:49 -0500
Subject: [PATCH 440/450] Preserve native TypeError detail

---
 tools/normalize_full_reference_type_errors.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/tools/normalize_full_reference_type_errors.py b/tools/normalize_full_reference_type_errors.py
index 73f030f3..5a9e4ebe 100644
--- a/tools/normalize_full_reference_type_errors.py
+++ b/tools/normalize_full_reference_type_errors.py
@@ -68,12 +68,12 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
     return self._capture_native(
         Status.NOT_FOUND,
         "NameError",
-        "PortaPy name not found",
+        error,
     )
 return self._capture_native(
     Status.TYPE_ERROR,
     "TypeError",
-    "PortaPy type error",
+    error,
 )
 '''
                 ).body,
@@ -131,12 +131,20 @@ def main() -> int:
         "Status.NOT_FOUND",
         "Status.TYPE_ERROR",
         "self._capture_native(",
+        "'NameError', error",
+        "'TypeError', error",
     )
     missing_markers = [marker for marker in required_markers if marker not in text]
     if missing_markers:
         raise RuntimeError(
             f"native reference TypeError validation failed: {missing_markers}"
         )
+    generic_markers = ("PortaPy name not found", "PortaPy type error")
+    remaining = [marker for marker in generic_markers if marker in text]
+    if remaining:
+        raise RuntimeError(
+            f"native TypeError detail is still replaced: {remaining}"
+        )
     print("NORMALIZED NATIVE REFERENCE TYPE ERRORS", rewriter.count)
     return 0
 

From 94dc3311ed54cd8d9ed6b05edf91d04caed91146 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:04:45 -0500
Subject: [PATCH 441/450] Use one native exception status transport

---
 tools/normalize_full_core_validation.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index df2f786e..df33e59b 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -23,7 +23,6 @@
 from tools.normalize_full_core_closures import main as normalize_closures
 from tools.normalize_full_core_collections import main as normalize_collections
 from tools.normalize_full_core_default_expressions import main as normalize_default_expressions
-from tools.normalize_full_core_exception_statuses import main as normalize_exception_statuses
 from tools.normalize_full_core_expr_stmt_initializer import main as normalize_expr_stmt_initializer
 from tools.normalize_full_core_extended_semantics_compat import main as normalize_extended_semantics
 from tools.normalize_full_core_function_binding import main as normalize_function_binding
@@ -204,7 +203,6 @@ def main() -> int:
         ("runtime_specs", normalize_runtime_specs),
         ("runtime_dispatch", normalize_runtime_dispatch),
         ("runtime_execution", normalize_runtime_execution),
-        ("exception_statuses", normalize_exception_statuses),
         ("parameter_name_collisions", normalize_parameter_name_collisions),
         ("builtin_parameter_collisions", normalize_builtin_parameter_collisions),
         ("local_name_collisions", normalize_local_name_collisions),

From c12d9b6b2f73e14fbb856076a522ae07a9a96867 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:16:46 -0500
Subject: [PATCH 442/450] Preserve positional and keyword parameter markers

---
 .../normalize_full_core_parameter_markers.py  | 293 ++++++++++++++++++
 1 file changed, 293 insertions(+)
 create mode 100644 tools/normalize_full_core_parameter_markers.py

diff --git a/tools/normalize_full_core_parameter_markers.py b/tools/normalize_full_core_parameter_markers.py
new file mode 100644
index 00000000..54fe9089
--- /dev/null
+++ b/tools/normalize_full_core_parameter_markers.py
@@ -0,0 +1,293 @@
+"""Preserve ``/`` and ``*`` function-parameter markers in the native parser.
+
+The pinned parser accepts a bare ``*`` but flattens every named parameter into one
+list, and it rejects the positional-only ``/`` marker entirely.  Carry two private
+sentinel entries through the vendored FuncDef parameter/default arrays, then remove
+them while constructing PortaPy's compatibility ``arguments`` node.  This avoids
+changing the pinned compiler AST schema while retaining Python's positional-only
+and keyword-only partitions and their independent defaults.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/core/native_ast.py")
+_PARSER_CLASS = "_npr_parser_Parser"
+_FUNCDEF_CLASS = "_npr_ast_nodes_FuncDef"
+_ARGUMENT_CLASS = "AstArg"
+_POSONLY_MARKER = "__portapy_posonly_marker__"
+_KWONLY_MARKER = "__portapy_kwonly_marker__"
+
+
+_PARSER_BODY = f'''start = self._peek().pos
+self._expect("KEYWORD", "def")
+name = self._expect("NAME").value
+self._expect("OP", "(")
+params: list[str] = []
+defaults: list[object] = []
+param_types: list[object] = []
+vararg: str | None = None
+kwarg: str | None = None
+first = True
+posonly_seen = False
+keyword_only = False
+positional_default_seen = False
+kwarg_seen = False
+while not self._check("OP", ")"):
+    if not first:
+        self._expect("OP", ",")
+        if self._check("OP", ")"):
+            break
+    first = False
+    if kwarg_seen:
+        raise _npr_errors_ParseError("parameter follows **kwargs", self._peek().pos)
+    if self._check("OP", "/"):
+        if posonly_seen or keyword_only or len(params) == 0:
+            raise _npr_errors_ParseError("invalid positional-only marker", self._peek().pos)
+        self._eat()
+        params.append("{_POSONLY_MARKER}")
+        defaults.append(None)
+        param_types.append(None)
+        posonly_seen = True
+        continue
+    if self._check("OP", "**"):
+        self._eat()
+        kwarg = self._expect("NAME").value
+        if self._check("OP", ":"):
+            self._eat()
+            self._parse_type_annotation()
+        params.append(kwarg)
+        param_types.append(("dict", None))
+        defaults.append(None)
+        kwarg_seen = True
+        continue
+    if self._check("OP", "*"):
+        self._eat()
+        if keyword_only:
+            raise _npr_errors_ParseError("duplicate keyword-only marker", self._peek().pos)
+        if self._check("NAME"):
+            vararg = self._expect("NAME").value
+            element_type = None
+            if self._check("OP", ":"):
+                self._eat()
+                inner = self._parse_type_annotation()
+                element_type = inner[0] if inner else None
+            params.append(vararg)
+            param_types.append(("list", element_type))
+            defaults.append(None)
+        params.append("{_KWONLY_MARKER}")
+        param_types.append(None)
+        defaults.append(None)
+        keyword_only = True
+        continue
+    parameter_name = self._expect("NAME").value
+    params.append(parameter_name)
+    annotation = None
+    if self._check("OP", ":"):
+        self._eat()
+        annotation = self._parse_type_annotation()
+    param_types.append(annotation)
+    default = self._parse_optional_default()
+    if not keyword_only:
+        if default is None and positional_default_seen:
+            raise _npr_errors_ParseError(
+                "non-default argument follows default argument",
+                self._peek().pos,
+            )
+        if default is not None:
+            positional_default_seen = True
+    defaults.append(default)
+self._expect("OP", ")")
+ret_type = None
+if self._check("OP", "->"):
+    self._eat()
+    ret_type = self._parse_type_annotation()
+self._expect("OP", ":")
+body = self._parse_block()
+asm_body = None
+asm_symbol = None
+if decorators and self._ASM_DECORATOR in decorators:
+    asm_body, asm_symbol = self._extract_asm_body(name, body, start)
+return {_FUNCDEF_CLASS}(
+    name=name,
+    params=params,
+    body=body,
+    pos=start,
+    defaults=defaults,
+    param_types=param_types,
+    ret_type=ret_type,
+    vararg=vararg,
+    kwarg=kwarg,
+    asm_body=asm_body,
+    asm_symbol=asm_symbol,
+    decorators=list(decorators) if decorators else [],
+    readonly_params=list(self._pending_readonly_params),
+)
+'''
+
+
+_BRIDGE_BODY = f'''native_params: list[str] = getattr(node, "params")
+native_defaults: list[dict] = getattr(node, "defaults")
+posonly_marker = -1
+kwonly_marker = -1
+marker_index = 0
+while marker_index < len(native_params):
+    marker_name = native_params[marker_index]
+    if marker_name == "{_POSONLY_MARKER}":
+        posonly_marker = marker_index
+    elif marker_name == "{_KWONLY_MARKER}":
+        kwonly_marker = marker_index
+    marker_index += 1
+positional_only: list[{_ARGUMENT_CLASS}] = []
+regular: list[{_ARGUMENT_CLASS}] = []
+keyword_only: list[{_ARGUMENT_CLASS}] = []
+defaults: list[dict] = []
+keyword_defaults: list[dict] = []
+vararg_name = getattr(node, "vararg")
+kwarg_name = getattr(node, "kwarg")
+parameter_index = 0
+while parameter_index < len(native_params):
+    parameter_name = native_params[parameter_index]
+    if (
+        parameter_name != "{_POSONLY_MARKER}"
+        and parameter_name != "{_KWONLY_MARKER}"
+        and parameter_name != vararg_name
+        and parameter_name != kwarg_name
+    ):
+        parameter = {_ARGUMENT_CLASS}(parameter_name)
+        default_node: dict = native_defaults[parameter_index]
+        if kwonly_marker >= 0 and parameter_index > kwonly_marker:
+            keyword_only.append(parameter)
+            if default_node is None:
+                keyword_defaults.append(None)
+            else:
+                converted_keyword_default: dict = _convert_expr(default_node, lifted)
+                keyword_defaults.append(converted_keyword_default)
+        else:
+            if posonly_marker >= 0 and parameter_index < posonly_marker:
+                positional_only.append(parameter)
+            else:
+                regular.append(parameter)
+            if default_node is not None:
+                converted_default: dict = _convert_expr(default_node, lifted)
+                defaults.append(converted_default)
+    parameter_index += 1
+vararg_node = None
+if vararg_name is not None:
+    vararg_node = {_ARGUMENT_CLASS}(vararg_name)
+kwarg_node = None
+if kwarg_name is not None:
+    kwarg_node = {_ARGUMENT_CLASS}(kwarg_name)
+return arguments(
+    positional_only,
+    regular,
+    vararg_node,
+    keyword_only,
+    keyword_defaults,
+    kwarg_node,
+    defaults,
+)
+'''
+
+
+def _parser_method(module: ast.Module) -> ast.FunctionDef:
+    classes = [
+        node
+        for node in module.body
+        if isinstance(node, ast.ClassDef) and node.name == _PARSER_CLASS
+    ]
+    if len(classes) != 1:
+        raise RuntimeError(
+            f"native parameter markers expected one parser class, found {len(classes)}"
+        )
+    methods = [
+        node
+        for node in classes[0].body
+        if isinstance(node, ast.FunctionDef) and node.name == "_parse_funcdef"
+    ]
+    if len(methods) != 1:
+        raise RuntimeError(
+            f"native parameter markers expected one function parser, found {len(methods)}"
+        )
+    return methods[0]
+
+
+def _bridge_function(module: ast.Module) -> ast.FunctionDef:
+    functions = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_convert_arguments"
+    ]
+    if len(functions) != 1:
+        raise RuntimeError(
+            f"native parameter markers expected one argument bridge, found {len(functions)}"
+        )
+    return functions[0]
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    parser = _parser_method(module)
+    bridge = _bridge_function(module)
+
+    parser_text = ast.unparse(parser)
+    bridge_text = ast.unparse(bridge)
+    if _POSONLY_MARKER in parser_text or _KWONLY_MARKER in parser_text:
+        raise RuntimeError("native function parser already carries parameter markers")
+    if "self._check('OP', '/')" in parser_text:
+        raise RuntimeError("native function parser has an unknown slash implementation")
+    if "return arguments([], all_args" not in bridge_text:
+        raise RuntimeError("native argument bridge no longer has the flattened source shape")
+
+    parser.body = ast.parse(_PARSER_BODY).body
+    bridge.body = ast.parse(_BRIDGE_BODY).body
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source, filename=str(PATH))
+    parser_text = ast.unparse(_parser_method(verified))
+    bridge_text = ast.unparse(_bridge_function(verified))
+    parser_required = (
+        "self._check('OP', '/')",
+        f"params.append('{_POSONLY_MARKER}')",
+        f"params.append('{_KWONLY_MARKER}')",
+        "keyword_only = True",
+        "positional_default_seen = True",
+    )
+    bridge_required = (
+        f"parameter_name != '{_POSONLY_MARKER}'",
+        f"parameter_name != '{_KWONLY_MARKER}'",
+        "positional_only.append(parameter)",
+        "keyword_only.append(parameter)",
+        "keyword_defaults.append(None)",
+        "return arguments(positional_only, regular, vararg_node, keyword_only",
+    )
+    missing = [
+        marker
+        for marker in (*parser_required, *bridge_required)
+        if marker not in parser_text and marker not in bridge_text
+    ]
+    if missing:
+        raise RuntimeError(f"native parameter marker repair was lost: {missing}")
+    forbidden = (
+        "return arguments([], all_args",
+        "self._parse_param(params, defaults, param_types)",
+    )
+    remaining = [
+        marker
+        for marker in forbidden
+        if marker in parser_text or marker in bridge_text
+    ]
+    if remaining:
+        raise RuntimeError(f"flattened parameter handling remains: {remaining}")
+
+    print("NORMALIZED NATIVE PARAMETER MARKERS", 1, 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 1a45892f9cfdd044fd3c6bae4a5a9c8ee748261c Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:17:12 -0500
Subject: [PATCH 443/450] Test native function parameter markers

---
 ...t_normalize_full_core_parameter_markers.py | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 tests/test_normalize_full_core_parameter_markers.py

diff --git a/tests/test_normalize_full_core_parameter_markers.py b/tests/test_normalize_full_core_parameter_markers.py
new file mode 100644
index 00000000..b78d1ac3
--- /dev/null
+++ b/tests/test_normalize_full_core_parameter_markers.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_parameter_markers as normalizer
+
+
+SOURCE = '''class _npr_parser_Parser:
+    def _parse_funcdef(self, decorators=None):
+        start = self._peek().pos
+        self._expect("KEYWORD", "def")
+        name = self._expect("NAME").value
+        self._expect("OP", "(")
+        params = []
+        defaults = []
+        param_types = []
+        vararg = None
+        kwarg = None
+        first = True
+        while not self._check("OP", ")"):
+            if not first:
+                self._expect("OP", ",")
+            first = False
+            self._parse_param(params, defaults, param_types)
+        self._expect("OP", ")")
+        self._expect("OP", ":")
+        body = self._parse_block()
+        return _npr_ast_nodes_FuncDef(name=name, params=params, body=body)
+
+def _convert_arguments(node, lifted):
+    all_args = [AstArg(name) for name in node.params]
+    defaults = []
+    return arguments([], all_args, None if node.vararg is None else AstArg(node.vararg), [], [], None if node.kwarg is None else AstArg(node.kwarg), defaults)
+'''
+
+
+def test_preserves_slash_and_star_partitions(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    assert normalizer.main() == 0
+
+    source = path.read_text(encoding="utf-8")
+    assert "self._check('OP', '/')" in source
+    assert "__portapy_posonly_marker__" in source
+    assert "__portapy_kwonly_marker__" in source
+    assert "positional_only.append(parameter)" in source
+    assert "keyword_only.append(parameter)" in source
+    assert "keyword_defaults.append(None)" in source
+    assert "return arguments(positional_only, regular, vararg_node" in source
+    assert "return arguments([], all_args" not in source
+    ast.parse(source)
+
+
+def test_fails_closed_for_unknown_bridge_shape(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    path = tmp_path / "native_ast.py"
+    path.write_text(
+        SOURCE.replace(
+            "return arguments([], all_args, None if node.vararg is None else AstArg(node.vararg), [], [], None if node.kwarg is None else AstArg(node.kwarg), defaults)",
+            "return arguments([], all_args, None, [], [], None, defaults)",
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(normalizer, "PATH", path)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "flattened source shape" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unexpected argument bridge")

From 4cbec73a17c7b7a3bcae1f256e837f2021c46629 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:18:13 -0500
Subject: [PATCH 444/450] Run native parameter marker normalization

---
 tools/normalize_full_core_validation.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index df33e59b..a09fdc4b 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -42,6 +42,7 @@
 from tools.normalize_full_core_native_semantics import main as normalize_native_semantics
 from tools.normalize_full_core_native_statement_bodies import main as normalize_native_statement_bodies
 from tools.normalize_full_core_opcode_maps import main as normalize_opcode_maps
+from tools.normalize_full_core_parameter_markers import main as normalize_parameter_markers
 from tools.normalize_full_core_parameter_name_collisions import main as normalize_parameter_name_collisions
 from tools.normalize_full_core_parser_errors import main as normalize_parser_errors
 from tools.normalize_full_core_pattern_constructor_collisions import main as normalize_pattern_constructor_collisions
@@ -166,7 +167,7 @@ def main() -> int:
         ("reference_error_locations", normalize_reference_error_locations),
         ("reference_value_kinds", normalize_reference_value_kinds),
         ("reference_expression_kinds", normalize_reference_expression_kinds),
-        ("reference_function_return_kinds", normalize_reference_function_return_kinds),
+        ("reference_function_return_kinds", normalize_function_return_kinds),
         ("reference_nested_kinds", normalize_reference_nested_kinds),
         ("reference_source_preprocess", normalize_reference_source_preprocess),
         ("reference_data_builders", normalize_reference_data_builders),
@@ -179,6 +180,7 @@ def main() -> int:
         ("keyword_calls", normalize_keyword_calls),
         ("combine_native_parser", combine_native_parser),
         ("default_expressions", normalize_default_expressions),
+        ("parameter_markers", normalize_parameter_markers),
         ("native_parser_expressions", normalize_native_parser_expressions),
         ("native_parser_target_dispatch", normalize_native_parser_target_dispatch),
         ("parser_errors", normalize_parser_errors),

From 607bd9c0bfc7d10c50555004c615354b2868b226 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:19:19 -0500
Subject: [PATCH 445/450] Fix return kind normalizer callback

---
 tools/normalize_full_core_validation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index a09fdc4b..cdc14835 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -167,7 +167,7 @@ def main() -> int:
         ("reference_error_locations", normalize_reference_error_locations),
         ("reference_value_kinds", normalize_reference_value_kinds),
         ("reference_expression_kinds", normalize_reference_expression_kinds),
-        ("reference_function_return_kinds", normalize_function_return_kinds),
+        ("reference_function_return_kinds", normalize_reference_function_return_kinds),
         ("reference_nested_kinds", normalize_reference_nested_kinds),
         ("reference_source_preprocess", normalize_reference_source_preprocess),
         ("reference_data_builders", normalize_reference_data_builders),

From b49c87a2a134e2b014b9a10773347d92f6bb85e1 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:22:24 -0500
Subject: [PATCH 446/450] Validate exact flattened argument bridge shape

---
 tools/normalize_full_core_parameter_markers.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/tools/normalize_full_core_parameter_markers.py b/tools/normalize_full_core_parameter_markers.py
index 54fe9089..6158eaad 100644
--- a/tools/normalize_full_core_parameter_markers.py
+++ b/tools/normalize_full_core_parameter_markers.py
@@ -1,9 +1,9 @@
 """Preserve ``/`` and ``*`` function-parameter markers in the native parser.
 
 The pinned parser accepts a bare ``*`` but flattens every named parameter into one
-list, and it rejects the positional-only ``/`` marker entirely.  Carry two private
+list, and it rejects the positional-only ``/`` marker entirely. Carry two private
 sentinel entries through the vendored FuncDef parameter/default arrays, then remove
-them while constructing PortaPy's compatibility ``arguments`` node.  This avoids
+them while constructing PortaPy's compatibility ``arguments`` node. This avoids
 changing the pinned compiler AST schema while retaining Python's positional-only
 and keyword-only partitions and their independent defaults.
 """
@@ -19,6 +19,11 @@
 _ARGUMENT_CLASS = "AstArg"
 _POSONLY_MARKER = "__portapy_posonly_marker__"
 _KWONLY_MARKER = "__portapy_kwonly_marker__"
+_FLAT_BRIDGE_RETURN = (
+    "return arguments([], all_args, None if node.vararg is None else "
+    "AstArg(node.vararg), [], [], None if node.kwarg is None else "
+    "AstArg(node.kwarg), defaults)"
+)
 
 
 _PARSER_BODY = f'''start = self._peek().pos
@@ -238,7 +243,7 @@ def main() -> int:
         raise RuntimeError("native function parser already carries parameter markers")
     if "self._check('OP', '/')" in parser_text:
         raise RuntimeError("native function parser has an unknown slash implementation")
-    if "return arguments([], all_args" not in bridge_text:
+    if _FLAT_BRIDGE_RETURN not in bridge_text:
         raise RuntimeError("native argument bridge no longer has the flattened source shape")
 
     parser.body = ast.parse(_PARSER_BODY).body

From 5c0d623d4f6a92355f068c880a58b70386a17959 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:31:53 -0500
Subject: [PATCH 447/450] Lower native len calls with value-kind hints

---
 tools/normalize_full_core_len.py | 159 +++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 tools/normalize_full_core_len.py

diff --git a/tools/normalize_full_core_len.py b/tools/normalize_full_core_len.py
new file mode 100644
index 00000000..290176ee
--- /dev/null
+++ b/tools/normalize_full_core_len.py
@@ -0,0 +1,159 @@
+"""Lower direct ``len`` calls with the native value-kind hint.
+
+The pinned compiler specializes ``len(value: object)`` as ``strlen``. That works
+for text, but it dereferences tuple/list/dict/bytes values as C strings and crashes
+for empty containers. Direct builtin calls already pass through the frontend, where
+PortaPy's truthiness pipeline can classify literals and tracked names. Thread that
+kind into a two-argument native builtin and use statically typed aliases for the
+actual string/container length operations.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+LOADER_PATH = Path("src/portapy/core/loader.py")
+FRONTEND_PATH = Path("src/portapy/core/frontend.py")
+
+
+_LEN_FUNCTION = '''def _builtin_len(value: object, kind: int = 0) -> int:
+    if kind == 4:
+        text_value: str = value
+        return len(text_value)
+    if kind == 5 or kind == 6:
+        container_value: list = value
+        return len(container_value)
+    raise TypeError("object has no len")
+'''
+
+
+_SPECIAL_CALL = '''if (
+    isinstance(node, ast.Call)
+    and isinstance(node.func, ast.Name)
+    and node.func.id == "len"
+    and node.func.id not in self.bound_names
+    and len(node.args) == 1
+    and not isinstance(node.args[0], ast.Starred)
+    and not node.keywords
+):
+    self.expr(node.func)
+    self.expr(node.args[0])
+    self.emit(Op.LOAD_CONST, self.constant(self.expression_kind(node.args[0])))
+    self.emit(Op.CALL, 2)
+'''
+
+
+def _normalize_loader() -> int:
+    module = ast.parse(
+        LOADER_PATH.read_text(encoding="utf-8"),
+        filename=str(LOADER_PATH),
+    )
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_builtin_len"
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(f"native len builtin expected once, found {len(matches)}")
+    function = matches[0]
+    original = ast.unparse(function)
+    if "return len(value)" not in original or len(function.args.args) != 1:
+        raise RuntimeError("native len builtin no longer has the unsafe object shape")
+
+    replacement = ast.parse(_LEN_FUNCTION).body[0]
+    replacement.decorator_list = function.decorator_list
+    module.body[module.body.index(function)] = replacement
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    LOADER_PATH.write_text(source, encoding="utf-8")
+
+    required = (
+        "def _builtin_len(value: object, kind: int=0) -> int:",
+        "text_value: str = value",
+        "container_value: list = value",
+        "kind == 5 or kind == 6",
+        "raise TypeError('object has no len')",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing or "def _builtin_len(value: object)" in source:
+        raise RuntimeError(f"native len builtin repair was lost: {missing}")
+    return 1
+
+
+def _is_simple_call_branch(node: ast.If) -> bool:
+    text = ast.unparse(node.test)
+    return (
+        "isinstance(node, ast.Call)" in text
+        and "not node.keywords" in text
+        and "all((not isinstance(arg, ast.Starred) for arg in node.args))" in text
+    )
+
+
+def _normalize_frontend() -> int:
+    module = ast.parse(
+        FRONTEND_PATH.read_text(encoding="utf-8"),
+        filename=str(FRONTEND_PATH),
+    )
+    lowerer = next(
+        (
+            node
+            for node in module.body
+            if isinstance(node, ast.ClassDef) and node.name == "_Lowerer"
+        ),
+        None,
+    )
+    if lowerer is None:
+        raise RuntimeError("native len frontend lost the _Lowerer class")
+    method = next(
+        (
+            node
+            for node in lowerer.body
+            if isinstance(node, ast.FunctionDef) and node.name == "expr"
+        ),
+        None,
+    )
+    if method is None:
+        raise RuntimeError("native len frontend lost _Lowerer.expr")
+    branches = [node for node in ast.walk(method) if isinstance(node, ast.If) and _is_simple_call_branch(node)]
+    if len(branches) != 1:
+        raise RuntimeError(
+            f"native len expected one simple-call branch, found {len(branches)}"
+        )
+    branch = branches[0]
+    original = ast.If(
+        test=branch.test,
+        body=branch.body,
+        orelse=branch.orelse,
+    )
+    special = ast.parse(_SPECIAL_CALL).body[0]
+    branch.test = special.test
+    branch.body = special.body
+    branch.orelse = [original]
+
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    FRONTEND_PATH.write_text(source, encoding="utf-8")
+    required = (
+        "node.func.id == 'len'",
+        "node.func.id not in self.bound_names",
+        "self.constant(self.expression_kind(node.args[0]))",
+        "self.emit(Op.CALL, 2)",
+    )
+    missing = [marker for marker in required if marker not in source]
+    if missing:
+        raise RuntimeError(f"native len frontend repair was lost: {missing}")
+    if source.count("self.constant(self.expression_kind(node.args[0]))") != 1:
+        raise RuntimeError("native len frontend kind transport is not unique")
+    return 1
+
+
+def main() -> int:
+    loader_count = _normalize_loader()
+    frontend_count = _normalize_frontend()
+    print("NORMALIZED NATIVE LEN", loader_count, frontend_count)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From e9712dfcf65bf616838d315d9cbe9176bfa8d315 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:32:18 -0500
Subject: [PATCH 448/450] Test kind-aware native len lowering

---
 tests/test_normalize_full_core_len.py | 74 +++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 tests/test_normalize_full_core_len.py

diff --git a/tests/test_normalize_full_core_len.py b/tests/test_normalize_full_core_len.py
new file mode 100644
index 00000000..6c57deb4
--- /dev/null
+++ b/tests/test_normalize_full_core_len.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from tools import normalize_full_core_len as normalizer
+
+
+LOADER_SOURCE = '''def _builtin_len(value: object) -> int:
+    return len(value)
+'''
+
+FRONTEND_SOURCE = '''class _Lowerer:
+    def expr(self, node):
+        if isinstance(node, ast.Constant):
+            pass
+        elif isinstance(node, ast.Call) and not node.keywords and all(not isinstance(arg, ast.Starred) for arg in node.args):
+            self.expr(node.func)
+            for arg in node.args:
+                self.expr(arg)
+            self.emit(Op.CALL, len(node.args))
+        elif isinstance(node, ast.Call):
+            pass
+'''
+
+
+def test_threads_expression_kind_into_native_len(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    loader = tmp_path / "loader.py"
+    frontend = tmp_path / "frontend.py"
+    loader.write_text(LOADER_SOURCE, encoding="utf-8")
+    frontend.write_text(FRONTEND_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "LOADER_PATH", loader)
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+
+    assert normalizer.main() == 0
+
+    loader_source = loader.read_text(encoding="utf-8")
+    assert "def _builtin_len(value: object, kind: int=0) -> int:" in loader_source
+    assert "text_value: str = value" in loader_source
+    assert "container_value: list = value" in loader_source
+    assert "kind == 5 or kind == 6" in loader_source
+
+    frontend_source = frontend.read_text(encoding="utf-8")
+    assert "node.func.id == 'len'" in frontend_source
+    assert "self.constant(self.expression_kind(node.args[0]))" in frontend_source
+    assert "self.emit(Op.CALL, 2)" in frontend_source
+    assert frontend_source.count("self.emit(Op.CALL, 2)") == 1
+    ast.parse(loader_source)
+    ast.parse(frontend_source)
+
+
+def test_fails_closed_when_len_builtin_shape_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    loader = tmp_path / "loader.py"
+    frontend = tmp_path / "frontend.py"
+    loader.write_text(
+        LOADER_SOURCE.replace("return len(value)", "return 0"),
+        encoding="utf-8",
+    )
+    frontend.write_text(FRONTEND_SOURCE, encoding="utf-8")
+    monkeypatch.setattr(normalizer, "LOADER_PATH", loader)
+    monkeypatch.setattr(normalizer, "FRONTEND_PATH", frontend)
+
+    try:
+        normalizer.main()
+    except RuntimeError as error:
+        assert "unsafe object shape" in str(error)
+    else:
+        raise AssertionError("normalizer accepted an unexpected len builtin")

From ac0d61d0f5eec242729a4283ded02f6cd04b7da2 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:33:23 -0500
Subject: [PATCH 449/450] Run kind-aware native len normalization

---
 tools/normalize_full_core_validation.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index cdc14835..921c1929 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -30,6 +30,7 @@
 from tools.normalize_full_core_function_specs import main as normalize_function_specs
 from tools.normalize_full_core_keyword_calls import main as normalize_keyword_calls
 from tools.normalize_full_core_lambdas import main as normalize_lambdas
+from tools.normalize_full_core_len import main as normalize_len
 from tools.normalize_full_core_local_name_collisions import main as normalize_local_name_collisions
 from tools.normalize_full_core_make_function import main as normalize_make_function
 from tools.normalize_full_core_name_index import main as normalize_name_index
@@ -200,6 +201,7 @@ def main() -> int:
         ("nested_code_introspection", _normalize_nested_code_introspection),
         ("opcode_validation", _normalize_opcode_validation),
         ("truthiness", normalize_truthiness),
+        ("len", normalize_len),
         ("string_addition", normalize_string_addition),
         ("reference_type_errors", normalize_reference_type_errors),
         ("runtime_specs", normalize_runtime_specs),

From 614dc4c9cf62158ab40afe52e9139535077e8020 Mon Sep 17 00:00:00 2001
From: deltathedumb <133447617+deltathedumb@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:39:15 -0500
Subject: [PATCH 450/450] Fix native container length lowering

---
 tests/test_full_core_probe.py                 |   6 +
 tests/test_full_reference_container_access.py |  62 +++++++++
 ...st_normalize_full_core_validation_order.py |  10 ++
 tools/normalize_full_core_validation.py       |   2 +
 ...rmalize_full_reference_container_access.py | 127 ++++++++++++++++++
 5 files changed, 207 insertions(+)
 create mode 100644 tests/test_full_reference_container_access.py
 create mode 100644 tools/normalize_full_reference_container_access.py

diff --git a/tests/test_full_core_probe.py b/tests/test_full_core_probe.py
index 5b98f4c1..e44c192c 100644
--- a/tests/test_full_core_probe.py
+++ b/tests/test_full_core_probe.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+from pathlib import Path
 import sys
 
 from tools.materialize_full_reference_entry import main as materialize_reference_entry
@@ -18,6 +19,9 @@
     "portapy.native_full_reference_entry",
     "portapy.reference_api",
 )
+_NATIVE_ENTRY_PATH = (
+    Path(__file__).parents[1] / "src" / "portapy" / "native_full_reference_entry.py"
+)
 
 
 def _unload_temporary_modules() -> None:
@@ -28,6 +32,7 @@ def _unload_temporary_modules() -> None:
 
 def test_full_core_probe_executes_reference_abi_path() -> None:
     original_reference_runtime = REFERENCE_RUNTIME_PATH.read_text(encoding="utf-8")
+    original_native_entry = _NATIVE_ENTRY_PATH.read_text(encoding="utf-8")
     try:
         _unload_temporary_modules()
         normalize_reference_runtime()
@@ -49,4 +54,5 @@ def test_full_core_probe_executes_reference_abi_path() -> None:
             original_reference_runtime,
             encoding="utf-8",
         )
+        _NATIVE_ENTRY_PATH.write_text(original_native_entry, encoding="utf-8")
         _unload_temporary_modules()
diff --git a/tests/test_full_reference_container_access.py b/tests/test_full_reference_container_access.py
new file mode 100644
index 00000000..351a492d
--- /dev/null
+++ b/tests/test_full_reference_container_access.py
@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+from tools import materialize_full_reference_entry as materializer
+from tools import normalize_full_reference_abi_helpers as abi_normalizer
+from tools import normalize_full_reference_container_access as container_normalizer
+
+
+def _function_source(module: ast.Module, name: str) -> str:
+    function = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    )
+    return ast.unparse(function)
+
+
+def test_container_lengths_cross_typed_native_boundaries(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    output = tmp_path / "native_full_reference_entry.py"
+    monkeypatch.setattr(materializer, "OUTPUT", output)
+    monkeypatch.setattr(abi_normalizer, "PATH", output)
+    monkeypatch.setattr(container_normalizer, "PATH", output)
+
+    assert materializer.main() == 0
+    assert abi_normalizer.main() == 0
+    assert container_normalizer.main() == 0
+
+    module = ast.parse(output.read_text(encoding="utf-8"))
+    sequence_functions = (
+        "_portapy_tuple_set_item_impl",
+        "_portapy_tuple_get_size_impl",
+        "_portapy_tuple_get_item_impl",
+        "_portapy_list_get_size_impl",
+        "_portapy_list_get_item_impl",
+        "_portapy_list_set_item_impl",
+    )
+    for name in sequence_functions:
+        source = _function_source(module, name)
+        assert "_native_sequence_size(" in source
+        assert "len(" not in source
+
+    dict_source = _function_source(module, "_portapy_dict_get_size_impl")
+    assert "_native_dict_size(target)" in dict_source
+    assert "len(" not in dict_source
+
+    sequence_helper = _function_source(module, "_native_sequence_size")
+    assert "values: list[object]" in sequence_helper
+    assert "return len(values)" in sequence_helper
+
+    dict_helper = _function_source(module, "_native_dict_size")
+    assert "values: dict[str, object]" in dict_helper
+    assert "return len(values)" in dict_helper
+
+    with pytest.raises(RuntimeError, match="already installed"):
+        container_normalizer.main()
diff --git a/tests/test_normalize_full_core_validation_order.py b/tests/test_normalize_full_core_validation_order.py
index 8f366750..bf9ad8fc 100644
--- a/tests/test_normalize_full_core_validation_order.py
+++ b/tests/test_normalize_full_core_validation_order.py
@@ -17,3 +17,13 @@ def test_match_defaults_precede_constructor_collision_renames() -> None:
     node_fields = source.index('("native_node_fields"')
 
     assert extended < expr_stmt < pattern_collision < node_fields
+
+
+def test_typed_container_access_follows_reference_data_access() -> None:
+    source = VALIDATION.read_text(encoding="utf-8")
+
+    data_access = source.index('("reference_data_access"')
+    container_access = source.index('("reference_container_access"')
+    handle_kind_access = source.index('("reference_handle_kind_access"')
+
+    assert data_access < container_access < handle_kind_access
diff --git a/tools/normalize_full_core_validation.py b/tools/normalize_full_core_validation.py
index 921c1929..db709102 100644
--- a/tools/normalize_full_core_validation.py
+++ b/tools/normalize_full_core_validation.py
@@ -58,6 +58,7 @@
 from tools.normalize_full_core_tracebacks import main as normalize_tracebacks
 from tools.normalize_full_reference_abi_helpers import main as normalize_reference_abi_helpers
 from tools.normalize_full_reference_bytes_literals import main as normalize_reference_bytes_literals
+from tools.normalize_full_reference_container_access import main as normalize_reference_container_access
 from tools.normalize_full_reference_data_access import main as normalize_reference_data_access
 from tools.normalize_full_reference_data_builders import main as normalize_reference_data_builders
 from tools.normalize_full_reference_error_locations import main as normalize_reference_error_locations
@@ -173,6 +174,7 @@ def main() -> int:
         ("reference_source_preprocess", normalize_reference_source_preprocess),
         ("reference_data_builders", normalize_reference_data_builders),
         ("reference_data_access", normalize_reference_data_access),
+        ("reference_container_access", normalize_reference_container_access),
         ("reference_handle_kind_access", normalize_reference_handle_kind_access),
         ("reference_bytes_literals", normalize_reference_bytes_literals),
         ("native_parser", normalize_native_parser),
diff --git a/tools/normalize_full_reference_container_access.py b/tools/normalize_full_reference_container_access.py
new file mode 100644
index 00000000..607d413a
--- /dev/null
+++ b/tools/normalize_full_reference_container_access.py
@@ -0,0 +1,127 @@
+"""Give opaque native containers statically typed length accessors.
+
+The reference ABI deliberately unboxes values as ``object``.  Without a typed
+boundary the pinned compiler lowers ``len(target)`` to ``strlen``, even when
+the runtime value is a list, tuple, or dictionary.  Route only the public
+container ABI length checks through typed helpers so native sequence metadata
+is read instead of scanning arbitrary memory as a C string.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+PATH = Path("src/portapy/native_full_reference_entry.py")
+
+_HELPERS = '''
+def _native_sequence_size(values: list[object]) -> int:
+    return len(values)
+
+
+def _native_dict_size(values: dict[str, object]) -> int:
+    return len(values)
+'''
+
+_REPLACEMENTS = {
+    "_portapy_tuple_set_item_impl": ("target.items", "_native_sequence_size"),
+    "_portapy_tuple_get_size_impl": ("target", "_native_sequence_size"),
+    "_portapy_tuple_get_item_impl": ("target", "_native_sequence_size"),
+    "_portapy_dict_get_size_impl": ("target", "_native_dict_size"),
+    "_portapy_list_get_size_impl": ("target", "_native_sequence_size"),
+    "_portapy_list_get_item_impl": ("target", "_native_sequence_size"),
+    "_portapy_list_set_item_impl": ("values", "_native_sequence_size"),
+}
+
+
+class _Rewrite(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.function = ""
+        self.replaced = {name: 0 for name in _REPLACEMENTS}
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        previous = self.function
+        self.function = node.name
+        self.generic_visit(node)
+        self.function = previous
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        self.generic_visit(node)
+        replacement = _REPLACEMENTS.get(self.function)
+        if replacement is None:
+            return node
+        expression, helper = replacement
+        if (
+            isinstance(node.func, ast.Name)
+            and node.func.id == "len"
+            and len(node.args) == 1
+            and not node.keywords
+            and ast.unparse(node.args[0]) == expression
+        ):
+            self.replaced[self.function] += 1
+            return ast.copy_location(
+                ast.Call(
+                    func=ast.Name(id=helper, ctx=ast.Load()),
+                    args=node.args,
+                    keywords=[],
+                ),
+                node,
+            )
+        return node
+
+
+def _function_source(module: ast.Module, name: str) -> str:
+    matches = [
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == name
+    ]
+    if len(matches) != 1:
+        raise RuntimeError(f"expected one {name} function, found {len(matches)}")
+    return ast.unparse(matches[0])
+
+
+def main() -> int:
+    module = ast.parse(PATH.read_text(encoding="utf-8"), filename=str(PATH))
+    existing = [
+        name
+        for name in ("_native_sequence_size", "_native_dict_size")
+        if any(
+            isinstance(node, ast.FunctionDef) and node.name == name
+            for node in module.body
+        )
+    ]
+    if existing:
+        raise RuntimeError(f"native container helpers are already installed: {existing}")
+
+    rewriter = _Rewrite()
+    module = rewriter.visit(module)
+    missed = {
+        name: count
+        for name, count in rewriter.replaced.items()
+        if count != 1
+    }
+    if missed:
+        raise RuntimeError(
+            "native container normalization missed expected length calls: "
+            f"{missed}"
+        )
+
+    module.body.extend(ast.parse(_HELPERS).body)
+    ast.fix_missing_locations(module)
+    source = ast.unparse(module) + "\n"
+    PATH.write_text(source, encoding="utf-8")
+
+    verified = ast.parse(source, filename=str(PATH))
+    for name, (_, helper) in _REPLACEMENTS.items():
+        function_source = _function_source(verified, name)
+        if f"{helper}(" not in function_source or "len(" in function_source:
+            raise RuntimeError(f"native container repair was lost in {name}")
+
+    print("NORMALIZED NATIVE CONTAINER LENGTH ACCESS", len(_REPLACEMENTS))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())