passages: tunnels own their floor - flat-bottomed tube + solid shell (L109, v217) - pending visual review

Owner design: flat world-horizontal floor (0.50 m corner blend), 0.75 m solid shell written only
where the host field is air (interiors union first and beat every shell), 5 m cubic mouth ramps.
Removed route support restoration, deferred support, support columns, mouth-support restoration
and their capsule checks (-5,129 / +1,641 lines). Near-ready @W12: FI 1.39 -> 0.86, TN 1.29 ->
0.90, VS 0.85 -> 0.74, SW 0.70 -> 0.76 s (more shell/skirt surface). All walk audits pass;
Clang/GCC W1/W8/W12 deterministic; fast tier PASS; Linux UE builds; 6 UE arrival traces pass.
OPEN ISSUE: open-air shell (e.g. passage 0-1, 1037-1489 m route span) shows a regular stepped
banding pattern - not merged into assembler/world until fixed/approved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1

Standalone/Research/WorldAssemblerM3/Linux109/RunL109CrossingDelta.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Compare LOD0-2 owner mesh edge crossings before and after L109."""
+from __future__ import annotations
+
+import json
+import math
+import statistics
+import struct
+import subprocess
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l109/crossings"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BINARIES = {
+    "before": ROOT / "Saved/Linux/l109/bin-baseline/VoxelForgeCoreHeadless-l109-baseline",
+    "after": ROOT / "Saved/Linux/l109/bin-final/VoxelForgeCoreHeadless-l109-clang",
+}
+CAMERAS = {
+    "SW": (8.0, 16.0, -372.2626953125),
+    "FI": (25.8369140625, 3.19921875, -737.0),
+    "TN": (19.166015625, -14.2001953125, -753.3740234375),
+    "VS": (-20.0625, -5.068359375, -900.353515625),
+}
+
+
+def read_exact(stream, size):
+    data = stream.read(size)
+    if len(data) != size:
+        raise RuntimeError("truncated VFMSH export")
+    return data
+
+
+def crossing_map(path: Path) -> tuple[dict, dict]:
+    crossings = {}
+    meta = {"tiles": 0, "surface_vertices": 0, "classified": 0}
+    with path.open("rb") as stream:
+        magic = read_exact(stream, 8)
+        materials = magic == b"VFMSH002"
+        if magic not in (b"VFMSH001", b"VFMSH002"):
+            raise RuntimeError(f"invalid mesh export {path}")
+        version, voxel_um, tile_count = struct.unpack("<3I", read_exact(stream, 12))
+        if version != (2 if materials else 1):
+            raise RuntimeError("VFMSH version mismatch")
+        read_exact(stream, 40)
+        voxel_m = voxel_um / 1_000_000.0
+        for _ in range(tile_count):
+            key = struct.unpack("<4i", read_exact(stream, 16))
+            surface_count, _skirts, vertex_count, index_count, mask_count = struct.unpack(
+                "<5I", read_exact(stream, 20))
+            positions = struct.iter_unpack("<3f", read_exact(stream, vertex_count * 12))
+            values = list(positions)
+            read_exact(stream, vertex_count * 12)  # normals
+            if materials:
+                read_exact(stream, vertex_count * 10)
+            read_exact(stream, index_count * 4 + mask_count)
+            meta["tiles"] += 1
+            meta["surface_vertices"] += min(surface_count, vertex_count)
+            unit = voxel_m * (1 << key[3])
+            for position in values[:min(surface_count, vertex_count)]:
+                grid = tuple(value / unit for value in position)
+                fractions = tuple(abs(value - round(value)) for value in grid)
+                axis = max(range(3), key=fractions.__getitem__)
+                if fractions[axis] < 1.0e-4:
+                    continue
+                fixed = [index for index in range(3) if index != axis]
+                if any(fractions[index] > 0.01 for index in fixed):
+                    continue
+                edge = [0, 0, 0]
+                for index in fixed:
+                    edge[index] = int(round(grid[index]))
+                edge[axis] = math.floor(grid[axis])
+                identity = (key[3], axis, *edge)
+                crossings.setdefault(identity, tuple(float(v) for v in position))
+                meta["classified"] += 1
+        if stream.read(1):
+            raise RuntimeError("trailing data in mesh export")
+    meta["classified_pct"] = (100.0 * meta["classified"] / meta["surface_vertices"]
+                              if meta["surface_vertices"] else 0.0)
+    return crossings, meta
+
+
+def export(strate: str, variant: str) -> Path:
+    OUT.mkdir(parents=True, exist_ok=True)
+    mesh = OUT / f"{strate.lower()}-{variant}.vfmesh"
+    log = OUT / f"{strate.lower()}-{variant}.log"
+    camera = ",".join(f"{v:.12f}" for v in CAMERAS[strate]) + ",0,0"
+    command = [
+        "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+        "timeout", "1740s", str(BINARIES[variant]), str(DATA),
+        "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+        "--workers=8", "--clip-radius=3", "--max-clip-level=2", "--max-level=2",
+        "--force-generate", "--recipe=surface-world", f"--camera={camera}",
+        "--render-distance-chunks=0",
+        f"--mesh-export={mesh}",
+    ]
+    started = time.monotonic()
+    with log.open("w", encoding="utf-8") as stream:
+        result = subprocess.run(command, cwd=ROOT, stdout=stream,
+                                stderr=subprocess.STDOUT, timeout=1740, check=False)
+    output = log.read_text(encoding="utf-8", errors="replace")
+    if result.returncode or not mesh.is_file() or "status=PASS" not in output:
+        raise RuntimeError(f"mesh export failed: {strate}/{variant} exit={result.returncode} {log}")
+    return mesh
+
+
+def main() -> int:
+    summaries = []
+    for strate in CAMERAS:
+        paths = {variant: export(strate, variant) for variant in ("before", "after")}
+        maps = {variant: crossing_map(path) for variant, path in paths.items()}
+        old, old_meta = maps["before"]
+        new, new_meta = maps["after"]
+        old_keys, new_keys = set(old), set(new)
+        shared = old_keys & new_keys
+        moved_cm = [100.0 * math.dist(old[key], new[key]) for key in shared
+                    if math.dist(old[key], new[key]) > 0.0001]
+        row = {
+            "strate": strate, "scope": "camera LOD0-2 mesh window; global lattice edge IDs",
+            "added_crossings": len(new_keys - old_keys),
+            "removed_crossings": len(old_keys - new_keys),
+            "shared_crossings": len(shared), "moved_crossings": len(moved_cm),
+            "mean_moved_cm": statistics.mean(moved_cm) if moved_cm else 0.0,
+            "max_moved_cm": max(moved_cm, default=0.0),
+            "before": old_meta, "after": new_meta,
+            "classified_pair_coverage_pct": min(old_meta["classified_pct"],
+                                                  new_meta["classified_pct"]),
+            "exports": {key: str(value.relative_to(ROOT)) for key, value in paths.items()},
+        }
+        summaries.append(row)
+        print("[L109CrossingDelta] " + json.dumps(row, sort_keys=True), flush=True)
+    (OUT / "summary.json").write_text(
+        json.dumps({"measurement": "per-vertex marching-cubes edge classifier; compare shared global lattice edges; positions >0.01cm count as moved",
+                    "strata": summaries}, indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())