From 0d487b0d7b4be5a8e979ad6cf69ce6fee5428db9 Mon Sep 17 00:00:00 2001
From: agustin-littlehat <minotopo@gmail.com>
Date: Wed, 20 May 2026 20:29:32 -0300
Subject: [PATCH 1/5] feat: speed up baked stable animations

---
 bench/README.md                               |  32 +-
 bench/animated-human-bench.mjs                |  13 +-
 bench/animated-human.html                     |  38 +-
 bench/nonvoxel-drag-trace.mjs                 | 803 +++++++++++++++
 bench/nonvoxel-vanilla.html                   | 165 +++-
 package.json                                  |   1 +
 packages/core/src/animation/index.ts          |  34 +-
 .../animation/optimizeAnimatedMeshPolygons.ts | 226 ++++-
 packages/core/src/parser/parseGltf.test.ts    |  36 +-
 packages/core/src/parser/parseGltf.ts         | 350 +++++--
 .../src/parser/solidTextureSamples.test.ts    |  91 ++
 .../core/src/parser/solidTextureSamples.ts    | 126 ++-
 packages/polycss/src/api/createPolyScene.ts   | 267 ++++-
 packages/polycss/src/render/textureAtlas.ts   | 925 +++++++++++++-----
 packages/react/src/scene/PolyMesh.tsx         |   1 +
 packages/react/src/scene/textureAtlas.tsx     | 336 ++++++-
 packages/vue/src/scene/PolyMesh.ts            |   1 +
 packages/vue/src/scene/textureAtlas.ts        | 336 ++++++-
 .../components/VanillaScene/VanillaScene.tsx  |   2 +-
 19 files changed, 3367 insertions(+), 416 deletions(-)
 create mode 100644 bench/nonvoxel-drag-trace.mjs
 create mode 100644 packages/core/src/parser/solidTextureSamples.test.ts

diff --git a/bench/README.md b/bench/README.md
index dfc44e46..e27b9560 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -17,11 +17,13 @@ contributors to verify perf claims and catch render regressions.
 pnpm bench:serve            # static server on :4400 with an index page
 pnpm bench:perf             # build bundles + run all 4 renderers × 5 scenarios
 pnpm bench:animated-human   # build bundles + run the animated human run bench
+pnpm bench:nonvoxel-drag-trace  # build bundles + trace a Playwright drag orbit on teapot
 pnpm bench:lossy            # compare lossless / previous lossy / auto lossy counts
 pnpm bench:visual           # screenshot diff against bench/baselines/*.png
 pnpm bench:visual --record  # capture new baselines (after intentional renderer changes)
 pnpm bench:build            # just rebuild the bench bundles (rarely needed alone)
 node bench/nonvoxel-rotation-bench.mjs  # non-voxel vanilla rotation probe
+node bench/nonvoxel-drag-trace.mjs --label teapot-drag  # pointer-drag trace, no auto-rotate
 node bench/nonvoxel-frame-buckets.mjs --no-trace  # non-voxel rAF cadence buckets
 node bench/nonvoxel-visual-compare.mjs  # non-voxel variant visual parity
 ```
@@ -38,6 +40,7 @@ node bench/lossy-optimizer-bench.mjs --json bench/results/lossy-optimizer.json
 node bench/lossy-optimizer-bench.mjs --models ducky,shark,bicycle
 node bench/perf-visual.mjs --mesh chicken --tolerance 0.005
 node bench/nonvoxel-rotation-bench.mjs --models teapot,bicycle --variants baseline,order-tile4 --run-order round-robin
+node bench/nonvoxel-drag-trace.mjs --mesh teapot --degrees 360 --drag-ms 1500 --label teapot-drag --frame-details --no-print-json
 node bench/nonvoxel-frame-buckets.mjs --mesh glb:Elephant.glb --variant baseline --no-trace
 node bench/nonvoxel-visual-compare.mjs --models bicycle,elephant,policecar --variants scene-split-target,scene-transform-perspective
 ```
@@ -141,6 +144,19 @@ tests above what the gallery's OBJs cover.
 Use `domOrder` for pure post-render DOM-order probes; `polygonOrder` changes
 the polygon array before render planning and is only for diagnostics.
 
+`nonvoxel-drag-trace.mjs` is the focused user-input lane for the same page.
+It loads a non-voxel mesh (`teapot` by default), leaves OrbitControls
+auto-rotate off, performs real Playwright mouse drags until the requested
+camera yaw delta is reached, and writes `bench/results/<label>.trace.json`
+plus `bench/results/<label>.json`. A 360 degree run uses clutched drags inside
+the viewport because OrbitControls maps 4 pointer pixels to 1 degree of yaw.
+Pass `--variant <id>` to reuse the non-voxel variant params from the rotation
+bench, or `--trace-out <path>` / `--json <path>` for explicit outputs.
+`--frame-details` aligns page-side frame work with Chrome trace events, adding
+per-frame `rotationFrames` / `slowestFrames` breakdowns; use
+`--frame-details-limit <n>` to keep every rotation frame and `--no-print-json`
+when the full result is too large for terminal output.
+
 `animated-human.html` is the focused animated-model page. It loads
 `/gallery/glb/poly-pizza/animated-human.glb` by default, chooses the run-like
 clip when available, and drives `createPolyAnimationMixer.update(dt)` into
@@ -155,12 +171,12 @@ Playwright runner accepts `--mode baked,dynamic`, `--clip <name|index|run>`,
 `--stable-triangle-color-max-step <channel-delta>`,
 `--animation-driver js|progressive-style-cache|js-style-cache|typed-om-style-cache|css-keyframes`,
 `--compare-stable-triangle-debug`, `--require-solid-triangles`, `--trace`, and
-the same GPU lane flags as the other browser benches. The color freeze option
-keeps exact baked colors but staggers leaf color writes across frames; adaptive
-color policy spends a capped write budget on leaves with the largest accumulated
-color error first. The max-step option caps the per-write RGB channel delta so
-cadence updates drift toward the next baked color instead of jumping directly to
-it. `css-keyframes` is a bench-only prototype that samples the clip into
+the same GPU lane flags as the other browser benches. The default baked color
+policy uses 8-channel quantized colors and staggers leaf color writes over a
+12-frame cadence; adaptive color policy spends a capped write budget on leaves
+with the largest accumulated color error first. The max-step option caps the
+per-write RGB channel delta so cadence updates drift toward the next baked color
+instead of jumping directly to it. `css-keyframes` is a bench-only prototype that samples the clip into
 per-leaf CSS animations, removing per-frame JS playback from the measurement
 window. The solid-triangle guard fails the run if the page leaves the baked
 `<u>` path. Use `--stable-triangle-color-freeze-frames 0` to keep the initial
@@ -199,6 +215,10 @@ bench/
                          GPU-default Playwright runner for the animated
                          human run sequence. Reports FPS, mixer/update cost,
                          setPolygons cost, render stats, and optional trace.
+  nonvoxel-drag-trace.mjs
+                         Vanilla-only non-voxel pointer-input trace bench.
+                         Uses Playwright mouse drags through OrbitControls
+                         instead of scene auto-rotation.
   lossy-optimizer-bench.mjs
                          Polygon-count strategy bench for lossless,
                          previous pair-only lossy, forced grouped lossy,
diff --git a/bench/animated-human-bench.mjs b/bench/animated-human-bench.mjs
index ce939dee..f50edebc 100644
--- a/bench/animated-human-bench.mjs
+++ b/bench/animated-human-bench.mjs
@@ -81,12 +81,13 @@ const DISABLE_STRATEGIES = optStr("disable-strategies", optStr("disableStrategie
 const STABLE_TRIANGLE_DEBUG = optStr("stable-triangle-debug", optStr("stableTriangleDebug"));
 const ANIMATION_DRIVER = optStr("animation-driver", optStr("animationDriver", "js"));
 const ANIMATION_FRAME_CACHE = hasFlag("animation-frame-cache") || hasFlag("animationFrameCache");
+const TRIANGLE_FRAME = !hasFlag("no-triangle-frame") && !hasFlag("noTriangleFrame");
 const ANIMATION_FRAME_CACHE_FRAMES = optNum(
   "animation-frame-cache-frames",
   optNum("animationFrameCacheFrames", 60),
 );
 const KEYFRAME_SAMPLES = optNum("keyframe-samples", optNum("keyframeSamples", 24));
-const DEFAULT_STABLE_TRIANGLE_COLOR_STEPS = 0;
+const DEFAULT_STABLE_TRIANGLE_COLOR_STEPS = 8;
 const DEFAULT_STABLE_TRIANGLE_COLOR_POLICY = "cadence";
 const DEFAULT_STABLE_TRIANGLE_COLOR_FREEZE_FRAMES = 12;
 const DEFAULT_STABLE_TRIANGLE_COLOR_BUDGET = 0.16;
@@ -96,7 +97,7 @@ const HAS_STABLE_TRIANGLE_COLOR_STEPS =
   hasOpt("stable-triangle-color-steps") || hasOpt("stableTriangleColorSteps");
 const STABLE_TRIANGLE_COLOR_STEPS = optNum(
   "stable-triangle-color-steps",
-  optNum("stableTriangleColorSteps", 0),
+  optNum("stableTriangleColorSteps", DEFAULT_STABLE_TRIANGLE_COLOR_STEPS),
 );
 const HAS_STABLE_TRIANGLE_COLOR_POLICY =
   hasOpt("stable-triangle-color-policy") || hasOpt("stableTriangleColorPolicy");
@@ -519,6 +520,7 @@ function buildUrl(port, scenario) {
     stableDom: scenario.stableDom ? "1" : "0",
     animationDriver: scenario.animationDriver,
     animationFrameCache: scenario.animationFrameCache ? "1" : "0",
+    triangleFrame: TRIANGLE_FRAME ? "1" : "0",
     animationFrameCacheFrames: String(ANIMATION_FRAME_CACHE_FRAMES),
     keyframeSamples: String(KEYFRAME_SAMPLES),
     animatedMeshOptimization: scenario.animatedMeshOptimization ? "1" : "0",
@@ -610,6 +612,9 @@ async function runScenario(port, scenario) {
       animation_update: summarizeDurations(pageResult.animationSamples, "updateMs"),
       set_polygons: summarizeDurations(pageResult.animationSamples, "setPolygonsMs"),
       sample_and_mixer: summarizeDurations(pageResult.animationSamples, "nonSetPolygonsMs"),
+      triangleFrameApplied: pageResult.animationSamples.filter((sample) =>
+        sample?.triangleFrameApplied === true
+      ).length,
       animation_sample_count: pageResult.animationSamples.length,
       polyCount: pageResult.polyCount,
       renderStats: pageResult.renderStats,
@@ -650,7 +655,7 @@ for (const mode of MODES) {
   }
 }
 
-console.log(`[animated-human] mesh=${MESH} clip=${CLIP} targetSize=${TARGET_SIZE} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms animatedMeshOptimization=${ANIMATED_MESH_OPTIMIZATION_VARIANTS.join(",")} animationDriver=${ANIMATION_DRIVER_VARIANTS.join(",")} animationFrameCache=${ANIMATION_FRAME_CACHE_VARIANTS.join(",")} animationFrameCacheFrames=${ANIMATION_FRAME_CACHE_FRAMES} keyframeSamples=${KEYFRAME_SAMPLES} stableTriangleDebug=${STABLE_TRIANGLE_DEBUG_VARIANTS.map((value) => value || "normal").join(",")} colorPolicy=${STABLE_TRIANGLE_COLOR_POLICY_LABEL} colorSteps=${STABLE_TRIANGLE_COLOR_STEPS_LABEL} colorFreezeFrames=${STABLE_TRIANGLE_COLOR_FREEZE_FRAMES_LABEL} colorBudget=${STABLE_TRIANGLE_COLOR_BUDGET_LABEL} colorMaxAge=${STABLE_TRIANGLE_COLOR_MAX_AGE_LABEL} colorMaxStep=${STABLE_TRIANGLE_COLOR_MAX_STEP_LABEL} matrixDecimals=${STABLE_TRIANGLE_MATRIX_DECIMALS_LABEL}`);
+console.log(`[animated-human] mesh=${MESH} clip=${CLIP} targetSize=${TARGET_SIZE} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms animatedMeshOptimization=${ANIMATED_MESH_OPTIMIZATION_VARIANTS.join(",")} animationDriver=${ANIMATION_DRIVER_VARIANTS.join(",")} animationFrameCache=${ANIMATION_FRAME_CACHE_VARIANTS.join(",")} triangleFrame=${TRIANGLE_FRAME ? "on" : "off"} animationFrameCacheFrames=${ANIMATION_FRAME_CACHE_FRAMES} keyframeSamples=${KEYFRAME_SAMPLES} stableTriangleDebug=${STABLE_TRIANGLE_DEBUG_VARIANTS.map((value) => value || "normal").join(",")} colorPolicy=${STABLE_TRIANGLE_COLOR_POLICY_LABEL} colorSteps=${STABLE_TRIANGLE_COLOR_STEPS_LABEL} colorFreezeFrames=${STABLE_TRIANGLE_COLOR_FREEZE_FRAMES_LABEL} colorBudget=${STABLE_TRIANGLE_COLOR_BUDGET_LABEL} colorMaxAge=${STABLE_TRIANGLE_COLOR_MAX_AGE_LABEL} colorMaxStep=${STABLE_TRIANGLE_COLOR_MAX_STEP_LABEL} matrixDecimals=${STABLE_TRIANGLE_MATRIX_DECIMALS_LABEL}`);
 if (BROWSER_EXECUTABLE) console.log(`[animated-human] browser=${BROWSER_EXECUTABLE}`);
 if (SOFTWARE_BACKEND) console.log("[animated-human] software backend=on");
 if (CHROMIUM_ARGS.length > 0) console.log(`[animated-human] chromium args=${CHROMIUM_ARGS.join(" ")}`);
@@ -697,6 +702,7 @@ try {
       `p95=${result.fps_p95.toFixed(1).padStart(5)}fps ` +
       `update p50=${result.animation_update.p50_ms.toFixed(2)}ms ` +
       `setPolys p50=${result.set_polygons.p50_ms.toFixed(2)}ms ` +
+      `typed=${result.triangleFrameApplied}/${result.animation_sample_count} ` +
       `clip=${result.animation?.clip?.name ?? "?"}${tagNote}${traceNote}${profileNote}\n`,
     );
   }
@@ -717,6 +723,7 @@ try {
     animationFrameCache: ANIMATION_FRAME_CACHE_VARIANTS.length === 1
       ? ANIMATION_FRAME_CACHE_VARIANTS[0]
       : "compare",
+    triangleFrame: TRIANGLE_FRAME,
     animationFrameCacheFrames: ANIMATION_FRAME_CACHE_FRAMES,
     keyframeSamples: KEYFRAME_SAMPLES,
     stableTriangleDebug: STABLE_TRIANGLE_DEBUG || null,
diff --git a/bench/animated-human.html b/bench/animated-human.html
index 81671a64..2ba48405 100644
--- a/bench/animated-human.html
+++ b/bench/animated-human.html
@@ -88,7 +88,7 @@
         : "";
     const stableTriangleColorSteps = params.has("stableTriangleColorSteps")
       ? numberParam("stableTriangleColorSteps", 0)
-      : 0;
+      : 8;
     const stableTriangleColorPolicyRaw = params.get("stableTriangleColorPolicy");
     const stableTriangleColorPolicy =
       stableTriangleColorPolicyRaw === "adaptive" ? "adaptive" : "cadence";
@@ -118,6 +118,7 @@
     const animationFrameCache = boolParam("animationFrameCache", false);
     const animationFrameCacheFrames = Math.max(2, Math.floor(numberParam("animationFrameCacheFrames", 60)));
     const animatedMeshOptimization = boolParam("animatedMeshOptimization", false);
+    const triangleFrame = boolParam("triangleFrame", true);
     const solidTextureSamples = boolParam("solidTextureSamples", true);
     const targetSize = numberParam("targetSize", 72);
     const timeScale = numberParam("timeScale", 1);
@@ -400,6 +401,7 @@
 
       let lastSetPolygonsMs = 0;
       let lastAnimatedPolygons = initialPolygons.length;
+      let lastTriangleFrameApplied = false;
       const keyframeInfo = animationDriver === "css-keyframes"
         ? await installCssKeyframeAnimation(mesh, renderParsed.animation, clip)
         : null;
@@ -434,6 +436,7 @@
         animationDriver,
         animationFrameCache,
         animationFrameCacheFrames,
+        triangleFrame,
         stableTriangleDebug,
         stableTriangleColorPolicy,
         stableTriangleColorSteps,
@@ -583,17 +586,36 @@
         return;
       }
 
+      const triangleFrameTargetSymbol = Symbol.for("polycss.animation.triangleFrameTarget");
+      const meshTriangleFrameTarget = mesh[triangleFrameTargetSymbol];
       const animationTarget = {
         setPolygons(polygons) {
+          lastTriangleFrameApplied = false;
           const start = performance.now();
           mesh.setPolygons(polygons, animationSetPolygonsOptions());
           lastSetPolygonsMs = performance.now() - start;
           lastAnimatedPolygons = polygons.length;
         },
+        [triangleFrameTargetSymbol](frame) {
+          if (!triangleFrame || typeof meshTriangleFrameTarget !== "function") return false;
+          const start = performance.now();
+          const applied = meshTriangleFrameTarget.call(
+            mesh,
+            frame,
+            animationSetPolygonsOptions(),
+          );
+          if (applied) {
+            lastTriangleFrameApplied = true;
+            lastSetPolygonsMs = performance.now() - start;
+            lastAnimatedPolygons = frame.polygonCount;
+          }
+          return applied;
+        },
       };
       const mixer = createPolyAnimationMixer(animationTarget, renderParsed.animation);
       const action = mixer.clipAction(clip.name);
       action.play();
+      const frameCacheStart = performance.now();
       const cachedAnimationFrames = animationFrameCache
         ? Array.from({ length: animationFrameCacheFrames }, (_, index) =>
             renderParsed.animation.sample(
@@ -602,6 +624,19 @@
             )
           )
         : null;
+      if (cachedAnimationFrames) {
+        const cachedPolygons = cachedAnimationFrames.reduce((sum, frame) => sum + frame.length, 0);
+        const cachedVertices = cachedAnimationFrames.reduce(
+          (sum, frame) => sum + frame.reduce((frameSum, polygon) => frameSum + polygon.vertices.length, 0),
+          0,
+        );
+        window.__perf__.animation.animationFrameCacheInfo = {
+          buildMs: performance.now() - frameCacheStart,
+          frameCount: cachedAnimationFrames.length,
+          cachedPolygons,
+          cachedVertices,
+        };
+      }
 
       let last = performance.now();
       let elapsedClipTime = 0;
@@ -627,6 +662,7 @@
           setPolygonsMs: lastSetPolygonsMs,
           nonSetPolygonsMs: Math.max(0, updateMs - lastSetPolygonsMs),
           polygons: lastAnimatedPolygons,
+          triangleFrameApplied: lastTriangleFrameApplied,
         });
         if (window.__perf__.animationSamples.length > 1800) {
           window.__perf__.animationSamples.splice(
diff --git a/bench/nonvoxel-drag-trace.mjs b/bench/nonvoxel-drag-trace.mjs
new file mode 100644
index 00000000..82e87668
--- /dev/null
+++ b/bench/nonvoxel-drag-trace.mjs
@@ -0,0 +1,803 @@
+#!/usr/bin/env node
+/**
+ * Non-voxel drag trace bench.
+ *
+ * Loads the vanilla non-voxel bench page, drives PolyOrbitControls with real
+ * Playwright mouse input, rotates the camera by the requested number of degrees,
+ * and writes both a Chrome trace file and a compact JSON summary.
+ *
+ * Usage:
+ *   node bench/nonvoxel-drag-trace.mjs
+ *   node bench/nonvoxel-drag-trace.mjs --mesh teapot --mode baked --label teapot-drag
+ *   node bench/nonvoxel-drag-trace.mjs --degrees 360 --drag-ms 1500 --steps 120
+ *   node bench/nonvoxel-drag-trace.mjs --variant force-atlas --trace-out bench/results/teapot.trace.json
+ *   node bench/nonvoxel-drag-trace.mjs --frame-details --no-print-json
+ */
+import { createServer } from "node:http";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { chromium } from "playwright";
+import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, "..");
+const benchDir = resolve(repoRoot, "bench");
+const galleryDir = resolve(repoRoot, "website/public/gallery");
+
+const argv = process.argv.slice(2);
+const flag = (name) => argv.indexOf(`--${name}`);
+const optStr = (name, dflt = "") => {
+  const i = flag(name);
+  if (i >= 0) return argv[i + 1] ?? dflt;
+  const prefixed = argv.find((arg) => arg.startsWith(`--${name}=`));
+  return prefixed ? prefixed.slice(name.length + 3) : dflt;
+};
+const optNum = (name, dflt) => {
+  const raw = optStr(name);
+  if (raw.trim() === "") return dflt;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : dflt;
+};
+const optAll = (name) => {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === `--${name}` && argv[i + 1]) {
+      values.push(argv[i + 1]);
+      i += 1;
+    } else if (arg.startsWith(`--${name}=`)) {
+      values.push(arg.slice(name.length + 3));
+    }
+  }
+  return values;
+};
+const hasFlag = (name) => flag(name) >= 0 || argv.includes(`--${name}=true`);
+
+const PIXELS_PER_DEGREE = 4;
+const MESH = optStr("mesh", "teapot");
+const MODE = optStr("mode", "baked");
+const VARIANT = optStr("variant", "baseline");
+const DEGREES = optNum("degrees", 360);
+const WARMUP_MS = optNum("warmup", 1000);
+const DRAG_MS = optNum("drag-ms", 1500);
+const SETTLE_MS = optNum("settle", 250);
+const STEPS = Math.max(1, Math.round(optNum("steps", 120)));
+const VIEWPORT_WIDTH = Math.max(320, Math.round(optNum("viewport-width", 1280)));
+const VIEWPORT_HEIGHT = Math.max(240, Math.round(optNum("viewport-height", 800)));
+const LABEL = optStr("label");
+const JSON_PATH = optStr("json");
+const TRACE_PATH = optStr("trace-out");
+const FRAME_DETAILS = hasFlag("frame-details");
+const FRAME_DETAILS_LIMIT = Math.max(0, Math.round(optNum("frame-details-limit", 24)));
+const PRINT_JSON = !hasFlag("no-print-json");
+const TRACE = !hasFlag("no-trace");
+const HEADED = hasFlag("headed");
+const BROWSER_EXECUTABLE = optStr("browser-executable");
+const SOFTWARE_BACKEND = hasFlag("software-backend");
+const CHROMIUM_ARGS = chromiumArgsWithGpuDefault([
+  ...optAll("chromium-arg"),
+  ...optAll("chromium-args").flatMap((value) => value.split(/\s+/).filter(Boolean)),
+], { softwareBackend: SOFTWARE_BACKEND });
+
+if (MODE !== "baked" && MODE !== "dynamic") {
+  throw new Error(`--mode must be baked or dynamic; got "${MODE}"`);
+}
+if (!Number.isFinite(DEGREES) || DEGREES === 0) {
+  throw new Error("--degrees must be a non-zero number");
+}
+
+const VARIANT_PARAMS = {
+  baseline: {},
+  "css-keyframes": { rotationDriver: "css-keyframes" },
+  "order-depth": { domOrder: "initial-depth" },
+  "order-tile4": { domOrder: "tile4-screen" },
+  "order-area": { domOrder: "area-desc" },
+  "no-border-shape": { disableStrategies: "i" },
+  "no-stable-tri": { disableStrategies: "u" },
+  "force-atlas": { disableStrategies: "b,i,u" },
+  "no-will-change": { sceneTransformMode: "no-will-change" },
+  "leaf-buckets-64": { leafBucketSize: "64" },
+  "leaf-buckets-128": { leafBucketSize: "128" },
+  "leaf-buckets-256": { leafBucketSize: "256" },
+  "scene-matrix3d": { sceneTransformMode: "matrix3d" },
+  "scene-split-target": { sceneTransformMode: "split-target" },
+  "scene-host-perspective": { sceneTransformMode: "host-perspective" },
+  "scene-transform-perspective": { sceneTransformMode: "transform-perspective" },
+};
+
+if (!VARIANT_PARAMS[VARIANT]) {
+  throw new Error(`Unknown --variant "${VARIANT}". Known: ${Object.keys(VARIANT_PARAMS).join(", ")}`);
+}
+
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".obj": "text/plain; charset=utf-8",
+  ".mtl": "text/plain; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gltf": "application/json; charset=utf-8",
+  ".glb": "model/gltf-binary",
+  ".vox": "application/octet-stream",
+};
+
+const TRACE_CATEGORIES = [
+  "devtools.timeline",
+  "disabled-by-default-devtools.timeline",
+  "blink",
+  "blink.user_timing",
+  "cc",
+  "gpu",
+  "viz",
+  "renderer.scheduler",
+].join(",");
+
+const EVENT_GROUPS = {
+  style: ["UpdateLayoutTree", "RecalculateStyles"],
+  layout: ["Layout"],
+  prePaint: ["PrePaint"],
+  paint: ["Paint"],
+  raster: ["RasterTask", "ImageDecodeTask", "Decode Image"],
+  script: ["FunctionCall", "EvaluateScript", "EventDispatch", "TimerFire", "FireAnimationFrame"],
+  compositorMain: [
+    "ProxyMain::BeginMainFrame",
+    "WebFrameWidgetImpl::UpdateLifecycle",
+    "PaintArtifactCompositor::Update",
+    "Layerize",
+    "Commit",
+    "ProxyImpl::ReadyToCommit",
+  ],
+  compositorImpl: [
+    "LayerTreeImpl::UpdateDrawProperties",
+    "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
+    "draw_property_utils::ComputeDrawPropertiesOfVisibleLayers",
+    "LayerTreeHostImpl::PrepareToDraw",
+    "MainFrame.Draw",
+    "SubmitCompositorFrame",
+  ],
+};
+
+const KEY_EVENTS = [
+  "EventDispatch",
+  "FunctionCall",
+  "FireAnimationFrame",
+  "UpdateLayoutTree",
+  "Layout",
+  "PrePaint",
+  "Paint",
+  "PaintArtifactCompositor::Update",
+  "Layerize",
+  "Commit",
+  "ProxyMain::BeginMainFrame",
+  "LayerTreeImpl::UpdateDrawProperties",
+  "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
+  "draw_property_utils::ComputeDrawPropertiesOfVisibleLayers",
+  "LayerTreeHostImpl::PrepareToDraw",
+  "MainFrame.Draw",
+  "SubmitCompositorFrame",
+  "RasterTask",
+  "DirectRenderer::DrawFrame",
+  "DirectRenderer::DrawRenderPass",
+];
+
+function startServer() {
+  return new Promise((resolveStart, rejectStart) => {
+    const server = createServer(async (req, res) => {
+      try {
+        const u = new URL(req.url, "http://localhost");
+        const safe = u.pathname.replace(/\/+/g, "/");
+        if (safe.includes("..")) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        const abs = safe.startsWith("/gallery/")
+          ? resolve(galleryDir, safe.slice("/gallery/".length))
+          : resolve(benchDir, safe === "/" ? "nonvoxel-vanilla.html" : safe.slice(1));
+        const data = await readFile(abs);
+        res.writeHead(200, {
+          "Content-Type": MIME[extname(abs).toLowerCase()] || "application/octet-stream",
+          "Cache-Control": "no-store",
+        });
+        res.end(data);
+      } catch (error) {
+        res.writeHead(404);
+        res.end(String(error?.message ?? error));
+      }
+    });
+    server.on("error", rejectStart);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolveStart({ server, port: typeof addr === "object" ? addr.port : 0 });
+    });
+  });
+}
+
+function stopServer(server) {
+  return new Promise((resolveStop) => server.close(resolveStop));
+}
+
+function safeLabel(value) {
+  return value.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "run";
+}
+
+function outputPaths() {
+  const label = LABEL || `nonvoxel-drag-${safeLabel(MESH)}-${MODE}-${safeLabel(VARIANT)}`;
+  return {
+    label,
+    json: resolve(repoRoot, JSON_PATH || `bench/results/${label}.json`),
+    trace: resolve(repoRoot, TRACE_PATH || `bench/results/${label}.trace.json`),
+  };
+}
+
+function urlFor(port) {
+  const params = new URLSearchParams({
+    mesh: MESH,
+    mode: MODE,
+    motion: "drag",
+    ...(FRAME_DETAILS ? { frameWork: "1" } : {}),
+    ...VARIANT_PARAMS[VARIANT],
+  });
+  return `http://127.0.0.1:${port}/nonvoxel-vanilla.html?${params.toString()}`;
+}
+
+function quantile(sorted, q) {
+  if (sorted.length === 0) return 0;
+  const i = (sorted.length - 1) * q;
+  const lo = Math.floor(i);
+  const hi = Math.ceil(i);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
+}
+
+function summarizeFrameTimes(samples) {
+  const rawDts = samples.map((sample) => sample.dt).filter((dt) => Number.isFinite(dt) && dt > 0);
+  const dts = rawDts.filter((dt) => dt < 2000).sort((a, b) => a - b);
+  const p50 = quantile(dts, 0.5);
+  const p95 = quantile(dts, 0.95);
+  const p99 = quantile(dts, 0.99);
+  const duration = samples.length >= 2
+    ? samples[samples.length - 1].t - samples[0].t
+    : 0;
+  return {
+    fps_p50: p50 > 0 ? +(1000 / p50).toFixed(2) : 0,
+    fps_p95: p95 > 0 ? +(1000 / p95).toFixed(2) : 0,
+    frame_time_p50_ms: +p50.toFixed(3),
+    frame_time_p95_ms: +p95.toFixed(3),
+    frame_time_p99_ms: +p99.toFixed(3),
+    sample_count: dts.length,
+    sample_count_raw: rawDts.length,
+    sample_count_filtered: rawDts.length - dts.length,
+    sample_duration_ms: +duration.toFixed(3),
+  };
+}
+
+function findTraceMark(events, name) {
+  return events.find((event) => event?.name === name && Number.isFinite(event?.args?.data?.startTime)) ??
+    events.find((event) => event?.name === "TimeStamp" && event?.args?.data?.message === name);
+}
+
+function makeFrameWindows(samples, startPerfNow, endPerfNow) {
+  return samples
+    .filter((sample) => Number.isFinite(sample?.dt) && sample.dt > 0 && sample.dt < 2000)
+    .filter((sample) => sample.t - sample.dt >= startPerfNow && sample.t <= endPerfNow)
+    .map((sample, index) => ({
+      index,
+      start: sample.t - sample.dt,
+      end: sample.t,
+      dt: sample.dt,
+    }));
+}
+
+function frameIndexAt(frames, perfNow) {
+  let lo = 0;
+  let hi = frames.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const frame = frames[mid];
+    if (perfNow < frame.start) hi = mid - 1;
+    else if (perfNow > frame.end) lo = mid + 1;
+    else return mid;
+  }
+  return -1;
+}
+
+function addDuration(map, name, durationMs) {
+  const entry = map.get(name) ?? { count: 0, duration_ms: 0 };
+  entry.count += 1;
+  entry.duration_ms += durationMs;
+  map.set(name, entry);
+}
+
+function addAggregate(map, name, count, durationMs) {
+  const entry = map.get(name) ?? { count: 0, duration_ms: 0 };
+  entry.count += count;
+  entry.duration_ms += durationMs;
+  map.set(name, entry);
+}
+
+function frameWorkForFrame(frameWorkSamples, frame, startIndex) {
+  if (!Array.isArray(frameWorkSamples) || frameWorkSamples.length === 0) {
+    return { sample: null, nextIndex: startIndex };
+  }
+
+  let index = Math.max(0, startIndex);
+  while (index + 1 < frameWorkSamples.length && frameWorkSamples[index + 1].t <= frame.end + 1) {
+    index += 1;
+  }
+  const sample = frameWorkSamples[index];
+  if (sample && sample.t >= frame.start - 1 && sample.t <= frame.end + 1) {
+    return { sample, nextIndex: index };
+  }
+  return { sample: null, nextIndex: index };
+}
+
+function serializePageOps(ops) {
+  const out = {};
+  if (!ops || typeof ops !== "object") return out;
+  for (const [name, entry] of Object.entries(ops)) {
+    out[name] = {
+      count: entry.count ?? 0,
+      duration_ms: +((entry.duration_ms ?? 0)).toFixed(4),
+    };
+  }
+  return out;
+}
+
+function summarizeFrameDetails(events, samples, frameWorkSamples, startPerfNow, endPerfNow) {
+  if (!FRAME_DETAILS || FRAME_DETAILS_LIMIT === 0) return null;
+  const startMark = findTraceMark(events, "polycss-drag-trace-start");
+  const endMark = findTraceMark(events, "polycss-drag-trace-end");
+  if (!startMark?.args?.data?.startTime || !endMark?.args?.data?.startTime) {
+    return {
+      error: "Trace markers were not captured; frame details cannot be aligned.",
+    };
+  }
+
+  const tracePerfOffsetMs = (startMark.ts / 1000) - startMark.args.data.startTime;
+  const alignedStartPerfNow = startMark.args.data.startTime || startPerfNow;
+  const alignedEndPerfNow = endMark.args.data.startTime || endPerfNow;
+  const frames = makeFrameWindows(samples, alignedStartPerfNow, alignedEndPerfNow);
+  const groupByEvent = new Map();
+  for (const [group, names] of Object.entries(EVENT_GROUPS)) {
+    for (const name of names) groupByEvent.set(name, group);
+  }
+
+  const frameTotals = frames.map((frame) => ({
+    ...frame,
+    groups: new Map(),
+    events: new Map(),
+    completeEventMs: 0,
+    pageOps: {},
+  }));
+
+  let frameWorkIndex = 0;
+  for (const frame of frameTotals) {
+    const result = frameWorkForFrame(frameWorkSamples, frame, frameWorkIndex);
+    frameWorkIndex = result.nextIndex;
+    frame.pageOps = serializePageOps(result.sample?.ops);
+  }
+
+  for (const event of events) {
+    if (event?.ph !== "X" || typeof event.dur !== "number" || !Number.isFinite(event.ts)) continue;
+    const durationMs = event.dur / 1000;
+    const midpointPerfNow = ((event.ts + event.dur / 2) / 1000) - tracePerfOffsetMs;
+    const index = frameIndexAt(frameTotals, midpointPerfNow);
+    if (index < 0) continue;
+    const frame = frameTotals[index];
+    frame.completeEventMs += durationMs;
+    addDuration(frame.events, event.name, durationMs);
+    const group = groupByEvent.get(event.name);
+    if (group) addDuration(frame.groups, group, durationMs);
+  }
+
+  const serializeMap = (map, keys) => {
+    const out = {};
+    for (const key of keys) out[key] = +((map.get(key)?.duration_ms ?? 0)).toFixed(4);
+    return out;
+  };
+  const serializeGroups = (map) => serializeMap(map, Object.keys(EVENT_GROUPS));
+  const serializeKeyEvents = (map) => serializeMap(map, KEY_EVENTS);
+  const topEvents = (map) => [...map.entries()]
+    .map(([event, total]) => ({
+      event,
+      count: total.count,
+      duration_ms: +total.duration_ms.toFixed(4),
+    }))
+    .sort((a, b) => b.duration_ms - a.duration_ms)
+    .slice(0, 12);
+  const topPageOps = (map) => [...map.entries()]
+    .map(([operation, total]) => ({
+      operation,
+      count: total.count,
+      duration_ms: +total.duration_ms.toFixed(4),
+    }))
+    .sort((a, b) => b.duration_ms - a.duration_ms)
+    .slice(0, 12);
+
+  const serializeFrame = (frame) => ({
+    index: frame.index,
+    start_ms: +frame.start.toFixed(3),
+    end_ms: +frame.end.toFixed(3),
+    dt_ms: +frame.dt.toFixed(3),
+    complete_event_ms: +frame.completeEventMs.toFixed(3),
+    page_ops: frame.pageOps,
+    groups_ms: serializeGroups(frame.groups),
+    key_events_ms: serializeKeyEvents(frame.events),
+    topEvents: topEvents(frame.events),
+  });
+
+  const framesOut = frameTotals
+    .slice()
+    .sort((a, b) => b.dt - a.dt)
+    .slice(0, FRAME_DETAILS_LIMIT)
+    .map(serializeFrame)
+    .sort((a, b) => a.index - b.index);
+  const rotationFrames = frameTotals
+    .filter((frame) =>
+      frame.pageOps["input.pointermove"] ||
+      frame.pageOps["controls.change"] ||
+      frame.pageOps["camera.update"] ||
+      frame.pageOps["scene.applyCamera"])
+    .slice(0, FRAME_DETAILS_LIMIT)
+    .map(serializeFrame);
+
+  const totals = new Map();
+  const pageTotals = new Map();
+  for (const frame of frameTotals) {
+    for (const [event, total] of frame.events) addAggregate(totals, event, total.count, total.duration_ms);
+    for (const [operation, total] of Object.entries(frame.pageOps)) {
+      addAggregate(pageTotals, operation, total.count ?? 0, total.duration_ms ?? 0);
+    }
+  }
+
+  return {
+    tracePerfOffsetMs: +tracePerfOffsetMs.toFixed(3),
+    frameCount: frameTotals.length,
+    includedFrames: framesOut.length,
+    slowestFrames: framesOut,
+    rotationFrames,
+    topPageOps: topPageOps(pageTotals),
+    topEvents: topEvents(totals),
+  };
+}
+
+function summarizeTraceEvents(events) {
+  const byName = new Map();
+  let completeEventCount = 0;
+  let totalDurationUs = 0;
+  for (const event of events) {
+    if (event?.ph !== "X" || typeof event.dur !== "number") continue;
+    completeEventCount += 1;
+    totalDurationUs += event.dur;
+    const prev = byName.get(event.name) ?? { count: 0, durationUs: 0 };
+    prev.count += 1;
+    prev.durationUs += event.dur;
+    byName.set(event.name, prev);
+  }
+
+  const group = (names) => {
+    let count = 0;
+    let durationUs = 0;
+    for (const name of names) {
+      const entry = byName.get(name);
+      if (!entry) continue;
+      count += entry.count;
+      durationUs += entry.durationUs;
+    }
+    return { count, duration_ms: +(durationUs / 1000).toFixed(3) };
+  };
+
+  const groups = Object.fromEntries(
+    Object.entries(EVENT_GROUPS).map(([name, names]) => [name, group(names)]),
+  );
+
+  const topEvents = [...byName.entries()]
+    .sort((a, b) => b[1].durationUs - a[1].durationUs)
+    .slice(0, 20)
+    .map(([name, entry]) => ({
+      name,
+      count: entry.count,
+      duration_ms: +(entry.durationUs / 1000).toFixed(3),
+    }));
+
+  return {
+    eventCount: events.length,
+    completeEventCount,
+    totalCompleteDurationMs: +(totalDurationUs / 1000).toFixed(3),
+    groups,
+    topEvents,
+  };
+}
+
+function metricMap(metrics) {
+  const out = new Map();
+  for (const metric of metrics?.metrics ?? []) out.set(metric.name, metric.value);
+  return out;
+}
+
+function diffPerformanceMetrics(before, after) {
+  const a = metricMap(before);
+  const b = metricMap(after);
+  const keys = [
+    "Timestamp",
+    "Documents",
+    "Frames",
+    "JSEventListeners",
+    "Nodes",
+    "LayoutCount",
+    "RecalcStyleCount",
+    "LayoutDuration",
+    "RecalcStyleDuration",
+    "ScriptDuration",
+    "TaskDuration",
+    "JSHeapUsedSize",
+    "JSHeapTotalSize",
+  ];
+  const out = {};
+  for (const key of keys) {
+    const beforeValue = a.get(key);
+    const afterValue = b.get(key);
+    if (beforeValue === undefined || afterValue === undefined) continue;
+    const value = key === "Timestamp" || key === "Documents" || key === "Frames" ||
+      key === "JSEventListeners" || key === "Nodes" ||
+      key === "JSHeapUsedSize" || key === "JSHeapTotalSize"
+      ? afterValue
+      : afterValue - beforeValue;
+    out[key] = Number(value.toFixed(key.endsWith("Duration") ? 6 : 3));
+  }
+  return out;
+}
+
+function buildGesturePlan(hostBox) {
+  const margin = Math.max(24, Math.min(96, hostBox.width * 0.15));
+  const left = hostBox.x + margin;
+  const right = hostBox.x + hostBox.width - margin;
+  const y = hostBox.y + hostBox.height / 2;
+  const usable = Math.max(1, right - left);
+  const totalDx = -DEGREES * PIXELS_PER_DEGREE;
+  const direction = Math.sign(totalDx);
+  let remaining = Math.abs(totalDx);
+  const gestures = [];
+
+  while (remaining > 0) {
+    const distance = Math.min(remaining, usable);
+    gestures.push(direction < 0
+      ? { startX: right, endX: right - distance, y, pixels: distance }
+      : { startX: left, endX: left + distance, y, pixels: distance });
+    remaining -= distance;
+  }
+
+  let remainingSteps = STEPS;
+  const totalPixels = gestures.reduce((sum, gesture) => sum + gesture.pixels, 0);
+  gestures.forEach((gesture, index) => {
+    if (index === gestures.length - 1) {
+      gesture.steps = Math.max(1, remainingSteps);
+    } else {
+      gesture.steps = Math.max(1, Math.round(STEPS * (gesture.pixels / totalPixels)));
+      remainingSteps = Math.max(1, remainingSteps - gesture.steps);
+    }
+  });
+
+  return {
+    pixelsPerDegree: PIXELS_PER_DEGREE,
+    requestedDegrees: DEGREES,
+    expectedRotYDelta: -totalDx / PIXELS_PER_DEGREE,
+    totalDx,
+    totalPixels,
+    durationMs: DRAG_MS,
+    stepCount: gestures.reduce((sum, gesture) => sum + gesture.steps, 0),
+    gestures,
+  };
+}
+
+async function startTrace(cdp) {
+  const events = [];
+  cdp.on("Tracing.dataCollected", (payload) => {
+    if (Array.isArray(payload.value)) events.push(...payload.value);
+  });
+  await cdp.send("Performance.enable");
+  await cdp.send("Tracing.start", {
+    transferMode: "ReportEvents",
+    categories: TRACE_CATEGORIES,
+  });
+  return events;
+}
+
+async function stopTrace(cdp, events) {
+  const done = new Promise((resolveDone) => {
+    cdp.once("Tracing.tracingComplete", resolveDone);
+  });
+  await cdp.send("Tracing.end");
+  await done;
+  return events;
+}
+
+async function performDrag(page, plan) {
+  const delayMs = plan.durationMs / Math.max(1, plan.stepCount);
+  const first = plan.gestures[0];
+  await page.mouse.move(first.startX, first.y);
+
+  for (let gestureIndex = 0; gestureIndex < plan.gestures.length; gestureIndex += 1) {
+    const gesture = plan.gestures[gestureIndex];
+    if (gestureIndex > 0) await page.mouse.move(gesture.startX, gesture.y);
+    await page.mouse.down();
+    for (let step = 1; step <= gesture.steps; step += 1) {
+      const t = step / gesture.steps;
+      const x = gesture.startX + (gesture.endX - gesture.startX) * t;
+      await page.mouse.move(x, gesture.y);
+      if (delayMs > 0) await page.waitForTimeout(delayMs);
+    }
+    await page.mouse.up();
+    if (gestureIndex + 1 < plan.gestures.length) await page.waitForTimeout(40);
+  }
+}
+
+async function run() {
+  const paths = outputPaths();
+  const { server, port } = await startServer();
+  console.log(`[drag-trace] server :${port}`);
+  console.log(`[drag-trace] mesh=${MESH} mode=${MODE} variant=${VARIANT} degrees=${DEGREES} warmup=${WARMUP_MS}ms drag=${DRAG_MS}ms settle=${SETTLE_MS}ms`);
+  if (BROWSER_EXECUTABLE) console.log(`[drag-trace] browser=${BROWSER_EXECUTABLE}`);
+  if (SOFTWARE_BACKEND) console.log("[drag-trace] software backend=on");
+  if (CHROMIUM_ARGS.length > 0) console.log(`[drag-trace] chromium args=${CHROMIUM_ARGS.join(" ")}`);
+
+  const launchOptions = { headless: !HEADED, args: CHROMIUM_ARGS };
+  if (BROWSER_EXECUTABLE) launchOptions.executablePath = BROWSER_EXECUTABLE;
+  let browser = null;
+
+  try {
+    browser = await chromium.launch(launchOptions);
+    const ctx = await browser.newContext({ viewport: { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT } });
+    const page = await ctx.newPage();
+    page.on("console", (message) => {
+      if (message.type() === "error" || message.type() === "warning") {
+        console.log(`[drag-trace:page:${message.type()}] ${message.text()}`);
+      }
+    });
+    page.on("pageerror", (error) => {
+      console.log(`[drag-trace:page:error] ${error?.stack || error?.message || error}`);
+    });
+    const targetUrl = urlFor(port);
+    await page.goto(targetUrl, { waitUntil: "load" });
+    await page.waitForFunction(() =>
+      window.__perf__?.ready === true && window.__nonvoxelBench?.ready === true,
+    null, { timeout: 30000 });
+    await page.waitForTimeout(WARMUP_MS);
+
+    const hostBox = await page.locator("#host").boundingBox();
+    if (!hostBox) throw new Error("Could not locate #host for drag input");
+    const dragPlan = buildGesturePlan(hostBox);
+    const cdp = await ctx.newCDPSession(page);
+    const traceEvents = TRACE ? await startTrace(cdp) : [];
+    const metricsBefore = await cdp.send("Performance.getMetrics");
+
+    const startInfo = await page.evaluate((traceEnabled) => {
+      window.__nonvoxelBench.resetInteractionStats();
+      if (traceEnabled) {
+        performance.mark("polycss-drag-trace-start");
+        console.timeStamp("polycss-drag-trace-start");
+      }
+      return {
+        sampleIndex: window.__perf__.samples.length,
+        perfNow: performance.now(),
+        camera: window.__nonvoxelBench.cameraState(),
+      };
+    }, TRACE);
+
+    await performDrag(page, dragPlan);
+    await page.waitForTimeout(SETTLE_MS);
+
+    const endInfo = await page.evaluate(({ from, traceEnabled }) => {
+      if (traceEnabled) {
+        performance.mark("polycss-drag-trace-end");
+        console.timeStamp("polycss-drag-trace-end");
+      }
+      return {
+        perfNow: performance.now(),
+        camera: window.__nonvoxelBench.cameraState(),
+        interaction: window.__nonvoxelBench.interactionStats(),
+        frameWorkSamples: window.__nonvoxelBench.frameWorkSamples(),
+        samples: window.__perf__.samples.slice(from),
+        polyCount: window.__perf__.polyCount,
+        renderStats: window.__perf__.renderStats ?? null,
+      };
+    }, { from: startInfo.sampleIndex, traceEnabled: TRACE });
+    const metricsAfter = await cdp.send("Performance.getMetrics");
+    const events = TRACE ? await stopTrace(cdp, traceEvents) : [];
+    await ctx.close();
+
+    const traceSummary = summarizeTraceEvents(events);
+    const frameDetails = summarizeFrameDetails(
+      events,
+      endInfo.samples,
+      endInfo.frameWorkSamples,
+      startInfo.perfNow,
+      endInfo.perfNow,
+    );
+    const result = {
+      kind: "nonvoxel-drag-trace",
+      mesh: MESH,
+      mode: MODE,
+      variant: VARIANT,
+      url: targetUrl,
+      viewport: { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT },
+      warmup_ms: WARMUP_MS,
+      settle_ms: SETTLE_MS,
+      browserExecutable: BROWSER_EXECUTABLE || null,
+      chromiumArgs: CHROMIUM_ARGS,
+      softwareBackend: SOFTWARE_BACKEND,
+      drag: {
+        ...dragPlan,
+        gestures: dragPlan.gestures.map((gesture) => ({
+          startX: +gesture.startX.toFixed(3),
+          endX: +gesture.endX.toFixed(3),
+          y: +gesture.y.toFixed(3),
+          pixels: +gesture.pixels.toFixed(3),
+          steps: gesture.steps,
+        })),
+      },
+      camera: {
+        start: startInfo.camera,
+        end: endInfo.camera,
+        cumulativeRotY: +endInfo.interaction.cumulativeRotY.toFixed(3),
+        requestedRotYDelta: +dragPlan.expectedRotYDelta.toFixed(3),
+        rotYError: +(endInfo.interaction.cumulativeRotY - dragPlan.expectedRotYDelta).toFixed(3),
+        interaction: endInfo.interaction,
+      },
+      frames: summarizeFrameTimes(endInfo.samples),
+      polyCount: endInfo.polyCount,
+      renderStats: endInfo.renderStats,
+      trace: traceSummary,
+      frameDetails,
+      performanceMetrics: diffPerformanceMetrics(metricsBefore, metricsAfter),
+      outputFiles: {
+        json: paths.json,
+        trace: paths.trace,
+      },
+    };
+
+    if (TRACE) {
+      const tracePayload = {
+        traceEvents: events,
+        displayTimeUnit: "ms",
+        metadata: {
+          source: "bench/nonvoxel-drag-trace.mjs",
+          mesh: MESH,
+          mode: MODE,
+          variant: VARIANT,
+          requestedDegrees: DEGREES,
+          dragMs: DRAG_MS,
+          steps: STEPS,
+        },
+      };
+      mkdirSync(dirname(paths.trace), { recursive: true });
+      writeFileSync(paths.trace, JSON.stringify(tracePayload));
+      console.log(`[drag-trace] wrote ${paths.trace}`);
+    }
+    mkdirSync(dirname(paths.json), { recursive: true });
+    writeFileSync(paths.json, `${JSON.stringify(result, null, 2)}\n`);
+
+    console.log(`[drag-trace] wrote ${paths.json}`);
+    console.log(
+      `[drag-trace] p50=${result.frames.fps_p50.toFixed(1)}fps p95=${result.frames.fps_p95.toFixed(1)}fps ` +
+      `p99=${result.frames.frame_time_p99_ms.toFixed(1)}ms rotY=${result.camera.cumulativeRotY.toFixed(1)}deg ` +
+      `err=${result.camera.rotYError.toFixed(2)}deg`,
+    );
+    if (PRINT_JSON) console.log(JSON.stringify(result, null, 2));
+  } finally {
+    if (browser) await browser.close();
+    await stopServer(server);
+  }
+}
+
+run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
diff --git a/bench/nonvoxel-vanilla.html b/bench/nonvoxel-vanilla.html
index da25670e..bd886fae 100644
--- a/bench/nonvoxel-vanilla.html
+++ b/bench/nonvoxel-vanilla.html
@@ -9,7 +9,7 @@
   <div id="host"></div>
 
   <script type="module">
-    import { createPolyScene, createPolyOrbitControls, loadMesh } from "./polycss.js";
+    import { createPolyCamera, createPolyScene, createPolyOrbitControls, loadMesh } from "./polycss.js";
     import { getSynthMesh } from "./synth-mesh.mjs";
     import {
       parseUrlParams, dirFromAzEl, createPerfRecorder,
@@ -26,6 +26,7 @@
     const polygonOrder = benchParams.get("polygonOrder") || "source";
     const domOrder = benchParams.get("domOrder") || "source";
     const leafBucketSize = Number(benchParams.get("leafBucketSize") || 0);
+    const recordFrameWork = benchParams.get("frameWork") === "1";
     const disabledStrategies = (benchParams.get("disableStrategies") || "")
       .split(",")
       .map((value) => value.trim())
@@ -33,15 +34,76 @@
     let azimuth = az;
 
     const host = document.getElementById("host");
+    const camera = createPolyCamera({ rotX: preset.rotX, rotY: preset.rotY, zoom: preset.zoom });
     const scene = createPolyScene(host, {
-      rotX: preset.rotX, rotY: preset.rotY, zoom: preset.zoom,
+      camera,
       directionalLight: { direction: dirFromAzEl(azimuth, el), color: "#ffffff", intensity: 1 },
       ambientLight: { color: "#ffffff", intensity: 0.4 },
       textureLighting: mode,
       autoCenter: true,
       ...(disabledStrategies.length > 0 ? { strategies: { disable: disabledStrategies } } : {}),
     });
-    createPolyOrbitControls(scene, { drag: true, wheel: true });
+    const frameWork = createFrameWorkRecorder(recordFrameWork);
+    if (recordFrameWork) instrumentCameraAndScene();
+    const controls = createPolyOrbitControls(scene, { drag: true, wheel: true });
+    const interactionStats = {
+      starts: 0,
+      changes: 0,
+      ends: 0,
+      cumulativeRotY: 0,
+      lastRotY: scene.camera.state.rotY ?? preset.rotY,
+    };
+
+    function cloneCameraState() {
+      const state = scene.camera.state;
+      const target = state.target ?? [0, 0, 0];
+      return {
+        rotX: state.rotX ?? 0,
+        rotY: state.rotY ?? 0,
+        zoom: state.zoom ?? 0,
+        distance: state.distance ?? 0,
+        target: [target[0], target[1], target[2]],
+      };
+    }
+
+    function unwrapAngleDelta(next, previous) {
+      let delta = next - previous;
+      if (delta > 180) delta -= 360;
+      if (delta < -180) delta += 360;
+      return delta;
+    }
+
+    function resetInteractionStats() {
+      interactionStats.starts = 0;
+      interactionStats.changes = 0;
+      interactionStats.ends = 0;
+      interactionStats.cumulativeRotY = 0;
+      interactionStats.lastRotY = scene.camera.state.rotY ?? preset.rotY;
+      frameWork.reset();
+    }
+
+    controls.addEventListener("start", () => {
+      frameWork.record("controls.start");
+      interactionStats.starts += 1;
+    });
+    controls.addEventListener("change", ({ camera }) => {
+      frameWork.record("controls.change");
+      interactionStats.cumulativeRotY += unwrapAngleDelta(camera.rotY, interactionStats.lastRotY);
+      interactionStats.lastRotY = camera.rotY;
+      interactionStats.changes += 1;
+    });
+    controls.addEventListener("end", () => {
+      frameWork.record("controls.end");
+      interactionStats.ends += 1;
+    });
+
+    window.__nonvoxelBench = {
+      ready: false,
+      cameraState: cloneCameraState,
+      interactionStats: () => ({ ...interactionStats }),
+      frameWorkSamples: () => frameWork.samples(),
+      resetInteractionStats,
+    };
 
     const sceneEl = host.querySelector(".polycss-scene");
     let splitShell = null;
@@ -55,6 +117,73 @@
       return sceneEl?.style.perspective || getComputedStyle(sceneEl).perspective || "8000px";
     }
 
+    function createFrameWorkRecorder(enabled) {
+      let current = {};
+      const frameSamples = [];
+
+      function record(name, durationMs = 0) {
+        if (!enabled) return;
+        const entry = current[name] ?? { count: 0, duration_ms: 0 };
+        entry.count += 1;
+        entry.duration_ms += Number.isFinite(durationMs) ? durationMs : 0;
+        current[name] = entry;
+      }
+
+      function snapshot(now) {
+        if (!enabled) return;
+        frameSamples.push({
+          t: now,
+          ops: Object.fromEntries(Object.entries(current).map(([name, entry]) => [
+            name,
+            {
+              count: entry.count,
+              duration_ms: +entry.duration_ms.toFixed(4),
+            },
+          ])),
+        });
+        current = {};
+        if (frameSamples.length > 1800) {
+          frameSamples.splice(0, frameSamples.length - 1800);
+        }
+      }
+
+      return {
+        record,
+        snapshot,
+        reset() {
+          if (!enabled) return;
+          current = {};
+          frameSamples.length = 0;
+        },
+        samples() {
+          return frameSamples.slice();
+        },
+      };
+    }
+
+    function timedFrameWork(name, fn) {
+      const start = performance.now();
+      try {
+        return fn();
+      } finally {
+        frameWork.record(name, performance.now() - start);
+      }
+    }
+
+    function instrumentCameraAndScene() {
+      const cameraUpdate = camera.update.bind(camera);
+      camera.update = (next) => timedFrameWork("camera.update", () => cameraUpdate(next));
+
+      const sceneApplyCamera = scene.applyCamera.bind(scene);
+      scene.applyCamera = () => timedFrameWork("scene.applyCamera", () => sceneApplyCamera());
+
+      host.addEventListener("pointerdown", () => frameWork.record("input.pointerdown"), { capture: true });
+      host.addEventListener("pointermove", () => frameWork.record("input.pointermove"), { capture: true });
+      host.addEventListener("pointerup", () => frameWork.record("input.pointerup"), { capture: true });
+      host.addEventListener("pointercancel", () => frameWork.record("input.pointercancel"), { capture: true });
+      host.addEventListener("wheel", () => frameWork.record("input.wheel"), { capture: true, passive: true });
+    }
+
     function ensureSplitShell() {
       if (splitShell || !sceneEl) return splitShell;
       splitShell = document.createElement("div");
@@ -319,6 +448,31 @@
       return true;
     }
 
+    function atlasLeavesReady() {
+      const leaves = Array.from(host.querySelectorAll(".polycss-mesh s"));
+      return leaves.every((leaf) => {
+        const inlineBg = leaf.style.backgroundImage;
+        const bg = inlineBg || getComputedStyle(leaf).backgroundImage;
+        return leaf.style.opacity !== "0" && bg && bg !== "none";
+      });
+    }
+
+    function markReadyWhenRenderPainted() {
+      window.__perf__.ready = false;
+      window.__nonvoxelBench.ready = false;
+
+      function check() {
+        if (atlasLeavesReady()) {
+          window.__perf__.ready = true;
+          window.__nonvoxelBench.ready = true;
+          return;
+        }
+        requestAnimationFrame(check);
+      }
+
+      check();
+    }
+
     const meshPromise = isSynth
       ? Promise.resolve(getSynthMesh(meshId))
       : loadMesh(preset.url, {
@@ -342,9 +496,11 @@
         polyCount: parseResult.polygons.length,
         polygons: parseResult.polygons,
       });
+      markReadyWhenRenderPainted();
 
       let frameCount = 0;
       function tick(now) {
+        frameWork.snapshot(now);
         recorder.onFrame(now);
         frameCount += 1;
         if (motion === "light") {
@@ -355,7 +511,8 @@
         } else if (motion === "rot") {
           const newRotY = ((preset.rotY + frameCount * 0.5) + 360) % 360;
           if (!cssDrivenRotation) {
-            scene.setOptions({ rotY: newRotY });
+            scene.camera.update({ rotY: newRotY });
+            scene.applyCamera();
             applySceneTransformMode();
           }
         }
diff --git a/package.json b/package.json
index 3474e737..020a129e 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,7 @@
     "bench:serve": "node bench/perf-serve.mjs --port 4400",
     "bench:perf": "node bench/build.mjs && node bench/perf-bench.mjs",
     "bench:animated-human": "node bench/build.mjs && node bench/animated-human-bench.mjs",
+    "bench:nonvoxel-drag-trace": "node bench/build.mjs && node bench/nonvoxel-drag-trace.mjs",
     "bench:lossy": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-optimizer-bench.mjs",
     "bench:visual": "node bench/build.mjs && node bench/perf-visual.mjs"
   },
diff --git a/packages/core/src/animation/index.ts b/packages/core/src/animation/index.ts
index 18043fc0..5321f602 100644
--- a/packages/core/src/animation/index.ts
+++ b/packages/core/src/animation/index.ts
@@ -10,6 +10,28 @@
 import type { ParseAnimationClip, ParseAnimationController } from "../parser/types";
 import type { Polygon } from "../types";
 
+const POLY_ANIMATION_TRIANGLE_FRAME_SOURCE = Symbol.for("polycss.animation.triangleFrameSource");
+const POLY_ANIMATION_TRIANGLE_FRAME_TARGET = Symbol.for("polycss.animation.triangleFrameTarget");
+
+interface PolyAnimationTriangleFrame {
+  polygonCount: number;
+  vertices: Float64Array;
+  colors?: readonly (string | undefined)[];
+  textureFlags?: readonly boolean[];
+  solidTriangles?: boolean;
+}
+
+interface PolyAnimationTriangleFrameSource {
+  [POLY_ANIMATION_TRIANGLE_FRAME_SOURCE]?: (
+    clip: number | string,
+    timeSeconds: number,
+  ) => PolyAnimationTriangleFrame | null | undefined;
+}
+
+interface PolyAnimationTriangleFrameTarget {
+  [POLY_ANIMATION_TRIANGLE_FRAME_TARGET]?: (frame: PolyAnimationTriangleFrame) => boolean;
+}
+
 // ── Loop mode constants (match three.js) ────────────────────────────────────
 
 export const LoopOnce = 2200 as const;
@@ -339,6 +361,8 @@ export function createPolyAnimationMixer(
   controller: ParseAnimationController,
 ): PolyAnimationMixer {
   const actionCache = new Map<number, PolyAnimationAction>();
+  const triangleFrameSource = controller as ParseAnimationController & PolyAnimationTriangleFrameSource;
+  const triangleFrameTarget = root as PolyAnimationTarget & PolyAnimationTriangleFrameTarget;
 
   function clipAction(key: number | string): PolyAnimationAction {
     const clip = resolveClip(controller.clips, key);
@@ -378,7 +402,15 @@ export function createPolyAnimationMixer(
     if (active.length === 1) {
       // Fast path: single active action — no blending needed.
       const { internal, clip } = active[0];
-      const polygons = controller.sample(clip.name, internal.sampleTime());
+      const sampleTime = internal.sampleTime();
+      const triangleFrame = triangleFrameSource[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE]?.(clip.name, sampleTime);
+      if (
+        triangleFrame &&
+        triangleFrameTarget[POLY_ANIMATION_TRIANGLE_FRAME_TARGET]?.(triangleFrame)
+      ) {
+        return;
+      }
+      const polygons = controller.sample(clip.name, sampleTime);
       root.setPolygons(polygons);
       return;
     }
diff --git a/packages/core/src/animation/optimizeAnimatedMeshPolygons.ts b/packages/core/src/animation/optimizeAnimatedMeshPolygons.ts
index 7c08694c..a6dfb58c 100644
--- a/packages/core/src/animation/optimizeAnimatedMeshPolygons.ts
+++ b/packages/core/src/animation/optimizeAnimatedMeshPolygons.ts
@@ -1,38 +1,48 @@
 import type { MeshResolution, Polygon, Vec3 } from "../types";
-import type { ParseResult } from "../parser/types";
+import type { ParseAnimationController, ParseResult } from "../parser/types";
 import { cullInteriorPolygons } from "../cull/cullInteriorPolygons";
+import { filterGltfAnimationController } from "../parser/parseGltf";
+import { getSolidTextureBakedAnimationInfo } from "../parser/solidTextureSamples";
+
+const POLY_ANIMATION_TRIANGLE_FRAME_SOURCE = Symbol.for("polycss.animation.triangleFrameSource");
+
+interface PolyAnimationTriangleFrame {
+  polygonCount: number;
+  vertices: Float64Array;
+  colors?: readonly (string | undefined)[];
+  textureFlags?: readonly boolean[];
+  solidTriangles?: boolean;
+}
+
+interface PolyAnimationTriangleFrameSource {
+  [POLY_ANIMATION_TRIANGLE_FRAME_SOURCE]?: (
+    clip: number | string,
+    timeSeconds: number,
+  ) => PolyAnimationTriangleFrame | null | undefined;
+}
 
 export interface OptimizeAnimatedMeshPolygonsOptions {
   /** Public quality/resolution intent. Defaults to "lossy". */
   meshResolution?: MeshResolution;
 }
 
-interface SourceVertex {
-  polygonIndex: number;
-  vertexIndex: number;
-}
-
 interface PlannedPolygon {
   rest: Polygon;
-  sources: SourceVertex[];
-}
-
-function mappedVertices(frame: Polygon[], sources: SourceVertex[]): Vec3[] | null {
-  const vertices: Vec3[] = [];
-  for (const source of sources) {
-    const vertex = frame[source.polygonIndex]?.vertices[source.vertexIndex];
-    if (!vertex || vertex.some((value) => !Number.isFinite(value))) return null;
-    vertices.push([vertex[0], vertex[1], vertex[2]]);
-  }
-  return vertices;
+  originalIndex: number;
+  sourceRefs: number[];
 }
 
 function plannedOriginalPolygon(polygons: Polygon[], index: number): PlannedPolygon | null {
   const polygon = polygons[index];
   if (!polygon) return null;
+  const sourceRefs: number[] = [];
+  for (let vertexIndex = 0; vertexIndex < polygon.vertices.length; vertexIndex++) {
+    sourceRefs.push(index, vertexIndex);
+  }
   return {
     rest: polygon,
-    sources: polygon.vertices.map((_, vertexIndex) => ({ polygonIndex: index, vertexIndex })),
+    originalIndex: index,
+    sourceRefs,
   };
 }
 
@@ -52,21 +62,65 @@ function buildCulledTrianglePlan(polygons: Polygon[]): PlannedPolygon[] {
   return plan;
 }
 
-function applyPlanToFrame(frame: Polygon[], plan: PlannedPolygon[]): Polygon[] {
-  const out: Polygon[] = [];
-  for (const item of plan) {
-    const vertices = mappedVertices(frame, item.sources);
-    if (!vertices) return frame;
-    const color = frame[item.sources[0]?.polygonIndex]?.color ?? item.rest.color;
-    out.push({
+function applyPlanToFrame(frame: Polygon[], plan: PlannedPolygon[], useRestColor = false): Polygon[] {
+  const out: Polygon[] = new Array(plan.length);
+  for (let planIndex = 0; planIndex < plan.length; planIndex++) {
+    const item = plan[planIndex]!;
+    const refs = item.sourceRefs;
+    const vertices: Vec3[] = new Array(refs.length / 2);
+    for (let refIndex = 0, vertexOut = 0; refIndex < refs.length; refIndex += 2, vertexOut++) {
+      const sourcePolygon = frame[refs[refIndex]!];
+      const vertex = sourcePolygon?.vertices[refs[refIndex + 1]!];
+      if (!vertex) return frame;
+      const x = vertex[0];
+      const y = vertex[1];
+      const z = vertex[2];
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return frame;
+      vertices[vertexOut] = [x, y, z];
+    }
+    const color = useRestColor ? item.rest.color : frame[refs[0] ?? -1]?.color ?? item.rest.color;
+    out[planIndex] = {
       ...item.rest,
       vertices,
       color,
-    });
+    };
+  }
+  return out;
+}
+
+function planForFilteredFrame(plan: PlannedPolygon[], sourceIndices: readonly number[]): PlannedPolygon[] {
+  const indexMap = new Map<number, number>();
+  sourceIndices.forEach((sourceIndex, filteredIndex) => {
+    indexMap.set(sourceIndex, filteredIndex);
+  });
+  return plan.map((item, index) => ({
+    ...item,
+    sourceRefs: item.sourceRefs.map((value, sourceRefIndex) =>
+      sourceRefIndex % 2 === 0 ? indexMap.get(value) ?? -1 : value
+    ),
+  }));
+}
+
+function applyRestColorsToFilteredFrame(frame: Polygon[], plan: PlannedPolygon[]): Polygon[] | null {
+  if (frame.length < plan.length) return null;
+  const out: Polygon[] = new Array(plan.length);
+  for (let i = 0; i < plan.length; i++) {
+    const polygon = frame[i];
+    const item = plan[i]!;
+    if (!polygon || polygon.vertices.length !== item.rest.vertices.length) return null;
+    out[i] = {
+      ...item.rest,
+      vertices: polygon.vertices,
+      color: item.rest.color,
+    };
   }
   return out;
 }
 
+function hasTexture(polygon: Polygon): boolean {
+  return !!(polygon.texture || polygon.material?.texture);
+}
+
 export function optimizeAnimatedMeshPolygons(
   result: ParseResult,
   options: OptimizeAnimatedMeshPolygonsOptions = {},
@@ -77,16 +131,124 @@ export function optimizeAnimatedMeshPolygons(
 
   const culledPlan = buildCulledTrianglePlan(result.polygons);
   if (culledPlan.length === 0 || culledPlan.length >= result.polygons.length) return result;
+  const bakedAnimationInfo = getSolidTextureBakedAnimationInfo(result.animation);
+  const sampleSource = bakedAnimationInfo?.source ?? result.animation;
+  const sourceIndices = culledPlan.map((item) => item.originalIndex);
+  const filteredSource = filterGltfAnimationController(
+    sampleSource,
+    sourceIndices,
+  );
+  const frameSource = filteredSource ?? sampleSource;
+  const framePlan = filteredSource ? planForFilteredFrame(culledPlan, sourceIndices) : culledPlan;
+  const restColors = culledPlan.map((item) => item.rest.color);
+  const restSolidTriangles = culledPlan.every((item) => item.rest.vertices.length === 3 && !hasTexture(item.rest));
+  const filteredFrameDirect = filteredSource &&
+    !bakedAnimationInfo &&
+    culledPlan.length === sourceIndices.length &&
+    culledPlan.every((item, index) =>
+      item.rest.vertices.length === 3 &&
+      item.sourceRefs.length === 6 &&
+      item.sourceRefs[0] === sourceIndices[index] &&
+      item.sourceRefs[2] === sourceIndices[index] &&
+      item.sourceRefs[4] === sourceIndices[index]
+    );
+  const sourceFrameSampler =
+    (frameSource as ParseAnimationController & PolyAnimationTriangleFrameSource)[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE];
+  let optimizedVertices = new Float64Array(culledPlan.length * 9);
+  let optimizedColors: Array<string | undefined> = restColors.slice();
+  let optimizedTextureFlags: boolean[] = new Array(culledPlan.length).fill(false);
+  const optimizedFrame: PolyAnimationTriangleFrame = {
+    polygonCount: culledPlan.length,
+    vertices: optimizedVertices,
+    colors: optimizedColors,
+    textureFlags: optimizedTextureFlags,
+    solidTriangles: restSolidTriangles,
+  };
+
+  const animation = {
+    ...result.animation,
+    sample(clip, timeSeconds) {
+      const frame = frameSource!.sample(clip, timeSeconds);
+      if (filteredFrameDirect) return frame;
+      if (filteredSource && bakedAnimationInfo) {
+        return restSolidTriangles && culledPlan.length === sourceIndices.length
+          ? applyRestColorsToFilteredFrame(frame, culledPlan) ??
+            applyPlanToFrame(frame, framePlan, true)
+          : applyPlanToFrame(frame, framePlan, true);
+      }
+      return applyPlanToFrame(frame, framePlan, !!bakedAnimationInfo);
+    },
+  } as ParseAnimationController & PolyAnimationTriangleFrameSource;
+
+  if (sourceFrameSampler && restSolidTriangles) {
+    animation[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE] = (clip, timeSeconds) => {
+      const frame = sourceFrameSampler(clip, timeSeconds);
+      if (!frame) return frame;
+      if (filteredSource) {
+        if (frame.polygonCount < culledPlan.length || frame.vertices.length < culledPlan.length * 9) {
+          return null;
+        }
+        optimizedFrame.polygonCount = culledPlan.length;
+        optimizedFrame.vertices = frame.vertices;
+        optimizedFrame.colors = bakedAnimationInfo ? restColors : frame.colors;
+        optimizedFrame.textureFlags = bakedAnimationInfo ? optimizedTextureFlags : frame.textureFlags;
+        optimizedFrame.solidTriangles = bakedAnimationInfo
+          ? restSolidTriangles
+          : frame.solidTriangles === true;
+        return optimizedFrame;
+      }
+
+      if (optimizedVertices.length < culledPlan.length * 9) {
+        optimizedVertices = new Float64Array(culledPlan.length * 9);
+        optimizedFrame.vertices = optimizedVertices;
+      }
+      if (optimizedColors.length < culledPlan.length) {
+        optimizedColors = new Array(culledPlan.length);
+        optimizedFrame.colors = optimizedColors;
+      }
+      if (optimizedTextureFlags.length < culledPlan.length) {
+        optimizedTextureFlags = new Array(culledPlan.length).fill(false);
+        optimizedFrame.textureFlags = optimizedTextureFlags;
+      }
+
+      let solidTriangles = restSolidTriangles && frame.solidTriangles !== false;
+      for (let planIndex = 0; planIndex < framePlan.length; planIndex++) {
+        const item = framePlan[planIndex]!;
+        const refs = item.sourceRefs;
+        for (let refIndex = 0, vertexOut = 0; refIndex < refs.length; refIndex += 2, vertexOut++) {
+          const sourcePolygonIndex = refs[refIndex]!;
+          const sourceVertexIndex = refs[refIndex + 1]!;
+          if (sourcePolygonIndex < 0 || sourcePolygonIndex >= frame.polygonCount) return null;
+          const sourceOffset = sourcePolygonIndex * 9 + sourceVertexIndex * 3;
+          const targetOffset = planIndex * 9 + vertexOut * 3;
+          if (sourceOffset + 2 >= frame.vertices.length) return null;
+          optimizedVertices[targetOffset] = frame.vertices[sourceOffset]!;
+          optimizedVertices[targetOffset + 1] = frame.vertices[sourceOffset + 1]!;
+          optimizedVertices[targetOffset + 2] = frame.vertices[sourceOffset + 2]!;
+        }
+        const sourcePolygonIndex = refs[0]!;
+        const textureFlag = !!frame.textureFlags?.[sourcePolygonIndex];
+        optimizedTextureFlags[planIndex] = textureFlag;
+        optimizedColors[planIndex] = bakedAnimationInfo
+          ? item.rest.color
+          : frame.colors?.[sourcePolygonIndex] ?? item.rest.color;
+        if (!bakedAnimationInfo && textureFlag) solidTriangles = false;
+      }
+
+      optimizedFrame.polygonCount = culledPlan.length;
+      optimizedFrame.vertices = optimizedVertices;
+      optimizedFrame.colors = optimizedColors;
+      optimizedFrame.textureFlags = optimizedTextureFlags;
+      optimizedFrame.solidTriangles = bakedAnimationInfo ? restSolidTriangles : solidTriangles;
+      return optimizedFrame;
+    };
+  }
+
 
   return {
     ...result,
     polygons: culledPlan.map((item) => item.rest),
-    animation: {
-      ...result.animation,
-      sample(clip, timeSeconds) {
-        return applyPlanToFrame(result.animation!.sample(clip, timeSeconds), culledPlan);
-      },
-    },
+    animation,
     metadata: {
       ...result.metadata,
       triangleCount: culledPlan.length,
diff --git a/packages/core/src/parser/parseGltf.test.ts b/packages/core/src/parser/parseGltf.test.ts
index a9433b1e..70f4f211 100644
--- a/packages/core/src/parser/parseGltf.test.ts
+++ b/packages/core/src/parser/parseGltf.test.ts
@@ -1,9 +1,10 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { parseGltf } from "./parseGltf";
+import { filterGltfAnimationController, parseGltf } from "./parseGltf";
 import { bakeSolidTextureSamples } from "./solidTextureSamples";
 import { optimizeAnimatedMeshPolygons } from "../animation/optimizeAnimatedMeshPolygons";
+import { cullInteriorPolygons } from "../cull/cullInteriorPolygons";
 
 // ── Real GLB fixture (lead test — matches voxcss parseMagicaVoxel pattern) ─
 
@@ -170,6 +171,24 @@ describe("parseGltf — animated fixture (FishAnimated.glb)", () => {
     }
   });
 
+  it("can sample a glTF animation through a filtered triangle controller", () => {
+    const result = parseGltf(loadGlbFile("poly-pizza", "animated-robot.glb"), {
+      gridShift: 0,
+      targetSize: 72,
+    });
+    const kept = cullInteriorPolygons(result.polygons);
+    const keptSet = new Set(kept);
+    const keptIndices = result.polygons.flatMap((polygon, index) =>
+      keptSet.has(polygon) ? [index] : []
+    );
+    const filtered = filterGltfAnimationController(result.animation, keptIndices);
+    const running = result.animation?.clips.find((clip) => /running/i.test(clip.name));
+    expect(filtered).toBeDefined();
+    expect(running).toBeDefined();
+    expect(keptIndices.length).toBeLessThan(result.polygons.length);
+    expect(filtered!.sample(running!.name, 0.25)).toHaveLength(keptIndices.length);
+  });
+
   it("can reduce robot animation with a stable animated mesh plan", async () => {
     const parsed = parseGltf(loadGlbFile("poly-pizza", "animated-robot.glb"), {
       gridShift: 0,
@@ -180,11 +199,24 @@ describe("parseGltf — animated fixture (FishAnimated.glb)", () => {
       meshResolution: "lossy",
     });
     const running = optimized.animation?.clips.find((clip) => /running/i.test(clip.name));
+    const kept = cullInteriorPolygons(baked.polygons);
+    const keptSet = new Set(kept);
+    const keptIndices = baked.polygons.flatMap((polygon, index) =>
+      keptSet.has(polygon) ? [index] : []
+    );
     expect(running).toBeDefined();
     expect(optimized.polygons.length).toBeLessThan(baked.polygons.length);
     expect(optimized.polygons.length).toBeGreaterThan(0);
+    expect(optimized.polygons).toHaveLength(keptIndices.length);
     for (const time of [0, 0.25, running!.duration / 2]) {
-      expect(optimized.animation!.sample(running!.name, time)).toHaveLength(optimized.polygons.length);
+      const fullFrame = baked.animation!.sample(running!.name, time);
+      const frame = optimized.animation!.sample(running!.name, time);
+      expect(frame).toHaveLength(optimized.polygons.length);
+      expect(frame.some((polygon) => polygon.texture)).toBe(false);
+      expect(frame[0].color).toBe(optimized.polygons[0].color);
+      for (let i = 0; i < frame.length; i++) {
+        expect(frame[i].vertices).toEqual(fullFrame[keptIndices[i]!]!.vertices);
+      }
     }
   });
 });
diff --git a/packages/core/src/parser/parseGltf.ts b/packages/core/src/parser/parseGltf.ts
index dd9e88b5..af953236 100644
--- a/packages/core/src/parser/parseGltf.ts
+++ b/packages/core/src/parser/parseGltf.ts
@@ -539,6 +539,7 @@ function computeWorldMatrices(doc: GltfDoc, localMatrices: Mat4[]): Mat4[] {
 }
 
 interface AnimatedPrimitiveSource {
+  sourceIndex: number;
   meshNode: number | null;
   meshBindWorld: Mat4;
   skinIndex?: number;
@@ -570,6 +571,48 @@ interface RuntimeAnimationClip {
   channels: RuntimeAnimationChannel[];
 }
 
+interface AnimatedPolygonSourceRef {
+  sourceIndex: number;
+  triangleIndex: number;
+}
+
+interface RuntimeSourceTriangleMask {
+  triangleMask: readonly boolean[];
+  activeVertices: readonly number[];
+}
+
+interface GltfAnimationRuntimeInfo {
+  withPolygonFilter(indices: readonly number[]): ParseAnimationController | undefined;
+}
+
+const GLTF_ANIMATION_RUNTIME_INFO = Symbol("polycss.gltfAnimationRuntimeInfo");
+const POLY_ANIMATION_TRIANGLE_FRAME_SOURCE = Symbol.for("polycss.animation.triangleFrameSource");
+
+interface PolyAnimationTriangleFrame {
+  polygonCount: number;
+  vertices: Float64Array;
+  colors?: readonly (string | undefined)[];
+  textureFlags?: readonly boolean[];
+  solidTriangles?: boolean;
+}
+
+interface GltfAnimationController extends ParseAnimationController {
+  [GLTF_ANIMATION_RUNTIME_INFO]?: GltfAnimationRuntimeInfo;
+  [POLY_ANIMATION_TRIANGLE_FRAME_SOURCE]?: (
+    clip: number | string,
+    timeSeconds: number,
+  ) => PolyAnimationTriangleFrame | null | undefined;
+}
+
+export function filterGltfAnimationController(
+  animation: ParseAnimationController | undefined,
+  indices: readonly number[],
+): ParseAnimationController | undefined {
+  return animation
+    ? (animation as GltfAnimationController)[GLTF_ANIMATION_RUNTIME_INFO]?.withPolygonFilter(indices)
+    : undefined;
+}
+
 function sameProjectedVertex(a: Vec3, b: Vec3): boolean {
   return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
 }
@@ -652,7 +695,9 @@ function buildAnimationController(
   doc: GltfDoc,
   bin: Uint8Array,
   sources: AnimatedPrimitiveSource[],
+  polygonRefs: Array<AnimatedPolygonSourceRef | undefined>,
   project: (v: Vec3) => Vec3,
+  projectFrameVertex: (v: Vec3, out: Float64Array, offset: number) => void,
 ): ParseAnimationController | undefined {
   const animations = doc.animations ?? [];
   if (animations.length === 0 || sources.length === 0) return undefined;
@@ -705,6 +750,35 @@ function buildAnimationController(
   const clips = runtimeClips.map((clip) => clip.info);
   if (clips.length === 0) return undefined;
 
+  const sourceMasksFromPolygonFilter = (
+    indices: readonly number[],
+  ): RuntimeSourceTriangleMask[] | undefined => {
+    const masks = sources.map((source) => new Array(source.triangleMask.length).fill(false));
+    for (const index of indices) {
+      const ref = polygonRefs[index];
+      if (!ref) return undefined;
+      const sourceMask = masks[ref.sourceIndex];
+      if (!sourceMask || ref.triangleIndex < 0 || ref.triangleIndex >= sourceMask.length) return undefined;
+      sourceMask[ref.triangleIndex] = true;
+    }
+
+    return masks.map((triangleMask, sourceIndex): RuntimeSourceTriangleMask => {
+      const source = sources[sourceIndex]!;
+      const used = new Set<number>();
+      let triangleOrdinal = 0;
+      for (let i = 0; i + 2 < source.indices.length; i += 3, triangleOrdinal++) {
+        if (!triangleMask[triangleOrdinal]) continue;
+        used.add(source.indices[i]!);
+        used.add(source.indices[i + 1]!);
+        used.add(source.indices[i + 2]!);
+      }
+      return {
+        triangleMask,
+        activeVertices: Array.from(used).sort((a, b) => a - b),
+      };
+    });
+  };
+
   const polygonFromWorldTri = (
     v0World: Vec3,
     v1World: Vec3,
@@ -722,41 +796,68 @@ function buildAnimationController(
     return polygon;
   };
 
-  const sample = (clipRef: number | string, timeSecondsIn: number): Polygon[] => {
-    const clip = typeof clipRef === "number"
-      ? runtimeClips[clipRef]
-      : runtimeClips.find((candidate) => candidate.info.name === clipRef);
-    if (!clip) return [];
-    const duration = clip.info.duration;
-    const timeSeconds = duration > 0
-      ? ((timeSecondsIn % duration) + duration) % duration
-      : Math.max(0, timeSecondsIn);
-
-    const poses = basePoses.map((pose): NodePose => ({
-      translation: pose.translation.slice(),
-      rotation: pose.rotation.slice(),
-      scale: pose.scale.slice(),
-      matrix: pose.matrix ? pose.matrix.slice() as Mat4 : undefined,
-    }));
-
-    for (const channel of clip.channels) {
-      const pose = poses[channel.targetNode];
-      if (!pose) continue;
-      const value = sampleAnimationChannel(channel.sampler, timeSeconds, channel.path);
-      // Animated TRS channels override matrix-based locals per glTF's node
-      // animation model; converting arbitrary matrices to TRS is intentionally
-      // out of scope for this minimal runtime.
-      pose.matrix = undefined;
-      if (channel.path === "translation") pose.translation = value.slice(0, 3);
-      else if (channel.path === "rotation") pose.rotation = normalizeQuat(value.slice(0, 4));
-      else if (channel.path === "scale") pose.scale = value.slice(0, 3);
-    }
+  const createController = (
+    sourceMaskOverrides?: RuntimeSourceTriangleMask[],
+  ): ParseAnimationController => {
+    const activeTriangleCapacity = sources.reduce((sum, source, sourceIndex) => {
+      const mask = sourceMaskOverrides?.[sourceIndex]?.triangleMask ?? source.triangleMask;
+      let count = 0;
+      for (let i = 0; i < mask.length; i++) {
+        if (mask[i]) count++;
+      }
+      return sum + count;
+    }, 0);
+    let triangleFrameVertices = new Float64Array(Math.max(0, activeTriangleCapacity * 9));
+    let triangleFrameColors: Array<string | undefined> = new Array(activeTriangleCapacity);
+    let triangleFrameTextureFlags: boolean[] = new Array(activeTriangleCapacity).fill(false);
+    const triangleFrame: PolyAnimationTriangleFrame = {
+      polygonCount: 0,
+      vertices: triangleFrameVertices,
+      colors: triangleFrameColors,
+      textureFlags: triangleFrameTextureFlags,
+      solidTriangles: true,
+    };
 
-    const worldMatrices = computeWorldMatrices(doc, poses.map(poseLocalMatrix));
-    const polygons: Polygon[] = [];
+    const sampleWorldMatrices = (clipRef: number | string, timeSecondsIn: number): Mat4[] | null => {
+      const clip = typeof clipRef === "number"
+        ? runtimeClips[clipRef]
+        : runtimeClips.find((candidate) => candidate.info.name === clipRef);
+      if (!clip) return null;
+      const duration = clip.info.duration;
+      const timeSeconds = duration > 0
+        ? ((timeSecondsIn % duration) + duration) % duration
+        : Math.max(0, timeSecondsIn);
+
+      const poses = basePoses.map((pose): NodePose => ({
+        translation: pose.translation.slice(),
+        rotation: pose.rotation.slice(),
+        scale: pose.scale.slice(),
+        matrix: pose.matrix ? pose.matrix.slice() as Mat4 : undefined,
+      }));
+
+      for (const channel of clip.channels) {
+        const pose = poses[channel.targetNode];
+        if (!pose) continue;
+        const value = sampleAnimationChannel(channel.sampler, timeSeconds, channel.path);
+        // Animated TRS channels override matrix-based locals per glTF's node
+        // animation model; converting arbitrary matrices to TRS is intentionally
+        // out of scope for this minimal runtime.
+        pose.matrix = undefined;
+        if (channel.path === "translation") pose.translation = value.slice(0, 3);
+        else if (channel.path === "rotation") pose.rotation = normalizeQuat(value.slice(0, 4));
+        else if (channel.path === "scale") pose.scale = value.slice(0, 3);
+      }
 
-    for (const source of sources) {
-      const worldPositions: Vec3[] = [];
+      return computeWorldMatrices(doc, poses.map(poseLocalMatrix));
+    };
+
+    const computeSourceWorldPositions = (
+      source: AnimatedPrimitiveSource,
+      sourceMask: RuntimeSourceTriangleMask | undefined,
+      worldMatrices: Mat4[],
+    ): Array<Vec3 | undefined> => {
+      const activeVertices = sourceMask?.activeVertices;
+      const worldPositions: Array<Vec3 | undefined> = new Array(source.positions.length);
       if (
         source.skinIndex !== undefined &&
         source.joints &&
@@ -764,12 +865,14 @@ function buildAnimationController(
         skins[source.skinIndex]
       ) {
         const skin = skins[source.skinIndex];
-        for (let i = 0; i < source.positions.length; i++) {
+        const sourceJoints = source.joints;
+        const sourceWeights = source.weights;
+        const skinVertex = (i: number): void => {
           const bindPosition = source.positions[i];
           let blended: Vec3 = [0, 0, 0];
           let weightSum = 0;
-          const joints = source.joints[i] ?? [];
-          const weights = source.weights[i] ?? [];
+          const joints = sourceJoints[i] ?? [];
+          const weights = sourceWeights[i] ?? [];
           for (let j = 0; j < 4; j++) {
             const weight = weights[j] ?? 0;
             if (weight <= 0) continue;
@@ -782,42 +885,131 @@ function buildAnimationController(
             blended = addVec3(blended, scaleVec3(transformPoint(jointMatrix, bindPosition), weight));
             weightSum += weight;
           }
-          worldPositions.push(weightSum > 0
+          worldPositions[i] = weightSum > 0
             ? scaleVec3(blended, 1 / weightSum)
-            : transformPoint(source.meshBindWorld, bindPosition));
+            : transformPoint(source.meshBindWorld, bindPosition);
+        };
+        if (activeVertices) {
+          for (const vertexIndex of activeVertices) skinVertex(vertexIndex);
+        } else {
+          for (let i = 0; i < source.positions.length; i++) skinVertex(i);
         }
       } else {
         const meshWorld = source.meshNode !== null
           ? (worldMatrices[source.meshNode] ?? source.meshBindWorld)
           : source.meshBindWorld;
-        for (const position of source.positions) {
-          worldPositions.push(transformPoint(meshWorld, position));
+        const transformVertex = (i: number): void => {
+          worldPositions[i] = transformPoint(meshWorld, source.positions[i]);
+        };
+        if (activeVertices) {
+          for (const vertexIndex of activeVertices) transformVertex(vertexIndex);
+        } else {
+          for (let i = 0; i < source.positions.length; i++) transformVertex(i);
         }
       }
+      return worldPositions;
+    };
 
-      let triangleOrdinal = 0;
-      for (let i = 0; i + 2 < source.indices.length; i += 3, triangleOrdinal++) {
-        if (!source.triangleMask[triangleOrdinal]) continue;
-        const i0 = source.indices[i];
-        const i1 = source.indices[i + 1];
-        const i2 = source.indices[i + 2];
-        const v0 = worldPositions[i0];
-        const v1 = worldPositions[i1];
-        const v2 = worldPositions[i2];
-        if (!v0 || !v1 || !v2) continue;
-        let triUvs: Vec2[] | undefined;
-        if (source.uvs && source.texture) {
-          const u0 = source.uvs[i0], u1 = source.uvs[i1], u2 = source.uvs[i2];
-          if (u0 && u1 && u2) triUvs = [u0, u1, u2];
+    const sample = (clipRef: number | string, timeSecondsIn: number): Polygon[] => {
+      const worldMatrices = sampleWorldMatrices(clipRef, timeSecondsIn);
+      if (!worldMatrices) return [];
+      const polygons: Polygon[] = [];
+
+      for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
+        const source = sources[sourceIndex]!;
+        const sourceMask = sourceMaskOverrides?.[sourceIndex];
+        const triangleMask = sourceMask?.triangleMask ?? source.triangleMask;
+        const worldPositions = computeSourceWorldPositions(source, sourceMask, worldMatrices);
+
+        let triangleOrdinal = 0;
+        for (let i = 0; i + 2 < source.indices.length; i += 3, triangleOrdinal++) {
+          if (!triangleMask[triangleOrdinal]) continue;
+          const i0 = source.indices[i];
+          const i1 = source.indices[i + 1];
+          const i2 = source.indices[i + 2];
+          const v0 = worldPositions[i0];
+          const v1 = worldPositions[i1];
+          const v2 = worldPositions[i2];
+          if (!v0 || !v1 || !v2) continue;
+          let triUvs: Vec2[] | undefined;
+          if (source.uvs && source.texture) {
+            const u0 = source.uvs[i0], u1 = source.uvs[i1], u2 = source.uvs[i2];
+            if (u0 && u1 && u2) triUvs = [u0, u1, u2];
+          }
+          const polygon = polygonFromWorldTri(v0, v1, v2, source.color, source.texture, triUvs);
+          if (polygon) polygons.push(polygon);
         }
-        const polygon = polygonFromWorldTri(v0, v1, v2, source.color, source.texture, triUvs);
-        if (polygon) polygons.push(polygon);
       }
-    }
-    return polygons;
+      return polygons;
+    };
+
+    const sampleTriangleFrame = (
+      clipRef: number | string,
+      timeSecondsIn: number,
+    ): PolyAnimationTriangleFrame | null => {
+      const worldMatrices = sampleWorldMatrices(clipRef, timeSecondsIn);
+      if (!worldMatrices) return null;
+      if (triangleFrameVertices.length < activeTriangleCapacity * 9) {
+        triangleFrameVertices = new Float64Array(activeTriangleCapacity * 9);
+        triangleFrame.vertices = triangleFrameVertices;
+      }
+      if (triangleFrameColors.length < activeTriangleCapacity) {
+        triangleFrameColors = new Array(activeTriangleCapacity);
+        triangleFrame.colors = triangleFrameColors;
+      }
+      if (triangleFrameTextureFlags.length < activeTriangleCapacity) {
+        triangleFrameTextureFlags = new Array(activeTriangleCapacity).fill(false);
+        triangleFrame.textureFlags = triangleFrameTextureFlags;
+      }
+      let polygonCount = 0;
+      let writeOffset = 0;
+      let hasTexture = false;
+
+      for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
+        const source = sources[sourceIndex]!;
+        const sourceMask = sourceMaskOverrides?.[sourceIndex];
+        const triangleMask = sourceMask?.triangleMask ?? source.triangleMask;
+        const worldPositions = computeSourceWorldPositions(source, sourceMask, worldMatrices);
+
+        let triangleOrdinal = 0;
+        for (let i = 0; i + 2 < source.indices.length; i += 3, triangleOrdinal++) {
+          if (!triangleMask[triangleOrdinal]) continue;
+          const i0 = source.indices[i]!;
+          const i1 = source.indices[i + 1]!;
+          const i2 = source.indices[i + 2]!;
+          const v0 = worldPositions[i0];
+          const v1 = worldPositions[i1];
+          const v2 = worldPositions[i2];
+          if (!v0 || !v1 || !v2) continue;
+          projectFrameVertex(v0, triangleFrameVertices, writeOffset);
+          projectFrameVertex(v1, triangleFrameVertices, writeOffset + 3);
+          projectFrameVertex(v2, triangleFrameVertices, writeOffset + 6);
+          triangleFrameColors[polygonCount] = source.color;
+          const textured = !!source.texture;
+          triangleFrameTextureFlags[polygonCount] = textured;
+          if (textured) hasTexture = true;
+          polygonCount++;
+          writeOffset += 9;
+        }
+      }
+
+      triangleFrame.polygonCount = polygonCount;
+      triangleFrame.solidTriangles = !hasTexture;
+      return triangleFrame;
+    };
+
+    const controller: GltfAnimationController = { clips, sample };
+    controller[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE] = sampleTriangleFrame;
+    controller[GLTF_ANIMATION_RUNTIME_INFO] = {
+      withPolygonFilter(indices) {
+        const masks = sourceMasksFromPolygonFilter(indices);
+        return masks ? createController(masks) : undefined;
+      },
+    };
+    return controller;
   };
 
-  return { clips, sample };
+  return createController();
 }
 
 export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOptions): ParseResult {
@@ -855,10 +1047,12 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
     texture?: string;
     uvs?: Vec2[];
     source?: AnimatedPrimitiveSource;
+    sourceIndex?: number;
     sourceTriangleIndex?: number;
   }
   const rawTris: RawTri[] = [];
   const animatedSources: AnimatedPrimitiveSource[] = [];
+  const animatedPolygonRefs: Array<AnimatedPolygonSourceRef | undefined> = [];
   const meshNames: string[] = (doc.meshes ?? []).map((m, i) => m.name ?? `mesh_${i}`);
   const materialNames: string[] = (doc.materials ?? []).map((m, i) => m.name ?? `material_${i}`);
 
@@ -920,6 +1114,7 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
         const joints = readAccessorTupleArray(doc, bin, prim.attributes.JOINTS_0, 4, vertCount);
         const weights = readAccessorTupleArray(doc, bin, prim.attributes.WEIGHTS_0, 4, vertCount);
         animatedSource = {
+          sourceIndex: animatedSources.length,
           meshNode,
           meshBindWorld: world,
           skinIndex: meshNode !== null ? doc.nodes?.[meshNode]?.skin : undefined,
@@ -947,7 +1142,17 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
           const u0 = uvs[indices[i]], u1 = uvs[indices[i + 1]], u2 = uvs[indices[i + 2]];
           if (u0 && u1 && u2) triUvs = [u0, u1, u2];
         }
-        rawTris.push({ v0, v1, v2, color, texture, uvs: triUvs, source: animatedSource, sourceTriangleIndex });
+        rawTris.push({
+          v0,
+          v1,
+          v2,
+          color,
+          texture,
+          uvs: triUvs,
+          source: animatedSource,
+          sourceIndex: animatedSource?.sourceIndex,
+          sourceTriangleIndex,
+        });
       }
     }
   }
@@ -1010,6 +1215,17 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
         round((x - minX) * scale + gridShift),
         round((y - minY) * scale + gridShift),
       ];
+  const projectFrameVertex = upAxis === "z"
+    ? (v: Vec3, out: Float64Array, offset: number): void => {
+        out[offset] = round((v[0] - minX) * scale + gridShift);
+        out[offset + 1] = round((v[1] - minY) * scale + gridShift);
+        out[offset + 2] = round((v[2] - minZ) * scale + gridShift);
+      }
+    : (v: Vec3, out: Float64Array, offset: number): void => {
+        out[offset] = round((v[2] - minZ) * scale + gridShift);
+        out[offset + 1] = round((v[0] - minX) * scale + gridShift);
+        out[offset + 2] = round((v[1] - minY) * scale + gridShift);
+      };
   const polygons: Polygon[] = [];
   for (const t of rawTris) {
     const v0 = project(t.v0);
@@ -1027,8 +1243,20 @@ export function parseGltf(input: ArrayBuffer | Uint8Array, options?: GltfParseOp
     if (t.texture) p.texture = t.texture;
     if (t.uvs) p.uvs = t.uvs;
     polygons.push(p);
+    animatedPolygonRefs.push(
+      t.sourceIndex !== undefined && t.sourceTriangleIndex !== undefined
+        ? { sourceIndex: t.sourceIndex, triangleIndex: t.sourceTriangleIndex }
+        : undefined,
+    );
   }
-  const animation = buildAnimationController(doc, bin, animatedSources, project);
+  const animation = buildAnimationController(
+    doc,
+    bin,
+    animatedSources,
+    animatedPolygonRefs,
+    project,
+    projectFrameVertex,
+  );
 
   return {
     polygons,
diff --git a/packages/core/src/parser/solidTextureSamples.test.ts b/packages/core/src/parser/solidTextureSamples.test.ts
new file mode 100644
index 00000000..27182d84
--- /dev/null
+++ b/packages/core/src/parser/solidTextureSamples.test.ts
@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Polygon } from "../types";
+import type { ParseResult } from "./types";
+import { bakeSolidTextureSamples, getSolidTextureBakedAnimationInfo } from "./solidTextureSamples";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+function installSolidTextureEnv(color: [number, number, number, number]): void {
+  class FakeImage {
+    naturalWidth = 1;
+    naturalHeight = 1;
+    width = 1;
+    height = 1;
+    onload: (() => void) | null = null;
+    onerror: (() => void) | null = null;
+
+    set src(_value: string) {
+      queueMicrotask(() => this.onload?.());
+    }
+  }
+
+  vi.stubGlobal("Image", FakeImage);
+  vi.stubGlobal("document", {
+    createElement(tagName: string) {
+      if (tagName !== "canvas") throw new Error(`unexpected element ${tagName}`);
+      return {
+        width: 0,
+        height: 0,
+        getContext(type: string) {
+          if (type !== "2d") return null;
+          return {
+            drawImage() {},
+            getImageData() {
+              return { data: color };
+            },
+          };
+        },
+      };
+    },
+  });
+}
+
+function texturedTriangle(vertices: Polygon["vertices"]): Polygon {
+  const uvs: Polygon["uvs"] = [[0, 0], [1, 0], [0, 1]];
+  return {
+    vertices,
+    color: "#000000",
+    texture: "texture.png",
+    uvs,
+    textureTriangles: [{ uvs: [uvs[0], uvs[1], uvs[2]] }],
+  };
+}
+
+describe("bakeSolidTextureSamples", () => {
+  it("reuses baked solid texture colors for animated samples", async () => {
+    installSolidTextureEnv([10, 20, 30, 255]);
+    const rest = texturedTriangle([[0, 0, 0], [1, 0, 0], [0, 1, 0]]);
+    const animated = texturedTriangle([[0, 0, 0], [2, 0, 0], [0, 2, 0]]);
+    let sampleCalls = 0;
+    const result: ParseResult = {
+      polygons: [rest],
+      objectUrls: [],
+      dispose() {},
+      warnings: [],
+      animation: {
+        clips: [{ index: 0, name: "move", duration: 1, channelCount: 1 }],
+        sample() {
+          sampleCalls++;
+          return [animated];
+        },
+      },
+    };
+
+    const baked = await bakeSolidTextureSamples(result);
+    const frame = baked.animation!.sample("move", 0.5);
+    const bakedAnimationInfo = getSolidTextureBakedAnimationInfo(baked.animation);
+
+    expect(sampleCalls).toBe(1);
+    expect(bakedAnimationInfo?.source).toBe(result.animation);
+    expect(bakedAnimationInfo?.bakedColorEntries).toEqual([{ index: 0, color: "#0a141e" }]);
+    expect(baked.polygons[0].color).toBe("#0a141e");
+    expect(baked.polygons[0].texture).toBeUndefined();
+    expect(frame[0].vertices).toEqual(animated.vertices);
+    expect(frame[0].color).toBe("#0a141e");
+    expect(frame[0].texture).toBeUndefined();
+    expect(frame[0].uvs).toBeUndefined();
+    expect(frame[0].textureTriangles).toBeUndefined();
+  });
+});
diff --git a/packages/core/src/parser/solidTextureSamples.ts b/packages/core/src/parser/solidTextureSamples.ts
index 61842eb2..2eadff00 100644
--- a/packages/core/src/parser/solidTextureSamples.ts
+++ b/packages/core/src/parser/solidTextureSamples.ts
@@ -1,5 +1,5 @@
 import type { Polygon, TextureTriangle, Vec2 } from "../types";
-import type { ParseResult } from "./types";
+import type { ParseAnimationController, ParseResult } from "./types";
 
 export interface SolidTextureSampleOptions {
   /**
@@ -62,6 +62,37 @@ interface ColorStats {
   count: number;
 }
 
+export interface SolidTextureBakedColorEntry {
+  index: number;
+  color: string;
+}
+
+export interface SolidTextureBakedAnimationInfo {
+  source: ParseAnimationController;
+  bakedColorEntries: readonly SolidTextureBakedColorEntry[];
+}
+
+export const SOLID_TEXTURE_BAKED_ANIMATION_INFO: unique symbol = Symbol(
+  "polycss.solidTextureBakedAnimationInfo",
+);
+const POLY_ANIMATION_TRIANGLE_FRAME_SOURCE = Symbol.for("polycss.animation.triangleFrameSource");
+
+interface PolyAnimationTriangleFrame {
+  polygonCount: number;
+  vertices: Float64Array;
+  colors?: readonly (string | undefined)[];
+  textureFlags?: readonly boolean[];
+  solidTriangles?: boolean;
+}
+
+interface SolidTextureBakedAnimation extends ParseAnimationController {
+  [SOLID_TEXTURE_BAKED_ANIMATION_INFO]?: SolidTextureBakedAnimationInfo;
+  [POLY_ANIMATION_TRIANGLE_FRAME_SOURCE]?: (
+    clip: number | string,
+    timeSeconds: number,
+  ) => PolyAnimationTriangleFrame | null | undefined;
+}
+
 const DEFAULT_MAX_TEXTURE_PIXELS = 16 * 1024 * 1024;
 const DEFAULT_COLOR_TOLERANCE = 2;
 const SMOOTH_SWATCH_TOLERANCE = 32;
@@ -374,6 +405,27 @@ function bakePolygon(polygon: Polygon, color: string): Polygon {
   };
 }
 
+export function bakeSolidTextureSampledAnimationFrame(
+  frame: Polygon[],
+  bakedColorEntries: readonly SolidTextureBakedColorEntry[],
+): Polygon[] {
+  const nextFrame = frame.slice();
+  for (let i = 0; i < bakedColorEntries.length; i++) {
+    const entry = bakedColorEntries[i]!;
+    const polygon = frame[entry.index];
+    if (polygon) nextFrame[entry.index] = bakePolygon(polygon, entry.color);
+  }
+  return nextFrame;
+}
+
+export function getSolidTextureBakedAnimationInfo(
+  animation: ParseAnimationController | undefined,
+): SolidTextureBakedAnimationInfo | undefined {
+  return animation
+    ? (animation as SolidTextureBakedAnimation)[SOLID_TEXTURE_BAKED_ANIMATION_INFO]
+    : undefined;
+}
+
 interface SolidTextureBaker {
   bake(polygons: Polygon[]): { polygons: Polygon[]; changed: boolean };
 }
@@ -436,18 +488,72 @@ export async function bakeSolidTextureSamples(
   if (!baker) return result;
 
   const baked = baker.bake(result.polygons);
-  if (!baked.changed && !result.animation) return result;
+  if (!baked.changed) return result;
+  const bakedColorEntries: SolidTextureBakedColorEntry[] = [];
+  for (let index = 0; index < baked.polygons.length; index++) {
+    const polygon = baked.polygons[index]!;
+    const color = polygon.color;
+    if (polygon !== result.polygons[index] && color) {
+      bakedColorEntries.push({ index, color });
+    }
+  }
+  const animation = result.animation;
+  const bakedAnimation: ParseAnimationController | undefined = animation
+    ? {
+        ...animation,
+        sample(clip, timeSeconds) {
+          return bakeSolidTextureSampledAnimationFrame(
+            animation.sample(clip, timeSeconds),
+            bakedColorEntries,
+          );
+        },
+      }
+    : animation;
+  if (bakedAnimation && animation) {
+    const sourceFrameSampler =
+      (animation as SolidTextureBakedAnimation)[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE];
+    if (sourceFrameSampler) {
+      const bakedColorByIndex = new Map(bakedColorEntries.map((entry) => [entry.index, entry.color]));
+      let colors: Array<string | undefined> = [];
+      const bakedFrame: PolyAnimationTriangleFrame = {
+        polygonCount: 0,
+        vertices: new Float64Array(0),
+        colors,
+        solidTriangles: false,
+      };
+      (bakedAnimation as SolidTextureBakedAnimation)[POLY_ANIMATION_TRIANGLE_FRAME_SOURCE] = (
+        clip,
+        timeSeconds,
+      ) => {
+        const frame = sourceFrameSampler(clip, timeSeconds);
+        if (!frame) return frame;
+        if (colors.length < frame.polygonCount) {
+          colors = new Array(frame.polygonCount);
+          bakedFrame.colors = colors;
+        }
+        const textureFlags = frame.textureFlags;
+        let solidTriangles = frame.solidTriangles === true || !!textureFlags;
+        for (let i = 0; i < frame.polygonCount; i++) {
+          const bakedColor = bakedColorByIndex.get(i);
+          colors[i] = bakedColor ?? frame.colors?.[i];
+          if (textureFlags?.[i] && !bakedColor) solidTriangles = false;
+        }
+        bakedFrame.polygonCount = frame.polygonCount;
+        bakedFrame.vertices = frame.vertices;
+        bakedFrame.textureFlags = textureFlags;
+        bakedFrame.solidTriangles = solidTriangles;
+        return bakedFrame;
+      };
+    }
+    (bakedAnimation as SolidTextureBakedAnimation)[SOLID_TEXTURE_BAKED_ANIMATION_INFO] = {
+      source: animation,
+      bakedColorEntries,
+    };
+  }
 
   return {
     ...result,
     polygons: baked.polygons,
-    animation: result.animation
-      ? {
-          ...result.animation,
-          sample(clip, timeSeconds) {
-            return baker.bake(result.animation!.sample(clip, timeSeconds)).polygons;
-          },
-        }
-      : result.animation,
+    animation: bakedAnimation,
   };
 }
diff --git a/packages/polycss/src/api/createPolyScene.ts b/packages/polycss/src/api/createPolyScene.ts
index 34e118ba..73341c88 100644
--- a/packages/polycss/src/api/createPolyScene.ts
+++ b/packages/polycss/src/api/createPolyScene.ts
@@ -57,6 +57,7 @@ import {
   renderPolygonsWithTextureAtlas,
   renderPolygonsWithTextureAtlasAsync,
   renderPolygonsWithStableTriangles,
+  updateStableTriangleFrame,
   updatePolygonsWithStableTopology,
   type TextureQuality,
   type PolyRenderStrategiesOption,
@@ -236,7 +237,7 @@ export interface PolyMeshHandle {
 // Internal-only async update hook for large imperative scene users. Keeping it
 // off PolyMeshHandle avoids turning a debug-workbench long-task fix into a
 // public API contract that React/Vue also need to mirror.
-interface InternalPolyMeshHandle extends PolyMeshHandle {
+interface InternalPolyMeshHandle extends PolyMeshHandle, PolyAnimationTriangleFrameTarget {
   setPolygonsChunked(polygons: Polygon[], options?: {
     merge?: boolean;
     stableDom?: boolean;
@@ -285,6 +286,7 @@ export interface PolySceneHandle {
 
 const DEFAULT_ZOOM = 1;
 const DEFAULT_TILE = BASE_TILE;
+const POLY_ANIMATION_TRIANGLE_FRAME_TARGET = Symbol.for("polycss.animation.triangleFrameTarget");
 // Sentinel that keeps broad camera DOM culling disabled once a mesh proves
 // it has non-voxel normals; callers never inspect group contents directly.
 const NON_CULLABLE_CAMERA_GROUP: CameraCullNormalGroup = {
@@ -311,6 +313,20 @@ interface InternalSetPolygonsOptions {
   stableTriangleMatrixDecimals?: number;
 }
 
+interface PolyAnimationTriangleFrame {
+  polygonCount: number;
+  vertices: ArrayLike<number>;
+  colors?: readonly (string | undefined)[];
+  solidTriangles?: boolean;
+}
+
+interface PolyAnimationTriangleFrameTarget {
+  [POLY_ANIMATION_TRIANGLE_FRAME_TARGET]?: (
+    frame: PolyAnimationTriangleFrame,
+    options?: InternalSetPolygonsOptions,
+  ) => boolean;
+}
+
 function strategiesEqual(
   a: PolyRenderStrategiesOption | undefined,
   b: PolyRenderStrategiesOption | undefined,
@@ -1407,8 +1423,125 @@ export function createPolyScene(
       bakedRotation: (transformIn.rotation ? [...transformIn.rotation] : [0, 0, 0]) as Vec3,
     };
 
+    let currentTriangleFrame: PolyAnimationTriangleFrame | null = null;
+    let currentTriangleFrameVersion = 0;
+    let materializedTriangleFrameVersion = -1;
+    let materializedTriangleFramePolygons: Polygon[] | null = null;
+
+    function clearCurrentTriangleFrame(): void {
+      currentTriangleFrame = null;
+      materializedTriangleFramePolygons = null;
+      materializedTriangleFrameVersion = -1;
+    }
+
+    function currentPolygons(): Polygon[] {
+      const frame = currentTriangleFrame;
+      if (!frame || frame.polygonCount !== entry.polygons.length) return entry.polygons;
+      if (
+        materializedTriangleFramePolygons &&
+        materializedTriangleFrameVersion === currentTriangleFrameVersion
+      ) {
+        return materializedTriangleFramePolygons;
+      }
+      const values = frame.vertices;
+      const out: Polygon[] = new Array(frame.polygonCount);
+      for (let polygonIndex = 0; polygonIndex < frame.polygonCount; polygonIndex++) {
+        const base = entry.polygons[polygonIndex]!;
+        const offset = polygonIndex * 9;
+        out[polygonIndex] = {
+          ...base,
+          color: frame.colors?.[polygonIndex] ?? base.color,
+          vertices: [
+            [values[offset]!, values[offset + 1]!, values[offset + 2]!] as Vec3,
+            [values[offset + 3]!, values[offset + 4]!, values[offset + 5]!] as Vec3,
+            [values[offset + 6]!, values[offset + 7]!, values[offset + 8]!] as Vec3,
+          ],
+        };
+      }
+      materializedTriangleFramePolygons = out;
+      materializedTriangleFrameVersion = currentTriangleFrameVersion;
+      return out;
+    }
+
+    function applyStableTopologyUpdate(
+      options: InternalSetPolygonsOptions | undefined,
+      shouldRecomputeAutoCenter: boolean,
+    ): boolean {
+      const colorOnlyStableTriangleUpdate =
+        options?.stableTriangleUpdateMode === "color-only";
+      entry.stableTriangleColorFrame++;
+      const shouldSkipTransformOrigin =
+        entry.stableDom && !shouldRecomputeAutoCenter;
+      if (!shouldSkipTransformOrigin) applyTransformOrigin(entry.polygons);
+      if (entry.stableDom && !entry.hasBuckets) {
+        const renderOptions = {
+          doc,
+          directionalLight: currentOptions.directionalLight,
+          ambientLight: currentOptions.ambientLight,
+          textureLighting: currentOptions.textureLighting,
+          textureQuality: currentOptions.textureQuality,
+        };
+        const allStableTriangles =
+          entry.rendered.length === entry.polygons.length &&
+          entry.rendered.every((item) => item.kind === "triangle");
+        const optimizeStableTopology =
+          entry.stableDom && !shouldRecomputeAutoCenter;
+        const solidPaintDefaults = allStableTriangles || optimizeStableTopology
+          ? {}
+          : getSolidPaintDefaults(entry.polygons, renderOptions);
+        if (!allStableTriangles) applySolidPaintVars(entry.wrapper, solidPaintDefaults);
+        const stableTopologyOptions = {
+          ...renderOptions,
+          solidPaintDefaults,
+          optimizeStableTriangleStyle: true,
+          stableTriangleDebug: options?.stableTriangleDebug,
+          stableTriangleUpdateMode: options?.stableTriangleUpdateMode,
+          stableTriangleColorPolicy: options?.stableTriangleColorPolicy,
+          stableTriangleColorSteps: options?.stableTriangleColorSteps,
+          stableTriangleColorFreezeFrames: options?.stableTriangleColorFreezeFrames,
+          stableTriangleColorBudget: options?.stableTriangleColorBudget,
+          stableTriangleColorMaxAge: options?.stableTriangleColorMaxAge,
+          stableTriangleColorMaxStep: options?.stableTriangleColorMaxStep,
+          stableTriangleMatrixDecimals: options?.stableTriangleMatrixDecimals,
+          stableTriangleColorFrame: entry.stableTriangleColorFrame,
+        } as Parameters<typeof updatePolygonsWithStableTopology>[2] & {
+          optimizeStableTriangleStyle: boolean;
+          stableTriangleDebug?: "transform-only" | "plan-only";
+          stableTriangleUpdateMode?: "full" | "transform-only" | "color-only";
+          stableTriangleColorPolicy?: "cadence" | "adaptive";
+          stableTriangleColorSteps?: number;
+          stableTriangleColorFreezeFrames?: number;
+          stableTriangleColorBudget?: number;
+          stableTriangleColorMaxAge?: number;
+          stableTriangleColorMaxStep?: number;
+          stableTriangleMatrixDecimals?: number;
+          stableTriangleColorFrame?: number;
+        };
+        if (
+          updatePolygonsWithStableTopology(
+            entry.rendered,
+            entry.polygons,
+            stableTopologyOptions,
+          )
+        ) {
+          if (!colorOnlyStableTriangleUpdate) {
+            recomputeCameraCullGroups(entry);
+            syncMountedRenderedForCameraChange(entry, true);
+            if (shouldRecomputeAutoCenter) recomputeAutoCenter();
+          }
+          return true;
+        }
+      }
+      if (shouldSkipTransformOrigin) applyTransformOrigin(entry.polygons);
+      return false;
+    }
+
     const handle: InternalPolyMeshHandle = {
-      polygons: sourcePolygons,
+      get polygons() { return currentPolygons(); },
+      set polygons(polygons: Polygon[]) {
+        clearCurrentTriangleFrame();
+        entry.polygons = polygons;
+      },
       element: wrapper,
       id: transformIn.id,
       get transform() { return transform; },
@@ -1428,34 +1561,56 @@ export function createPolyScene(
         entry.stableDom = stableDomOnUpdate;
         entry.voxelSource = undefined;
         entry.polygons = preparePolygons(polygons, mergeOnUpdate);
+        clearCurrentTriangleFrame();
         handle.polygons = entry.polygons;
         const shouldRecomputeAutoCenter = options?.recomputeAutoCenter ?? true;
-        const colorOnlyStableTriangleUpdate =
-          options?.stableTriangleUpdateMode === "color-only";
-        entry.stableTriangleColorFrame++;
-        const shouldSkipTransformOrigin =
-          entry.stableDom && !shouldRecomputeAutoCenter;
-        if (!shouldSkipTransformOrigin) applyTransformOrigin(entry.polygons);
-        if (entry.stableDom && !entry.hasBuckets) {
-          const renderOptions = {
+        if (applyStableTopologyUpdate(options, shouldRecomputeAutoCenter)) return;
+        renderEntry(entry);
+        if (shouldRecomputeAutoCenter) recomputeAutoCenter();
+      },
+      [POLY_ANIMATION_TRIANGLE_FRAME_TARGET](
+        frame: PolyAnimationTriangleFrame,
+        options?: InternalSetPolygonsOptions,
+      ) {
+        const nextMergeOnUpdate = options?.merge ?? mergeOnUpdate;
+        const nextStableDomOnUpdate = options?.stableDom ?? stableDomOnUpdate;
+        if (
+          !frame.solidTriangles ||
+          !nextStableDomOnUpdate ||
+          nextMergeOnUpdate ||
+          transformIn.meshResolution !== undefined ||
+          entry.hasBuckets ||
+          frame.polygonCount !== entry.polygons.length ||
+          frame.vertices.length < frame.polygonCount * 9 ||
+          entry.rendered.length !== frame.polygonCount
+        ) {
+          return false;
+        }
+        for (let i = 0; i < entry.rendered.length; i++) {
+          const rendered = entry.rendered[i];
+          const polygon = entry.polygons[i];
+          if (
+            rendered?.kind !== "triangle" ||
+            rendered.polygonIndex !== i ||
+            !polygon ||
+            polygon.vertices.length !== 3 ||
+            polygon.texture ||
+            polygon.material?.texture
+          ) {
+            return false;
+          }
+        }
+
+        const shouldRecomputeAutoCenter = options?.recomputeAutoCenter ?? true;
+        if (!shouldRecomputeAutoCenter) {
+          const colorFrame = entry.stableTriangleColorFrame + 1;
+          const stableTopologyOptions = {
             doc,
             directionalLight: currentOptions.directionalLight,
             ambientLight: currentOptions.ambientLight,
             textureLighting: currentOptions.textureLighting,
             textureQuality: currentOptions.textureQuality,
-          };
-          const allStableTriangles =
-            entry.rendered.length === entry.polygons.length &&
-            entry.rendered.every((item) => item.kind === "triangle");
-          const optimizeStableTopology =
-            entry.stableDom && !shouldRecomputeAutoCenter;
-          const solidPaintDefaults = allStableTriangles || optimizeStableTopology
-            ? {}
-            : getSolidPaintDefaults(entry.polygons, renderOptions);
-          if (!allStableTriangles) applySolidPaintVars(entry.wrapper, solidPaintDefaults);
-          const stableTopologyOptions = {
-            ...renderOptions,
-            solidPaintDefaults,
+            solidPaintDefaults: {},
             optimizeStableTriangleStyle: true,
             stableTriangleDebug: options?.stableTriangleDebug,
             stableTriangleUpdateMode: options?.stableTriangleUpdateMode,
@@ -1466,8 +1621,8 @@ export function createPolyScene(
             stableTriangleColorMaxAge: options?.stableTriangleColorMaxAge,
             stableTriangleColorMaxStep: options?.stableTriangleColorMaxStep,
             stableTriangleMatrixDecimals: options?.stableTriangleMatrixDecimals,
-            stableTriangleColorFrame: entry.stableTriangleColorFrame,
-          } as Parameters<typeof updatePolygonsWithStableTopology>[2] & {
+            stableTriangleColorFrame: colorFrame,
+          } as Parameters<typeof updateStableTriangleFrame>[3] & {
             optimizeStableTriangleStyle: boolean;
             stableTriangleDebug?: "transform-only" | "plan-only";
             stableTriangleUpdateMode?: "full" | "transform-only" | "color-only";
@@ -1481,29 +1636,68 @@ export function createPolyScene(
             stableTriangleColorFrame?: number;
           };
           if (
-            updatePolygonsWithStableTopology(
+            updateStableTriangleFrame(
               entry.rendered,
               entry.polygons,
+              frame,
               stableTopologyOptions,
             )
           ) {
-            if (!colorOnlyStableTriangleUpdate) {
-              recomputeCameraCullGroups(entry);
-              syncMountedRenderedForCameraChange(entry, true);
-              if (shouldRecomputeAutoCenter) recomputeAutoCenter();
-            }
-            return;
+            polygonUpdateVersion++;
+            mergeOnUpdate = nextMergeOnUpdate;
+            stableDomOnUpdate = nextStableDomOnUpdate;
+            entry.stableDom = stableDomOnUpdate;
+            entry.voxelSource = undefined;
+            entry.stableTriangleColorFrame = colorFrame;
+            currentTriangleFrame = frame;
+            currentTriangleFrameVersion++;
+            materializedTriangleFramePolygons = null;
+            materializedTriangleFrameVersion = -1;
+            recomputeCameraCullGroups(entry);
+            syncMountedRenderedForCameraChange(entry, true);
+            return true;
           }
         }
-        if (shouldSkipTransformOrigin) applyTransformOrigin(entry.polygons);
-        renderEntry(entry);
-        if (shouldRecomputeAutoCenter) recomputeAutoCenter();
+
+        polygonUpdateVersion++;
+        mergeOnUpdate = nextMergeOnUpdate;
+        stableDomOnUpdate = nextStableDomOnUpdate;
+        entry.stableDom = stableDomOnUpdate;
+        entry.voxelSource = undefined;
+
+        const values = frame.vertices;
+        for (let polygonIndex = 0; polygonIndex < frame.polygonCount; polygonIndex++) {
+          const polygon = entry.polygons[polygonIndex]!;
+          const color = frame.colors?.[polygonIndex];
+          if (color) polygon.color = color;
+          const vertices = polygon.vertices;
+          const offset = polygonIndex * 9;
+          vertices[0]![0] = values[offset]!;
+          vertices[0]![1] = values[offset + 1]!;
+          vertices[0]![2] = values[offset + 2]!;
+          vertices[1]![0] = values[offset + 3]!;
+          vertices[1]![1] = values[offset + 4]!;
+          vertices[1]![2] = values[offset + 5]!;
+          vertices[2]![0] = values[offset + 6]!;
+          vertices[2]![1] = values[offset + 7]!;
+          vertices[2]![2] = values[offset + 8]!;
+        }
+        clearCurrentTriangleFrame();
+        handle.polygons = entry.polygons;
+        return applyStableTopologyUpdate(
+          options,
+          shouldRecomputeAutoCenter,
+        );
       },
       updatePolygon(target: Polygon | number, partial: Partial<Polygon>) {
-        const idx = typeof target === "number"
+        let idx = typeof target === "number"
           ? target
           : entry.polygons.indexOf(target);
+        if (idx < 0 && typeof target !== "number" && currentTriangleFrame) {
+          idx = currentPolygons().indexOf(target);
+        }
         if (idx < 0 || idx >= entry.polygons.length) return;
+        clearCurrentTriangleFrame();
         entry.voxelSource = undefined;
         Object.assign(entry.polygons[idx], partial);
         renderEntry(entry);
@@ -1519,6 +1713,7 @@ export function createPolyScene(
         entry.stableDom = stableDomOnUpdate;
         entry.voxelSource = undefined;
         entry.polygons = preparePolygons(polygons, mergeOnUpdate);
+        clearCurrentTriangleFrame();
         handle.polygons = entry.polygons;
         applyTransformOrigin(entry.polygons);
         const shouldRecomputeAutoCenter = options?.recomputeAutoCenter ?? true;
diff --git a/packages/polycss/src/render/textureAtlas.ts b/packages/polycss/src/render/textureAtlas.ts
index 325fae94..54c7ffbf 100644
--- a/packages/polycss/src/render/textureAtlas.ts
+++ b/packages/polycss/src/render/textureAtlas.ts
@@ -150,6 +150,8 @@ interface SolidTriangleBasis {
 interface SolidTriangleComputeOptions {
   basis?: SolidTriangleBasis;
   includeColor?: boolean;
+  matrixDecimals?: number;
+  color?: string;
 }
 
 interface SolidTriangleElement extends HTMLElement {
@@ -158,6 +160,8 @@ interface SolidTriangleElement extends HTMLElement {
   __polycssSolidTriangleColorRgb?: RGB;
   __polycssSolidTriangleColorAlpha?: number;
   __polycssSolidTriangleColorFrame?: number;
+  __polycssSolidTriangleHidden?: boolean;
+  __polycssHasDataAttrs?: boolean;
 }
 
 interface StableTriangleColorState {
@@ -167,6 +171,12 @@ interface StableTriangleColorState {
   maxStep: number;
 }
 
+export interface SolidTriangleFrame {
+  polygonCount: number;
+  vertices: ArrayLike<number>;
+  colors?: readonly (string | undefined)[];
+}
+
 export interface SolidPaintDefaults {
   paintColor?: string;
   dynamicColor?: { r: number; g: number; b: number };
@@ -303,6 +313,13 @@ const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
 const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = Number.POSITIVE_INFINITY;
 const PROJECTIVE_QUAD_BLEED = 0.6;
 
+function stableTriangleMatrixDecimals(options: InternalRenderTextureAtlasOptions): number {
+  return Math.max(
+    0,
+    Math.min(6, Math.floor(options.stableTriangleMatrixDecimals ?? DEFAULT_MATRIX_DECIMALS)),
+  );
+}
+
 interface BorderShapeBounds {
   minX: number;
   minY: number;
@@ -398,10 +415,94 @@ function formatAffineMatrix3dColumns(
   txCol: Vec3,
   decimals = DEFAULT_MATRIX_DECIMALS,
 ): string {
-  return `${roundDecimal(xCol[0], decimals)},${roundDecimal(xCol[1], decimals)},${roundDecimal(xCol[2], decimals)},0,` +
-    `${roundDecimal(yCol[0], decimals)},${roundDecimal(yCol[1], decimals)},${roundDecimal(yCol[2], decimals)},0,` +
-    `${roundDecimal(zCol[0], decimals)},${roundDecimal(zCol[1], decimals)},${roundDecimal(zCol[2], decimals)},0,` +
-    `${roundDecimal(txCol[0], decimals)},${roundDecimal(txCol[1], decimals)},${roundDecimal(txCol[2], decimals)},1`;
+  return formatAffineMatrix3dScalars(
+    xCol[0], xCol[1], xCol[2],
+    yCol[0], yCol[1], yCol[2],
+    zCol[0], zCol[1], zCol[2],
+    txCol[0], txCol[1], txCol[2],
+    decimals,
+  );
+}
+
+function formatAffineMatrix3dScalars(
+  x0: number,
+  x1: number,
+  x2: number,
+  y0: number,
+  y1: number,
+  y2: number,
+  z0: number,
+  z1: number,
+  z2: number,
+  tx0: number,
+  tx1: number,
+  tx2: number,
+  decimals = DEFAULT_MATRIX_DECIMALS,
+): string {
+  if (decimals === 3) {
+    const rx0 = Math.round(x0 * 1000) / 1000 || 0;
+    const rx1 = Math.round(x1 * 1000) / 1000 || 0;
+    const rx2 = Math.round(x2 * 1000) / 1000 || 0;
+    const ry0 = Math.round(y0 * 1000) / 1000 || 0;
+    const ry1 = Math.round(y1 * 1000) / 1000 || 0;
+    const ry2 = Math.round(y2 * 1000) / 1000 || 0;
+    const rz0 = Math.round(z0 * 1000) / 1000 || 0;
+    const rz1 = Math.round(z1 * 1000) / 1000 || 0;
+    const rz2 = Math.round(z2 * 1000) / 1000 || 0;
+    const rtx0 = Math.round(tx0 * 1000) / 1000 || 0;
+    const rtx1 = Math.round(tx1 * 1000) / 1000 || 0;
+    const rtx2 = Math.round(tx2 * 1000) / 1000 || 0;
+    return `${rx0},${rx1},${rx2},0,` +
+      `${ry0},${ry1},${ry2},0,` +
+      `${rz0},${rz1},${rz2},0,` +
+      `${rtx0},${rtx1},${rtx2},1`;
+  }
+  return `${roundDecimal(x0, decimals)},${roundDecimal(x1, decimals)},${roundDecimal(x2, decimals)},0,` +
+    `${roundDecimal(y0, decimals)},${roundDecimal(y1, decimals)},${roundDecimal(y2, decimals)},0,` +
+    `${roundDecimal(z0, decimals)},${roundDecimal(z1, decimals)},${roundDecimal(z2, decimals)},0,` +
+    `${roundDecimal(tx0, decimals)},${roundDecimal(tx1, decimals)},${roundDecimal(tx2, decimals)},1`;
+}
+
+function formatAffineMatrix3dTransformScalars(
+  x0: number,
+  x1: number,
+  x2: number,
+  y0: number,
+  y1: number,
+  y2: number,
+  z0: number,
+  z1: number,
+  z2: number,
+  tx0: number,
+  tx1: number,
+  tx2: number,
+  decimals = DEFAULT_MATRIX_DECIMALS,
+): string {
+  if (decimals !== 3) {
+    return `matrix3d(${formatAffineMatrix3dScalars(
+      x0, x1, x2,
+      y0, y1, y2,
+      z0, z1, z2,
+      tx0, tx1, tx2,
+      decimals,
+    )})`;
+  }
+  const rx0 = Math.round(x0 * 1000) / 1000 || 0;
+  const rx1 = Math.round(x1 * 1000) / 1000 || 0;
+  const rx2 = Math.round(x2 * 1000) / 1000 || 0;
+  const ry0 = Math.round(y0 * 1000) / 1000 || 0;
+  const ry1 = Math.round(y1 * 1000) / 1000 || 0;
+  const ry2 = Math.round(y2 * 1000) / 1000 || 0;
+  const rz0 = Math.round(z0 * 1000) / 1000 || 0;
+  const rz1 = Math.round(z1 * 1000) / 1000 || 0;
+  const rz2 = Math.round(z2 * 1000) / 1000 || 0;
+  const rtx0 = Math.round(tx0 * 1000) / 1000 || 0;
+  const rtx1 = Math.round(tx1 * 1000) / 1000 || 0;
+  const rtx2 = Math.round(tx2 * 1000) / 1000 || 0;
+  return `matrix3d(${rx0},${rx1},${rx2},0,` +
+    `${ry0},${ry1},${ry2},0,` +
+    `${rz0},${rz1},${rz2},0,` +
+    `${rtx0},${rtx1},${rtx2},1)`;
 }
 
 function isConvexPolygonPoints(points: Array<[number, number]>): boolean {
@@ -532,47 +633,171 @@ function offsetTrianglePoints(
 ): number[] {
   if (amount <= 0) return [x0, y0, x1, y1, x2, y2];
   const area = (x0 * y1 - y0 * x1 + x1 * y2 - y1 * x2 + x2 * y0 - y2 * x0) / 2;
-  if (Math.abs(area) <= BASIS_EPS) return expandClipPoints([x0, y0, x1, y1, x2, y2], amount);
+  const fallback = () => expandClipPoints([x0, y0, x1, y1, x2, y2], amount);
+  if (Math.abs(area) <= BASIS_EPS) return fallback();
 
   const outwardSign = area > 0 ? 1 : -1;
-  const line = (ax: number, ay: number, bx: number, by: number) => {
-    const dx = bx - ax;
-    const dy = by - ay;
-    const length = Math.hypot(dx, dy);
-    if (length <= BASIS_EPS) return null;
-    const ox = outwardSign * (dy / length) * amount;
-    const oy = outwardSign * (-dx / length) * amount;
-    return {
-      ax: ax + ox,
-      ay: ay + oy,
-      bx: bx + ox,
-      by: by + oy,
-    };
-  };
 
-  const l0 = line(x0, y0, x1, y1);
-  const l1 = line(x1, y1, x2, y2);
-  const l2 = line(x2, y2, x0, y0);
-  if (!l0 || !l1 || !l2) return expandClipPoints([x0, y0, x1, y1, x2, y2], amount);
+  const dx0 = x1 - x0;
+  const dy0 = y1 - y0;
+  const len0 = Math.sqrt(dx0 * dx0 + dy0 * dy0);
+  const dx1 = x2 - x1;
+  const dy1 = y2 - y1;
+  const len1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+  const dx2 = x0 - x2;
+  const dy2 = y0 - y2;
+  const len2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+  if (len0 <= BASIS_EPS || len1 <= BASIS_EPS || len2 <= BASIS_EPS) return fallback();
+
+  const ox0 = outwardSign * (dy0 / len0) * amount;
+  const oy0 = outwardSign * (-dx0 / len0) * amount;
+  const l0ax = x0 + ox0;
+  const l0ay = y0 + oy0;
+  const l0bx = x1 + ox0;
+  const l0by = y1 + oy0;
+
+  const ox1 = outwardSign * (dy1 / len1) * amount;
+  const oy1 = outwardSign * (-dx1 / len1) * amount;
+  const l1ax = x1 + ox1;
+  const l1ay = y1 + oy1;
+  const l1bx = x2 + ox1;
+  const l1by = y2 + oy1;
+
+  const ox2 = outwardSign * (dy2 / len2) * amount;
+  const oy2 = outwardSign * (-dx2 / len2) * amount;
+  const l2ax = x2 + ox2;
+  const l2ay = y2 + oy2;
+  const l2bx = x0 + ox2;
+  const l2by = y0 + oy2;
+
+  const r0x = l2bx - l2ax;
+  const r0y = l2by - l2ay;
+  const s0x = l0bx - l0ax;
+  const s0y = l0by - l0ay;
+  const det0 = r0x * s0y - r0y * s0x;
+  if (Math.abs(det0) <= BASIS_EPS) return fallback();
+  const q0x = l0ax - l2ax;
+  const q0y = l0ay - l2ay;
+  const t0 = (q0x * s0y - q0y * s0x) / det0;
+  let p0x = l2ax + t0 * r0x;
+  let p0y = l2ay + t0 * r0y;
+
+  const r1x = l0bx - l0ax;
+  const r1y = l0by - l0ay;
+  const s1x = l1bx - l1ax;
+  const s1y = l1by - l1ay;
+  const det1 = r1x * s1y - r1y * s1x;
+  if (Math.abs(det1) <= BASIS_EPS) return fallback();
+  const q1x = l1ax - l0ax;
+  const q1y = l1ay - l0ay;
+  const t1 = (q1x * s1y - q1y * s1x) / det1;
+  let p1x = l0ax + t1 * r1x;
+  let p1y = l0ay + t1 * r1y;
+
+  const r2x = l1bx - l1ax;
+  const r2y = l1by - l1ay;
+  const s2x = l2bx - l2ax;
+  const s2y = l2by - l2ay;
+  const det2 = r2x * s2y - r2y * s2x;
+  if (Math.abs(det2) <= BASIS_EPS) return fallback();
+  const q2x = l2ax - l1ax;
+  const q2y = l2ay - l1ay;
+  const t2 = (q2x * s2y - q2y * s2x) / det2;
+  let p2x = l1ax + t2 * r2x;
+  let p2y = l1ay + t2 * r2y;
+
+  const maxMiter = Math.max(2, amount * 4);
+  const m0x = p0x - x0;
+  const m0y = p0y - y0;
+  const m0 = Math.sqrt(m0x * m0x + m0y * m0y);
+  if (m0 > maxMiter) {
+    p0x = x0 + (m0x / m0) * maxMiter;
+    p0y = y0 + (m0y / m0) * maxMiter;
+  }
+  const m1x = p1x - x1;
+  const m1y = p1y - y1;
+  const m1 = Math.sqrt(m1x * m1x + m1y * m1y);
+  if (m1 > maxMiter) {
+    p1x = x1 + (m1x / m1) * maxMiter;
+    p1y = y1 + (m1y / m1) * maxMiter;
+  }
+  const m2x = p2x - x2;
+  const m2y = p2y - y2;
+  const m2 = Math.sqrt(m2x * m2x + m2y * m2y);
+  if (m2 > maxMiter) {
+    p2x = x2 + (m2x / m2) * maxMiter;
+    p2y = y2 + (m2y / m2) * maxMiter;
+  }
+
+  return [p0x, p0y, p1x, p1y, p2x, p2y];
+}
 
-  const p0 = intersect2DLinesRaw(l2.ax, l2.ay, l2.bx, l2.by, l0.ax, l0.ay, l0.bx, l0.by);
-  const p1 = intersect2DLinesRaw(l0.ax, l0.ay, l0.bx, l0.by, l1.ax, l1.ay, l1.bx, l1.by);
-  const p2 = intersect2DLinesRaw(l1.ax, l1.ay, l1.bx, l1.by, l2.ax, l2.ay, l2.bx, l2.by);
-  if (!p0 || !p1 || !p2) return expandClipPoints([x0, y0, x1, y1, x2, y2], amount);
+function offsetStableTrianglePoints(
+  left: number,
+  right: number,
+  height: number,
+  amount: number,
+): number[] {
+  const baseWidth = left + right;
+  if (
+    amount <= 0 ||
+    height <= BASIS_EPS ||
+    baseWidth <= BASIS_EPS ||
+    !Number.isFinite(left + right + height + amount)
+  ) {
+    return offsetTrianglePoints(left, 0, 0, height, baseWidth, height, amount);
+  }
+
+  const leftLen = Math.sqrt(left * left + height * height);
+  const rightLen = Math.sqrt(right * right + height * height);
+  if (leftLen <= BASIS_EPS || rightLen <= BASIS_EPS) {
+    return offsetTrianglePoints(left, 0, 0, height, baseWidth, height, amount);
+  }
+
+  const leftOffsetX = -amount * height / leftLen;
+  const leftOffsetY = -amount * left / leftLen;
+  const rightOffsetX = amount * height / rightLen;
+  const rightOffsetY = -amount * right / rightLen;
+  const apexLineLeftX = left + leftOffsetX;
+  const apexLineLeftY = leftOffsetY;
+  const apexLineRightX = baseWidth + rightOffsetX;
+  const apexLineRightY = height + rightOffsetY;
+  const det = -height * baseWidth;
+  if (Math.abs(det) <= BASIS_EPS) {
+    return offsetTrianglePoints(left, 0, 0, height, baseWidth, height, amount);
+  }
+
+  const qx = apexLineLeftX - apexLineRightX;
+  const qy = apexLineLeftY - apexLineRightY;
+  const t = (qx * height + qy * left) / det;
+  let apexX = apexLineRightX - t * right;
+  let apexY = apexLineRightY - t * height;
+  let baseLeftX = -amount * (left + leftLen) / height;
+  let baseLeftY = height + amount;
+  let baseRightX = baseWidth + amount * (right + rightLen) / height;
+  let baseRightY = baseLeftY;
 
   const maxMiter = Math.max(2, amount * 4);
-  const clamp = (px: number, py: number, ox: number, oy: number): Vec2 => {
-    const dx = px - ox;
-    const dy = py - oy;
-    const miter = Math.hypot(dx, dy);
-    return miter > maxMiter
-      ? [ox + (dx / miter) * maxMiter, oy + (dy / miter) * maxMiter]
-      : [px, py];
-  };
-  const c0 = clamp(p0[0], p0[1], x0, y0);
-  const c1 = clamp(p1[0], p1[1], x1, y1);
-  const c2 = clamp(p2[0], p2[1], x2, y2);
-  return [c0[0], c0[1], c1[0], c1[1], c2[0], c2[1]];
+  const apexDx = apexX - left;
+  const apexDy = apexY;
+  const apexMiter = Math.sqrt(apexDx * apexDx + apexDy * apexDy);
+  if (apexMiter > maxMiter) {
+    apexX = left + (apexDx / apexMiter) * maxMiter;
+    apexY = (apexDy / apexMiter) * maxMiter;
+  }
+  const leftMiter = Math.sqrt(baseLeftX * baseLeftX + amount * amount);
+  if (leftMiter > maxMiter) {
+    baseLeftX = (baseLeftX / leftMiter) * maxMiter;
+    baseLeftY = height + (amount / leftMiter) * maxMiter;
+  }
+  const rightDx = baseRightX - baseWidth;
+  const rightMiter = Math.sqrt(rightDx * rightDx + amount * amount);
+  if (rightMiter > maxMiter) {
+    baseRightX = baseWidth + (rightDx / rightMiter) * maxMiter;
+    baseRightY = height + (amount / rightMiter) * maxMiter;
+  }
+
+  return [apexX, apexY, baseLeftX, baseLeftY, baseRightX, baseRightY];
 }
 
 function finiteNumber(value: unknown, fallback: number): number {
@@ -1910,9 +2135,12 @@ function computeTextureAtlasPlan(
 function computeSolidTriangleColorPlanFromNormal(
   polygon: Polygon,
   index: number,
-  normal: Vec3,
+  nx: number,
+  ny: number,
+  nz: number,
   options: RenderTextureAtlasOptions,
   includeColor: boolean,
+  colorOverride?: string,
 ): SolidTriangleColorPlan {
   const internalOptions = options as InternalRenderTextureAtlasOptions;
   let bakedColorValue = "";
@@ -1920,6 +2148,7 @@ function computeSolidTriangleColorPlanFromNormal(
   let bakedAlpha: number | undefined;
   let dynamicVars = "";
   if (includeColor) {
+    const baseColor = colorOverride ?? polygon.color ?? "#cccccc";
     const directionalCfg = options.directionalLight;
     const ambientCfg = options.ambientLight;
     const lightDir = directionalCfg?.direction ?? DEFAULT_LIGHT_DIR;
@@ -1929,13 +2158,13 @@ function computeSolidTriangleColorPlanFromNormal(
     const ambientIntensity = Math.max(0, ambientCfg?.intensity ?? DEFAULT_AMBIENT_INTENSITY);
     const lLen = Math.hypot(lightDir[0], lightDir[1], lightDir[2]) || 1;
     const lx = lightDir[0] / lLen, ly = lightDir[1] / lLen, lz = lightDir[2] / lLen;
-    const directScale = lightIntensity * Math.max(0, normal[0] * lx + normal[1] * ly + normal[2] * lz);
-    const shadedColorRaw = shadePolygon(polygon.color ?? "#cccccc", directScale, lightColor, ambientColor, ambientIntensity);
+    const directScale = lightIntensity * Math.max(0, nx * lx + ny * ly + nz * lz);
+    const shadedColorRaw = shadePolygon(baseColor, directScale, lightColor, ambientColor, ambientIntensity);
     const textureLighting = options.textureLighting ?? "baked";
     const shadedColor = textureLighting === "baked" && internalOptions.stableTriangleColorSteps
       ? quantizeCssColor(shadedColorRaw, internalOptions.stableTriangleColorSteps)
       : shadedColorRaw;
-    const base = parseHex(polygon.color ?? "#cccccc");
+    const base = parseHex(baseColor);
     const useDefaultPaint = shadedColor === options.solidPaintDefaults?.paintColor;
     const useDefaultDynamicColor =
       textureLighting === "dynamic" && rgbKey(base) === options.solidPaintDefaults?.dynamicColorKey;
@@ -1945,7 +2174,7 @@ function computeSolidTriangleColorPlanFromNormal(
     bakedRgb = bakedColorValue ? parseHex(bakedColorValue) : undefined;
     bakedAlpha = bakedColorValue ? parseAlpha(bakedColorValue) : undefined;
     dynamicVars = textureLighting === "dynamic"
-      ? `--pnx:${normal[0].toFixed(4)};--pny:${normal[1].toFixed(4)};--pnz:${normal[2].toFixed(4)};` +
+      ? `--pnx:${nx.toFixed(4)};--pny:${ny.toFixed(4)};--pnz:${nz.toFixed(4)};` +
         (useDefaultDynamicColor
           ? ""
           : `--psr:${(base.r / 255).toFixed(4)};--psg:${(base.g / 255).toFixed(4)};--psb:${(base.b / 255).toFixed(4)};`)
@@ -1985,12 +2214,12 @@ function computeSolidTriangleColorPlan(
   let nx = -(e10y * e20z - e10z * e20y);
   let ny = -(e10z * e20x - e10x * e20z);
   let nz = -(e10x * e20y - e10y * e20x);
-  const nLen = Math.hypot(nx, ny, nz);
+  const nLen = Math.sqrt(nx * nx + ny * ny + nz * nz);
   if (nLen <= BASIS_EPS) return null;
   nx /= nLen;
   ny /= nLen;
   nz /= nLen;
-  return computeSolidTriangleColorPlanFromNormal(polygon, index, [nx, ny, nz], options, true);
+  return computeSolidTriangleColorPlanFromNormal(polygon, index, nx, ny, nz, options, true);
 }
 
 function computeSolidTrianglePlan(
@@ -2001,32 +2230,67 @@ function computeSolidTrianglePlan(
 ): SolidTrianglePlan | null {
   if (polygon.texture || polygon.vertices.length !== 3) return null;
 
-  const internalOptions = options as InternalRenderTextureAtlasOptions;
   const tile = options.tileSize ?? DEFAULT_TILE;
   const elev = options.layerElevation ?? tile;
   const v0 = polygon.vertices[0];
   const v1 = polygon.vertices[1];
   const v2 = polygon.vertices[2];
-  const pts: Vec3[] = [
-    [v0[1] * tile, v0[0] * tile, v0[2] * elev],
-    [v1[1] * tile, v1[0] * tile, v1[2] * elev],
-    [v2[1] * tile, v2[0] * tile, v2[2] * elev],
-  ];
-  const e10x = pts[1][0] - pts[0][0];
-  const e10y = pts[1][1] - pts[0][1];
-  const e10z = pts[1][2] - pts[0][2];
-  const e20x = pts[2][0] - pts[0][0];
-  const e20y = pts[2][1] - pts[0][1];
-  const e20z = pts[2][2] - pts[0][2];
+  const p0x = v0[1] * tile;
+  const p0y = v0[0] * tile;
+  const p0z = v0[2] * elev;
+  const p1x = v1[1] * tile;
+  const p1y = v1[0] * tile;
+  const p1z = v1[2] * elev;
+  const p2x = v2[1] * tile;
+  const p2y = v2[0] * tile;
+  const p2z = v2[2] * elev;
+  return computeSolidTrianglePlanFromCssPoints(
+    polygon,
+    index,
+    options,
+    computeOptions,
+    p0x,
+    p0y,
+    p0z,
+    p1x,
+    p1y,
+    p1z,
+    p2x,
+    p2y,
+    p2z,
+  );
+}
+
+function computeSolidTrianglePlanFromCssPoints(
+  polygon: Polygon,
+  index: number,
+  options: RenderTextureAtlasOptions,
+  computeOptions: SolidTriangleComputeOptions,
+  p0x: number,
+  p0y: number,
+  p0z: number,
+  p1x: number,
+  p1y: number,
+  p1z: number,
+  p2x: number,
+  p2y: number,
+  p2z: number,
+): SolidTrianglePlan | null {
+  const internalOptions = options as InternalRenderTextureAtlasOptions;
+  const e10x = p1x - p0x;
+  const e10y = p1y - p0y;
+  const e10z = p1z - p0z;
+  const e20x = p2x - p0x;
+  const e20y = p2y - p0y;
+  const e20z = p2z - p0z;
   let nx = -(e10y * e20z - e10z * e20y);
   let ny = -(e10z * e20x - e10x * e20z);
   let nz = -(e10x * e20y - e10y * e20x);
-  const nLen = Math.hypot(nx, ny, nz);
+  const nLen = Math.sqrt(nx * nx + ny * ny + nz * nz);
   if (nLen <= BASIS_EPS) return null;
   nx /= nLen;
   ny /= nLen;
   nz /= nLen;
-  const normal: Vec3 = [nx, ny, nz];
 
   let basisHint = computeOptions.basis;
   let a = basisHint?.a ?? 0;
@@ -2042,23 +2306,48 @@ function computeSolidTrianglePlan(
     a = 0;
     b = 1;
     c = 2;
+  } else if (
+    !(
+      (a === 0 && b === 1 && c === 2) ||
+      (a === 1 && b === 2 && c === 0) ||
+      (a === 2 && b === 0 && c === 1)
+    )
+  ) {
+    basisHint = undefined;
+    a = 0;
+    b = 1;
+    c = 2;
   }
   const retryWithoutBasis = (): SolidTrianglePlan | null =>
     basisHint
-      ? computeSolidTrianglePlan(polygon, index, options, {
-          ...computeOptions,
-          basis: undefined,
-        })
+      ? computeSolidTrianglePlanFromCssPoints(
+          polygon,
+          index,
+          options,
+          {
+            ...computeOptions,
+            basis: undefined,
+          },
+          p0x,
+          p0y,
+          p0z,
+          p1x,
+          p1y,
+          p1z,
+          p2x,
+          p2y,
+          p2z,
+        )
       : null;
 
   if (!basisHint) {
     const len01Sq = e10x * e10x + e10y * e10y + e10z * e10z;
-    const e21x = pts[2][0] - pts[1][0];
-    const e21y = pts[2][1] - pts[1][1];
-    const e21z = pts[2][2] - pts[1][2];
-    const e02x = pts[0][0] - pts[2][0];
-    const e02y = pts[0][1] - pts[2][1];
-    const e02z = pts[0][2] - pts[2][2];
+    const e21x = p2x - p1x;
+    const e21y = p2y - p1y;
+    const e21z = p2z - p1z;
+    const e02x = p0x - p2x;
+    const e02y = p0y - p2y;
+    const e02z = p0z - p2z;
     const len12Sq = e21x * e21x + e21y * e21y + e21z * e21z;
     const len20Sq = e02x * e02x + e02y * e02y + e02z * e02z;
     let baseLengthSq = len01Sq;
@@ -2075,92 +2364,59 @@ function computeSolidTrianglePlan(
     }
   }
 
-  let av = pts[a];
-  let bv = pts[b];
-  const cv = pts[c];
-  let baseDx = bv[0] - av[0];
-  let baseDy = bv[1] - av[1];
-  let baseDz = bv[2] - av[2];
-  let baseLength = Math.hypot(baseDx, baseDy, baseDz);
+  let avx: number;
+  let avy: number;
+  let avz: number;
+  let bvx: number;
+  let bvy: number;
+  let bvz: number;
+  const cvx = c === 0 ? p0x : c === 1 ? p1x : p2x;
+  const cvy = c === 0 ? p0y : c === 1 ? p1y : p2y;
+  const cvz = c === 0 ? p0z : c === 1 ? p1z : p2z;
+  if (a === 0) {
+    avx = p0x; avy = p0y; avz = p0z;
+  } else if (a === 1) {
+    avx = p1x; avy = p1y; avz = p1z;
+  } else {
+    avx = p2x; avy = p2y; avz = p2z;
+  }
+  if (b === 0) {
+    bvx = p0x; bvy = p0y; bvz = p0z;
+  } else if (b === 1) {
+    bvx = p1x; bvy = p1y; bvz = p1z;
+  } else {
+    bvx = p2x; bvy = p2y; bvz = p2z;
+  }
+
+  let baseDx = bvx - avx;
+  let baseDy = bvy - avy;
+  let baseDz = bvz - avz;
+  let baseLength = Math.sqrt(baseDx * baseDx + baseDy * baseDy + baseDz * baseDz);
   if (baseLength <= BASIS_EPS) return retryWithoutBasis();
 
-  let xAxis: Vec3 = [
-    baseDx / baseLength,
-    baseDy / baseLength,
-    baseDz / baseLength,
-  ];
-  const ac: Vec3 = [cv[0] - av[0], cv[1] - av[1], cv[2] - av[2]];
-  let apexX = dotVec(ac, xAxis);
-  let foot: Vec3 = [
-    av[0] + xAxis[0] * apexX,
-    av[1] + xAxis[1] * apexX,
-    av[2] + xAxis[2] * apexX,
-  ];
-  let yAxisRaw: Vec3 = [
-    foot[0] - cv[0],
-    foot[1] - cv[1],
-    foot[2] - cv[2],
-  ];
-  let height = Math.hypot(yAxisRaw[0], yAxisRaw[1], yAxisRaw[2]);
+  let x0 = baseDx / baseLength;
+  let x1 = baseDy / baseLength;
+  let x2 = baseDz / baseLength;
+  let apexX = (cvx - avx) * x0 + (cvy - avy) * x1 + (cvz - avz) * x2;
+  let y0 = ny * x2 - nz * x1;
+  let y1 = nz * x0 - nx * x2;
+  let y2 = nx * x1 - ny * x0;
+  let height = nLen / baseLength;
   if (height <= BASIS_EPS) return retryWithoutBasis();
-  let yAxis: Vec3 = [
-    yAxisRaw[0] / height,
-    yAxisRaw[1] / height,
-    yAxisRaw[2] / height,
-  ];
-
-  if (dotVec(crossVec(xAxis, yAxis), normal) < 0) {
-    const nextA = b;
-    b = a;
-    a = nextA;
-    av = pts[a];
-    bv = pts[b];
-    baseDx = bv[0] - av[0];
-    baseDy = bv[1] - av[1];
-    baseDz = bv[2] - av[2];
-    baseLength = Math.hypot(baseDx, baseDy, baseDz);
-    if (baseLength <= BASIS_EPS) return retryWithoutBasis();
-    xAxis = [
-      baseDx / baseLength,
-      baseDy / baseLength,
-      baseDz / baseLength,
-    ];
-    const nextAc: Vec3 = [cv[0] - av[0], cv[1] - av[1], cv[2] - av[2]];
-    apexX = dotVec(nextAc, xAxis);
-    foot = [
-      av[0] + xAxis[0] * apexX,
-      av[1] + xAxis[1] * apexX,
-      av[2] + xAxis[2] * apexX,
-    ];
-    yAxisRaw = [
-      foot[0] - cv[0],
-      foot[1] - cv[1],
-      foot[2] - cv[2],
-    ];
-    height = Math.hypot(yAxisRaw[0], yAxisRaw[1], yAxisRaw[2]);
-    if (height <= BASIS_EPS) return retryWithoutBasis();
-    yAxis = [
-      yAxisRaw[0] / height,
-      yAxisRaw[1] / height,
-      yAxisRaw[2] / height,
-    ];
-  }
 
   const left = Math.max(0, Math.min(baseLength, apexX));
   const right = Math.max(0, baseLength - left);
-  const expanded = offsetTrianglePoints(
-    left, 0,
-    0, height,
-    left + right, height,
-    SOLID_TRIANGLE_BLEED,
-  );
-  const apex2: Vec2 = [expanded[0], expanded[1]];
-  const baseLeft2: Vec2 = [expanded[2], expanded[3]];
-  const baseRight2: Vec2 = [expanded[4], expanded[5]];
-  const baseY = (baseLeft2[1] + baseRight2[1]) / 2;
-  const leftPx = apex2[0] - baseLeft2[0];
-  const rightPx = baseRight2[0] - apex2[0];
-  const heightPx = baseY - apex2[1];
+  const expanded = offsetStableTrianglePoints(left, right, height, SOLID_TRIANGLE_BLEED);
+  const apex2x = expanded[0];
+  const apex2y = expanded[1];
+  const baseLeft2x = expanded[2];
+  const baseLeft2y = expanded[3];
+  const baseRight2x = expanded[4];
+  const baseRight2y = expanded[5];
+  const baseY = (baseLeft2y + baseRight2y) / 2;
+  const leftPx = apex2x - baseLeft2x;
+  const rightPx = baseRight2x - apex2x;
+  const heightPx = baseY - apex2y;
   if (
     leftPx <= BASIS_EPS ||
     rightPx <= BASIS_EPS ||
@@ -2169,59 +2425,54 @@ function computeSolidTrianglePlan(
   ) {
     return retryWithoutBasis();
   }
-  const colorPlan = computeSolidTriangleColorPlanFromNormal(
-    polygon,
-    index,
-    normal,
-    options,
-    computeOptions.includeColor ?? true,
-  );
-  const bakedColor = colorPlan.bakedColor ? `color:${colorPlan.bakedColor};` : "";
-  const dynamicVars = colorPlan.dynamicVars ?? "";
-  const cv0 = cv[0];
-  const cv1 = cv[1];
-  const cv2 = cv[2];
-  const apexOffsetX = apex2[0] - left;
-  const apexY = apex2[1];
-  const baseLeftOffsetX = baseLeft2[0] - left;
-  const baseRightOffsetX = baseRight2[0] - left;
-  const apex: Vec3 = [
-    cv0 + apexOffsetX * xAxis[0] + apexY * yAxis[0],
-    cv1 + apexOffsetX * xAxis[1] + apexY * yAxis[1],
-    cv2 + apexOffsetX * xAxis[2] + apexY * yAxis[2],
-  ];
-  const baseLeft: Vec3 = [
-    cv0 + baseLeftOffsetX * xAxis[0] + baseY * yAxis[0],
-    cv1 + baseLeftOffsetX * xAxis[1] + baseY * yAxis[1],
-    cv2 + baseLeftOffsetX * xAxis[2] + baseY * yAxis[2],
-  ];
-  const baseRight: Vec3 = [
-    cv0 + baseRightOffsetX * xAxis[0] + baseY * yAxis[0],
-    cv1 + baseRightOffsetX * xAxis[1] + baseY * yAxis[1],
-    cv2 + baseRightOffsetX * xAxis[2] + baseY * yAxis[2],
-  ];
-  const halfBase = SOLID_TRIANGLE_CANONICAL_SIZE / 2;
-  const xCol: Vec3 = [
-    (baseRight[0] - baseLeft[0]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-    (baseRight[1] - baseLeft[1]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-    (baseRight[2] - baseLeft[2]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-  ];
-  const txCol: Vec3 = [
-    apex[0] - xCol[0] * halfBase,
-    apex[1] - xCol[1] * halfBase,
-    apex[2] - xCol[2] * halfBase,
-  ];
-  const yCol: Vec3 = [
-    (baseLeft[0] - txCol[0]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-    (baseLeft[1] - txCol[1]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-    (baseLeft[2] - txCol[2]) / SOLID_TRIANGLE_CANONICAL_SIZE,
-  ];
-  const matrixDecimals = Math.max(
-    0,
-    Math.min(6, Math.floor(internalOptions.stableTriangleMatrixDecimals ?? DEFAULT_MATRIX_DECIMALS)),
+  const includeColor = computeOptions.includeColor ?? true;
+  let colorComputed = false;
+  let bakedColorValue: string | undefined;
+  let bakedRgb: RGB | undefined;
+  let bakedAlpha: number | undefined;
+  let dynamicVars = "";
+  if (includeColor) {
+    const colorPlan = computeSolidTriangleColorPlanFromNormal(
+      polygon,
+      index,
+      nx,
+      ny,
+      nz,
+      options,
+      true,
+      computeOptions.color,
+    );
+    colorComputed = colorPlan.colorComputed;
+    bakedColorValue = colorPlan.bakedColor;
+    bakedRgb = colorPlan.bakedRgb;
+    bakedAlpha = colorPlan.bakedAlpha;
+    dynamicVars = colorPlan.dynamicVars ?? "";
+  }
+  const bakedColor = bakedColorValue ? `color:${bakedColorValue};` : "";
+  const invCanonicalSize = 1 / SOLID_TRIANGLE_CANONICAL_SIZE;
+  const baseWidthPx = leftPx + rightPx;
+  const xScale = baseWidthPx * invCanonicalSize;
+  const yXScale = (rightPx - leftPx) * 0.5 * invCanonicalSize;
+  const yYScale = heightPx * invCanonicalSize;
+  const txXOffset = apex2x - left - baseWidthPx * 0.5;
+  const txYOffset = apex2y;
+  const xCol0 = x0 * xScale;
+  const xCol1 = x1 * xScale;
+  const xCol2 = x2 * xScale;
+  const yCol0 = x0 * yXScale + y0 * yYScale;
+  const yCol1 = x1 * yXScale + y1 * yYScale;
+  const yCol2 = x2 * yXScale + y2 * yYScale;
+  const txCol0 = cvx + x0 * txXOffset + y0 * txYOffset;
+  const txCol1 = cvy + x1 * txXOffset + y1 * txYOffset;
+  const txCol2 = cvz + x2 * txXOffset + y2 * txYOffset;
+  const matrixDecimals = computeOptions.matrixDecimals ?? stableTriangleMatrixDecimals(internalOptions);
+  const transformText = formatAffineMatrix3dTransformScalars(
+    xCol0, xCol1, xCol2,
+    yCol0, yCol1, yCol2,
+    nx, ny, nz,
+    txCol0, txCol1, txCol2,
+    matrixDecimals,
   );
-  const canonicalMatrix = formatAffineMatrix3dColumns(xCol, yCol, normal, txCol, matrixDecimals);
-  const transformText = `matrix3d(${canonicalMatrix})`;
   const textureLighting = options.textureLighting ?? "baked";
   const optimizeStyleText =
     internalOptions.optimizeStableTriangleStyle === true &&
@@ -2230,17 +2481,20 @@ function computeSolidTrianglePlan(
     ? ""
     : `transform:${transformText};` + bakedColor + dynamicVars;
 
+  const basis = basisHint && basisHint.a === a && basisHint.b === b && basisHint.c === c
+    ? basisHint
+    : { a, b, c };
   return {
     index,
     polygon,
     styleText,
     transformText,
-    basis: { a, b, c },
-    colorComputed: colorPlan.colorComputed,
-    bakedColor: colorPlan.bakedColor,
-    bakedRgb: colorPlan.bakedRgb,
-    bakedAlpha: colorPlan.bakedAlpha,
-    dynamicVars: colorPlan.dynamicVars,
+    basis,
+    colorComputed,
+    bakedColor: bakedColorValue,
+    bakedRgb,
+    bakedAlpha,
+    dynamicVars,
   };
 }
 
@@ -2758,6 +3012,11 @@ function applyPolygonDataAttrs(el: HTMLElement, polygon: Polygon): void {
     }
   }
   ELEMENT_DATA_KEYS.set(el, nextDataKeys);
+  (el as SolidTriangleElement).__polycssHasDataAttrs = nextDataKeys.length > 0;
+}
+
+function hasPolygonDataAttrs(el: HTMLElement): boolean {
+  return (el as SolidTriangleElement).__polycssHasDataAttrs === true;
 }
 
 function formatScaledMatrixFromPlan(
@@ -3617,13 +3876,14 @@ function applySolidTriangleElement(
   el.setAttribute("style", entry.styleText);
   const triangleEl = el as SolidTriangleElement;
   triangleEl.__polycssSolidTriangleBasis = entry.basis;
+  triangleEl.__polycssSolidTriangleHidden = false;
   if (entry.colorComputed) {
     triangleEl.__polycssSolidTriangleColor = entry.bakedColor ?? "";
     triangleEl.__polycssSolidTriangleColorRgb = entry.bakedRgb;
     triangleEl.__polycssSolidTriangleColorAlpha = entry.bakedAlpha;
   }
   triangleEl.__polycssSolidTriangleColorFrame = undefined;
-  if (entry.polygon.data || ELEMENT_DATA_KEYS.get(el)?.length) {
+  if (entry.polygon.data || hasPolygonDataAttrs(el)) {
     applyPolygonDataAttrs(el, entry.polygon);
   }
 }
@@ -3635,7 +3895,7 @@ function applySolidTriangleElementColor(
   colorUpdateAllowed?: boolean,
 ): void {
   if (!entry.colorComputed) {
-    if (entry.polygon.data || ELEMENT_DATA_KEYS.get(el)?.length) {
+    if (entry.polygon.data || hasPolygonDataAttrs(el)) {
       applyPolygonDataAttrs(el, entry.polygon);
     }
     return;
@@ -3669,7 +3929,7 @@ function applySolidTriangleElementColor(
     triangleEl.__polycssSolidTriangleColorAlpha = nextAlpha;
     triangleEl.__polycssSolidTriangleColorFrame = colorState.colorFrame;
   }
-  if (entry.polygon.data || ELEMENT_DATA_KEYS.get(el)?.length) {
+  if (entry.polygon.data || hasPolygonDataAttrs(el)) {
     applyPolygonDataAttrs(el, entry.polygon);
   }
 }
@@ -3681,10 +3941,14 @@ function applySolidTriangleElementFast(
   colorUpdateAllowed?: boolean,
 ): void {
   const triangleEl = el as SolidTriangleElement;
-  triangleEl.__polycssSolidTriangleBasis = entry.basis;
-  if (el.style.visibility) el.style.visibility = "";
+  if (triangleEl.__polycssSolidTriangleBasis !== entry.basis) {
+    triangleEl.__polycssSolidTriangleBasis = entry.basis;
+  }
+  showSolidTriangleElement(el);
   el.style.transform = entry.transformText;
-  applySolidTriangleElementColor(el, entry, colorState, colorUpdateAllowed);
+  if (entry.colorComputed || entry.polygon.data || hasPolygonDataAttrs(el)) {
+    applySolidTriangleElementColor(el, entry, colorState, colorUpdateAllowed);
+  }
 }
 
 function applySolidTriangleElementColorOnly(
@@ -3693,7 +3957,7 @@ function applySolidTriangleElementColorOnly(
   colorState: StableTriangleColorState,
   colorUpdateAllowed?: boolean,
 ): void {
-  if (el.style.visibility) el.style.visibility = "";
+  showSolidTriangleElement(el);
   applySolidTriangleElementColor(el, entry, colorState, colorUpdateAllowed);
 }
 
@@ -3702,16 +3966,28 @@ function applySolidTriangleElementTransformOnly(
   entry: SolidTrianglePlan,
 ): void {
   const triangleEl = el as SolidTriangleElement;
-  triangleEl.__polycssSolidTriangleBasis = entry.basis;
-  if (el.style.visibility) el.style.visibility = "";
+  if (triangleEl.__polycssSolidTriangleBasis !== entry.basis) {
+    triangleEl.__polycssSolidTriangleBasis = entry.basis;
+  }
+  showSolidTriangleElement(el);
   el.style.transform = entry.transformText;
-  if (entry.polygon.data || ELEMENT_DATA_KEYS.get(el)?.length) {
+  if (entry.polygon.data || hasPolygonDataAttrs(el)) {
     applyPolygonDataAttrs(el, entry.polygon);
   }
 }
 
+function showSolidTriangleElement(el: HTMLElement): void {
+  const triangleEl = el as SolidTriangleElement;
+  if (!triangleEl.__polycssSolidTriangleHidden) return;
+  el.style.visibility = "";
+  triangleEl.__polycssSolidTriangleHidden = false;
+}
+
 function hideSolidTriangleElement(el: HTMLElement): void {
+  const triangleEl = el as SolidTriangleElement;
+  if (triangleEl.__polycssSolidTriangleHidden) return;
   el.style.visibility = "hidden";
+  triangleEl.__polycssSolidTriangleHidden = true;
 }
 
 function stableTriangleColorBudgetCount(
@@ -3789,6 +4065,185 @@ function createHiddenSolidTriangleElement(
   return el;
 }
 
+function updateStableTriangleElementsStreaming(
+  rendered: RenderedPoly[],
+  polygons: Polygon[],
+  options: RenderTextureAtlasOptions,
+  optimizeTriangleStyle: boolean,
+  stableTriangleUpdateMode: "full" | "transform-only" | "color-only" | "plan-only",
+  colorState: StableTriangleColorState,
+): boolean {
+  const internalOptions = options as InternalRenderTextureAtlasOptions;
+  const stableTriangleDebug = internalOptions.stableTriangleDebug;
+  const colorOnly = optimizeTriangleStyle && stableTriangleUpdateMode === "color-only";
+  if (internalOptions.stableTriangleColorPolicy === "adaptive") return false;
+  if (rendered.length !== polygons.length) return false;
+  const matrixDecimals = stableTriangleMatrixDecimals(internalOptions);
+
+  for (let i = 0; i < rendered.length; i++) {
+    const item = rendered[i];
+    if (item.kind !== "triangle" || item.polygonIndex !== i || !polygons[i]) return false;
+  }
+
+  for (let i = 0; i < rendered.length; i++) {
+    const element = rendered[i].element as SolidTriangleElement;
+    const polygon = polygons[i];
+    if (colorOnly) {
+      if (
+        shouldComputeStableTriangleColor(
+          element,
+          i,
+          optimizeTriangleStyle,
+          stableTriangleDebug,
+          internalOptions.stableTriangleColorPolicy,
+          colorState,
+        )
+      ) {
+        const plan = computeSolidTriangleColorPlan(polygon, i, options);
+        if (!plan) continue;
+        applySolidTriangleElementColorOnly(
+          element,
+          plan,
+          colorState,
+        );
+      }
+      continue;
+    }
+
+    const plan = computeSolidTrianglePlan(polygon, i, options, {
+      basis: element.__polycssSolidTriangleBasis,
+      matrixDecimals,
+      includeColor: stableTriangleUpdateMode !== "plan-only" &&
+        stableTriangleUpdateMode !== "transform-only" &&
+        shouldComputeStableTriangleColor(
+          element,
+          i,
+          optimizeTriangleStyle,
+          stableTriangleDebug,
+          internalOptions.stableTriangleColorPolicy,
+          colorState,
+        ),
+    });
+    if (!plan) {
+      hideSolidTriangleElement(element);
+      continue;
+    }
+    if (optimizeTriangleStyle && stableTriangleUpdateMode === "plan-only") {
+      continue;
+    } else if (optimizeTriangleStyle && stableTriangleUpdateMode === "transform-only") {
+      applySolidTriangleElementTransformOnly(element, plan);
+    } else if (optimizeTriangleStyle) {
+      applySolidTriangleElementFast(element, plan, colorState);
+    } else {
+      applySolidTriangleElement(element, plan);
+    }
+  }
+
+  return true;
+}
+
+export function updateStableTriangleFrame(
+  rendered: RenderedPoly[],
+  polygons: Polygon[],
+  frame: SolidTriangleFrame,
+  options: RenderTextureAtlasOptions = {},
+): boolean {
+  const textureLighting = options.textureLighting ?? "baked";
+  const internalOptions = options as InternalRenderTextureAtlasOptions;
+  const optimizeTriangleStyle =
+    internalOptions.optimizeStableTriangleStyle === true &&
+    textureLighting === "baked";
+  if (!optimizeTriangleStyle) return false;
+  if (internalOptions.stableTriangleColorPolicy === "adaptive") return false;
+  if (rendered.length !== frame.polygonCount || polygons.length !== frame.polygonCount) return false;
+  if (frame.vertices.length < frame.polygonCount * 9) return false;
+
+  const stableTriangleDebug = internalOptions.stableTriangleDebug;
+  const stableTriangleUpdateMode = internalOptions.stableTriangleUpdateMode ??
+    (stableTriangleDebug === "plan-only" || stableTriangleDebug === "transform-only"
+      ? stableTriangleDebug
+      : "full");
+  if (stableTriangleUpdateMode === "color-only") return false;
+
+  const matrixDecimals = stableTriangleMatrixDecimals(internalOptions);
+  const colorState = stableTriangleColorState(internalOptions);
+  const tile = options.tileSize ?? DEFAULT_TILE;
+  const elev = options.layerElevation ?? tile;
+
+  for (let i = 0; i < rendered.length; i++) {
+    const item = rendered[i];
+    const polygon = polygons[i];
+    if (
+      item.kind !== "triangle" ||
+      item.polygonIndex !== i ||
+      !polygon ||
+      polygon.vertices.length !== 3 ||
+      polygon.texture ||
+      polygon.material?.texture
+    ) {
+      return false;
+    }
+  }
+
+  const values = frame.vertices;
+  for (let i = 0; i < rendered.length; i++) {
+    const element = rendered[i].element as SolidTriangleElement;
+    const polygon = polygons[i]!;
+    const offset = i * 9;
+    const p0x = values[offset + 1]! * tile;
+    const p0y = values[offset]! * tile;
+    const p0z = values[offset + 2]! * elev;
+    const p1x = values[offset + 4]! * tile;
+    const p1y = values[offset + 3]! * tile;
+    const p1z = values[offset + 5]! * elev;
+    const p2x = values[offset + 7]! * tile;
+    const p2y = values[offset + 6]! * tile;
+    const p2z = values[offset + 8]! * elev;
+    const plan = computeSolidTrianglePlanFromCssPoints(
+      polygon,
+      i,
+      options,
+      {
+        basis: element.__polycssSolidTriangleBasis,
+        matrixDecimals,
+        color: frame.colors?.[i],
+        includeColor: stableTriangleUpdateMode !== "plan-only" &&
+          stableTriangleUpdateMode !== "transform-only" &&
+          shouldComputeStableTriangleColor(
+            element,
+            i,
+            optimizeTriangleStyle,
+            stableTriangleDebug,
+            internalOptions.stableTriangleColorPolicy,
+            colorState,
+          ),
+      },
+      p0x,
+      p0y,
+      p0z,
+      p1x,
+      p1y,
+      p1z,
+      p2x,
+      p2y,
+      p2z,
+    );
+    if (!plan) {
+      hideSolidTriangleElement(element);
+      continue;
+    }
+    if (stableTriangleUpdateMode === "plan-only") {
+      continue;
+    } else if (stableTriangleUpdateMode === "transform-only") {
+      applySolidTriangleElementTransformOnly(element, plan);
+    } else {
+      applySolidTriangleElementFast(element, plan, colorState);
+    }
+  }
+
+  return true;
+}
+
 export function renderPolygonsWithStableTriangles(
   polygons: Polygon[],
   options: RenderTextureAtlasOptions = {},
@@ -3799,11 +4254,12 @@ export function renderPolygonsWithStableTriangles(
   if (polygons.some((polygon) => polygon.texture || polygon.vertices.length !== 3)) {
     return null;
   }
+  const matrixDecimals = stableTriangleMatrixDecimals(options as InternalRenderTextureAtlasOptions);
   const rendered: RenderedPoly[] = [];
 
   for (let i = 0; i < polygons.length; i += 1) {
     const polygon = polygons[i];
-    const plan = computeSolidTrianglePlan(polygon, i, options);
+    const plan = computeSolidTrianglePlan(polygon, i, options, { matrixDecimals });
     const element = plan
       ? createSolidTriangleElement(plan, doc)
       : createHiddenSolidTriangleElement(polygon, doc);
@@ -3841,6 +4297,22 @@ export function updatePolygonsWithStableTriangles(
       : "full");
   const colorOnly = optimizeTriangleStyle && stableTriangleUpdateMode === "color-only";
   const colorState = stableTriangleColorState(internalOptions);
+  const matrixDecimals = stableTriangleMatrixDecimals(internalOptions);
+  if (
+    updateStableTriangleElementsStreaming(
+      rendered,
+      polygons,
+      options,
+      optimizeTriangleStyle,
+      stableTriangleUpdateMode,
+      colorState,
+    )
+  ) {
+    return {
+      rendered,
+      dispose() {},
+    };
+  }
   const nextTrianglePlans: Array<SolidTrianglePlan | null> = new Array(rendered.length);
   const nextTriangleColorPlans: Array<SolidTriangleColorPlan | null> = new Array(rendered.length);
   for (let i = 0; i < rendered.length; i++) {
@@ -3862,6 +4334,7 @@ export function updatePolygonsWithStableTriangles(
     }
     nextTrianglePlans[i] = computeSolidTrianglePlan(polygons[i], i, options, {
       basis: element.__polycssSolidTriangleBasis,
+      matrixDecimals,
       includeColor: stableTriangleUpdateMode !== "plan-only" &&
         stableTriangleUpdateMode !== "transform-only" &&
         shouldComputeStableTriangleColor(
@@ -3954,6 +4427,19 @@ export function updatePolygonsWithStableTopology(
       : "full");
   const colorOnly = optimizeTriangleStyle && stableTriangleUpdateMode === "color-only";
   const colorState = stableTriangleColorState(internalOptions);
+  const matrixDecimals = stableTriangleMatrixDecimals(internalOptions);
+  if (
+    updateStableTriangleElementsStreaming(
+      rendered,
+      polygons,
+      options,
+      optimizeTriangleStyle,
+      stableTriangleUpdateMode,
+      colorState,
+    )
+  ) {
+    return true;
+  }
   const nextTrianglePlans: Array<SolidTrianglePlan | null> = [];
   const nextTriangleColorPlans: Array<SolidTriangleColorPlan | null> = [];
   const nextTexturePlans: Array<TextureAtlasPlan | null> = [];
@@ -3992,6 +4478,7 @@ export function updatePolygonsWithStableTopology(
       }
       const plan = computeSolidTrianglePlan(polygon, i, options, {
         basis: element.__polycssSolidTriangleBasis,
+        matrixDecimals,
         includeColor: stableTriangleUpdateMode !== "plan-only" &&
           stableTriangleUpdateMode !== "transform-only" &&
           shouldComputeStableTriangleColor(
diff --git a/packages/react/src/scene/PolyMesh.tsx b/packages/react/src/scene/PolyMesh.tsx
index 2613186f..a398a170 100644
--- a/packages/react/src/scene/PolyMesh.tsx
+++ b/packages/react/src/scene/PolyMesh.tsx
@@ -633,6 +633,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
         ambientLight: effectiveAmbient,
         textureLighting: effectiveTextureLighting,
         colorFrame: ++stableTriangleColorFrameRef.current,
+        colorSteps: 8,
         colorFreezeFrames: 12,
         colorMaxStep: 8,
       })
diff --git a/packages/react/src/scene/textureAtlas.tsx b/packages/react/src/scene/textureAtlas.tsx
index e0f9d3ab..a6945d6b 100644
--- a/packages/react/src/scene/textureAtlas.tsx
+++ b/packages/react/src/scene/textureAtlas.tsx
@@ -58,7 +58,13 @@ export type TextureQuality = number | "auto";
 
 interface RGB { r: number; g: number; b: number; }
 interface RGBFactors { r: number; g: number; b: number; }
+interface StableTriangleBasis {
+  a: number;
+  b: number;
+  c: number;
+}
 interface StableTriangleDomElement extends HTMLElement {
+  __polycssStableTriangleBasis?: StableTriangleBasis;
   __polycssStableTriangleColor?: string;
   __polycssStableTriangleColorRgb?: RGB;
 }
@@ -1163,6 +1169,23 @@ function shadePolygon(
     : rgbToHex({ r, g, b });
 }
 
+function quantizeCssColor(input: string, steps: number): string {
+  if (!Number.isFinite(steps) || steps <= 1) return input;
+  const parsed = parsePureColor(input);
+  if (!parsed) return input;
+  const channelStep = 255 / Math.max(1, Math.round(steps) - 1);
+  const quantize = (value: number) =>
+    Math.max(0, Math.min(255, Math.round(Math.round(value / channelStep) * channelStep)));
+  const rgb = {
+    r: quantize(parsed.rgb[0]),
+    g: quantize(parsed.rgb[1]),
+    b: quantize(parsed.rgb[2]),
+  };
+  return parsed.alpha < 1
+    ? `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${parsed.alpha})`
+    : rgbToHex(rgb);
+}
+
 function textureTintFactors(
   directScale: number,
   lightColor: string,
@@ -1188,10 +1211,295 @@ export interface StableTriangleDomUpdateOptions {
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
   colorFrame?: number;
+  colorSteps?: number;
   colorFreezeFrames?: number;
   colorMaxStep?: number;
 }
 
+interface StableTriangleDomStyle {
+  transform: string;
+  color: string;
+  basis: StableTriangleBasis;
+}
+
+function isStableTriangleBasis(value: StableTriangleBasis | undefined): value is StableTriangleBasis {
+  if (!value) return false;
+  const { a, b, c } = value;
+  return (
+    (a === 0 && b === 1 && c === 2) ||
+    (a === 1 && b === 2 && c === 0) ||
+    (a === 2 && b === 0 && c === 1)
+  );
+}
+
+function offsetStableTrianglePoints(
+  left: number,
+  right: number,
+  height: number,
+  amount: number,
+): number[] {
+  const baseWidth = left + right;
+  if (
+    amount <= 0 ||
+    height <= BASIS_EPS ||
+    baseWidth <= BASIS_EPS ||
+    !Number.isFinite(left + right + height + amount)
+  ) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const leftLen = Math.sqrt(left * left + height * height);
+  const rightLen = Math.sqrt(right * right + height * height);
+  if (leftLen <= BASIS_EPS || rightLen <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const leftOffsetX = -amount * height / leftLen;
+  const leftOffsetY = -amount * left / leftLen;
+  const rightOffsetX = amount * height / rightLen;
+  const rightOffsetY = -amount * right / rightLen;
+  const apexLineLeftX = left + leftOffsetX;
+  const apexLineLeftY = leftOffsetY;
+  const apexLineRightX = baseWidth + rightOffsetX;
+  const apexLineRightY = height + rightOffsetY;
+  const det = -height * baseWidth;
+  if (Math.abs(det) <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const qx = apexLineLeftX - apexLineRightX;
+  const qy = apexLineLeftY - apexLineRightY;
+  const t = (qx * height + qy * left) / det;
+  let apexX = apexLineRightX - t * right;
+  let apexY = apexLineRightY - t * height;
+  let baseLeftX = -amount * (left + leftLen) / height;
+  let baseLeftY = height + amount;
+  let baseRightX = baseWidth + amount * (right + rightLen) / height;
+  let baseRightY = baseLeftY;
+
+  const maxMiter = Math.max(2, amount * 4);
+  const apexDx = apexX - left;
+  const apexDy = apexY;
+  const apexMiter = Math.sqrt(apexDx * apexDx + apexDy * apexDy);
+  if (apexMiter > maxMiter) {
+    apexX = left + (apexDx / apexMiter) * maxMiter;
+    apexY = (apexDy / apexMiter) * maxMiter;
+  }
+  const leftMiter = Math.sqrt(baseLeftX * baseLeftX + amount * amount);
+  if (leftMiter > maxMiter) {
+    baseLeftX = (baseLeftX / leftMiter) * maxMiter;
+    baseLeftY = height + (amount / leftMiter) * maxMiter;
+  }
+  const rightDx = baseRightX - baseWidth;
+  const rightMiter = Math.sqrt(rightDx * rightDx + amount * amount);
+  if (rightMiter > maxMiter) {
+    baseRightX = baseWidth + (rightDx / rightMiter) * maxMiter;
+    baseRightY = height + (amount / rightMiter) * maxMiter;
+  }
+
+  return [apexX, apexY, baseLeftX, baseLeftY, baseRightX, baseRightY];
+}
+
+function formatStableTriangleTransformScalars(
+  x0: number,
+  x1: number,
+  x2: number,
+  y0: number,
+  y1: number,
+  y2: number,
+  z0: number,
+  z1: number,
+  z2: number,
+  tx0: number,
+  tx1: number,
+  tx2: number,
+): string {
+  const rx0 = Math.round(x0 * 1000) / 1000 || 0;
+  const rx1 = Math.round(x1 * 1000) / 1000 || 0;
+  const rx2 = Math.round(x2 * 1000) / 1000 || 0;
+  const ry0 = Math.round(y0 * 1000) / 1000 || 0;
+  const ry1 = Math.round(y1 * 1000) / 1000 || 0;
+  const ry2 = Math.round(y2 * 1000) / 1000 || 0;
+  const rz0 = Math.round(z0 * 1000) / 1000 || 0;
+  const rz1 = Math.round(z1 * 1000) / 1000 || 0;
+  const rz2 = Math.round(z2 * 1000) / 1000 || 0;
+  const rtx0 = Math.round(tx0 * 1000) / 1000 || 0;
+  const rtx1 = Math.round(tx1 * 1000) / 1000 || 0;
+  const rtx2 = Math.round(tx2 * 1000) / 1000 || 0;
+  return `matrix3d(${rx0},${rx1},${rx2},0,` +
+    `${ry0},${ry1},${ry2},0,` +
+    `${rz0},${rz1},${rz2},0,` +
+    `${rtx0},${rtx1},${rtx2},1)`;
+}
+
+function computeStableTriangleDomStyle(
+  polygon: Polygon,
+  options: StableTriangleDomUpdateOptions,
+  basisHint?: StableTriangleBasis,
+): StableTriangleDomStyle | null {
+  if (polygon.texture || polygon.vertices.length !== 3) return null;
+
+  const tile = DEFAULT_TILE;
+  const elev = tile;
+  const v0 = polygon.vertices[0];
+  const v1 = polygon.vertices[1];
+  const v2 = polygon.vertices[2];
+  const p0x = v0[1] * tile;
+  const p0y = v0[0] * tile;
+  const p0z = v0[2] * elev;
+  const p1x = v1[1] * tile;
+  const p1y = v1[0] * tile;
+  const p1z = v1[2] * elev;
+  const p2x = v2[1] * tile;
+  const p2y = v2[0] * tile;
+  const p2z = v2[2] * elev;
+  const e10x = p1x - p0x;
+  const e10y = p1y - p0y;
+  const e10z = p1z - p0z;
+  const e20x = p2x - p0x;
+  const e20y = p2y - p0y;
+  const e20z = p2z - p0z;
+  let nx = -(e10y * e20z - e10z * e20y);
+  let ny = -(e10z * e20x - e10x * e20z);
+  let nz = -(e10x * e20y - e10y * e20x);
+  const nLen = Math.sqrt(nx * nx + ny * ny + nz * nz);
+  if (nLen <= BASIS_EPS) return null;
+  nx /= nLen;
+  ny /= nLen;
+  nz /= nLen;
+
+  const len01Sq = e10x * e10x + e10y * e10y + e10z * e10z;
+  const e21x = p2x - p1x;
+  const e21y = p2y - p1y;
+  const e21z = p2z - p1z;
+  const e02x = p0x - p2x;
+  const e02y = p0y - p2y;
+  const e02z = p0z - p2z;
+  const len12Sq = e21x * e21x + e21y * e21y + e21z * e21z;
+  const len20Sq = e02x * e02x + e02y * e02y + e02z * e02z;
+  let a = isStableTriangleBasis(basisHint) ? basisHint.a : 0;
+  let b = isStableTriangleBasis(basisHint) ? basisHint.b : 1;
+  let c = isStableTriangleBasis(basisHint) ? basisHint.c : 2;
+  const retryWithoutBasis = (): StableTriangleDomStyle | null =>
+    basisHint ? computeStableTriangleDomStyle(polygon, options) : null;
+  if (!isStableTriangleBasis(basisHint)) {
+    let baseLengthSq = len01Sq;
+    if (len12Sq > baseLengthSq) {
+      a = 1;
+      b = 2;
+      c = 0;
+      baseLengthSq = len12Sq;
+    }
+    if (len20Sq > baseLengthSq) {
+      a = 2;
+      b = 0;
+      c = 1;
+    }
+  }
+
+  const cvx = c === 0 ? p0x : c === 1 ? p1x : p2x;
+  const cvy = c === 0 ? p0y : c === 1 ? p1y : p2y;
+  const cvz = c === 0 ? p0z : c === 1 ? p1z : p2z;
+  const avx = a === 0 ? p0x : a === 1 ? p1x : p2x;
+  const avy = a === 0 ? p0y : a === 1 ? p1y : p2y;
+  const avz = a === 0 ? p0z : a === 1 ? p1z : p2z;
+  const bvx = b === 0 ? p0x : b === 1 ? p1x : p2x;
+  const bvy = b === 0 ? p0y : b === 1 ? p1y : p2y;
+  const bvz = b === 0 ? p0z : b === 1 ? p1z : p2z;
+
+  const baseDx = bvx - avx;
+  const baseDy = bvy - avy;
+  const baseDz = bvz - avz;
+  const baseLength = Math.sqrt(baseDx * baseDx + baseDy * baseDy + baseDz * baseDz);
+  if (baseLength <= BASIS_EPS) return retryWithoutBasis();
+
+  const x0 = baseDx / baseLength;
+  const x1 = baseDy / baseLength;
+  const x2 = baseDz / baseLength;
+  const apexX = (cvx - avx) * x0 + (cvy - avy) * x1 + (cvz - avz) * x2;
+  let y0 = avx + x0 * apexX - cvx;
+  let y1 = avy + x1 * apexX - cvy;
+  let y2 = avz + x2 * apexX - cvz;
+  const height = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (height <= BASIS_EPS) return retryWithoutBasis();
+  y0 /= height;
+  y1 /= height;
+  y2 /= height;
+
+  const left = Math.max(0, Math.min(baseLength, apexX));
+  const right = Math.max(0, baseLength - left);
+  const expanded = offsetStableTrianglePoints(left, right, height, SOLID_TRIANGLE_BLEED);
+  const apex2x = expanded[0];
+  const apex2y = expanded[1];
+  const baseLeft2x = expanded[2];
+  const baseLeft2y = expanded[3];
+  const baseRight2x = expanded[4];
+  const baseRight2y = expanded[5];
+  const baseY = (baseLeft2y + baseRight2y) / 2;
+  const leftPx = apex2x - baseLeft2x;
+  const rightPx = baseRight2x - apex2x;
+  const heightPx = baseY - apex2y;
+  if (
+    leftPx <= BASIS_EPS ||
+    rightPx <= BASIS_EPS ||
+    heightPx <= BASIS_EPS ||
+    !Number.isFinite(leftPx + rightPx + heightPx)
+  ) {
+    return retryWithoutBasis();
+  }
+
+  const invCanonicalSize = 1 / SOLID_TRIANGLE_CANONICAL_SIZE;
+  const baseWidthPx = leftPx + rightPx;
+  const xScale = baseWidthPx * invCanonicalSize;
+  const yXScale = (rightPx - leftPx) * 0.5 * invCanonicalSize;
+  const yYScale = heightPx * invCanonicalSize;
+  const txXOffset = apex2x - left - baseWidthPx * 0.5;
+  const txYOffset = apex2y;
+  const transform = formatStableTriangleTransformScalars(
+    x0 * xScale,
+    x1 * xScale,
+    x2 * xScale,
+    x0 * yXScale + y0 * yYScale,
+    x1 * yXScale + y1 * yYScale,
+    x2 * yXScale + y2 * yYScale,
+    nx,
+    ny,
+    nz,
+    cvx + x0 * txXOffset + y0 * txYOffset,
+    cvy + x1 * txXOffset + y1 * txYOffset,
+    cvz + x2 * txXOffset + y2 * txYOffset,
+  );
+
+  const directionalCfg = options.directionalLight;
+  const ambientCfg = options.ambientLight;
+  const lightDir = directionalCfg?.direction ?? DEFAULT_LIGHT_DIR;
+  const lightColor = directionalCfg?.color ?? DEFAULT_LIGHT_COLOR;
+  const lightIntensity = Math.max(0, directionalCfg?.intensity ?? DEFAULT_LIGHT_INTENSITY);
+  const ambientColor = ambientCfg?.color ?? DEFAULT_AMBIENT_COLOR;
+  const ambientIntensity = Math.max(0, ambientCfg?.intensity ?? DEFAULT_AMBIENT_INTENSITY);
+  const lLen = Math.sqrt(
+    lightDir[0] * lightDir[0] +
+    lightDir[1] * lightDir[1] +
+    lightDir[2] * lightDir[2],
+  ) || 1;
+  const lx = lightDir[0] / lLen;
+  const ly = lightDir[1] / lLen;
+  const lz = lightDir[2] / lLen;
+  const directScale = lightIntensity * Math.max(0, nx * lx + ny * ly + nz * lz);
+  const shadedColor = shadePolygon(
+    polygon.color ?? "#cccccc",
+    directScale,
+    lightColor,
+    ambientColor,
+    ambientIntensity,
+  );
+  const color = options.colorSteps
+    ? quantizeCssColor(shadedColor, options.colorSteps)
+    : shadedColor;
+
+  return { transform, color, basis: { a, b, c } };
+}
+
 function stableTriangleColorAllowed(index: number, colorFrame: number, freezeFrames: number): boolean {
   return freezeFrames > 0 && (freezeFrames <= 1 || (colorFrame + index) % freezeFrames === 0);
 }
@@ -1241,30 +1549,18 @@ export function updateStableTriangleDom(
   );
   if (leaves.length !== polygons.length) return false;
 
-  const plans = polygons.map((polygon, index) => {
-    if (polygon.texture || polygon.vertices.length !== 3) return null;
-    const plan = computeTextureAtlasPlan(polygon, index, {
-      directionalLight: options.directionalLight,
-      ambientLight: options.ambientLight,
-    });
-    if (!plan || !isSolidTrianglePlan(plan)) return null;
-    const style = solidTriangleStyle(plan, "baked", "auto", {});
-    if (!style?.transform) return null;
-    return style;
-  });
-  if (plans.some((plan) => !plan)) return false;
+  const styles = polygons.map((polygon, index) =>
+    computeStableTriangleDomStyle(polygon, options, leaves[index].__polycssStableTriangleBasis)
+  );
+  if (styles.some((style) => !style)) return false;
 
   for (let i = 0; i < leaves.length; i += 1) {
-    const style = plans[i]!;
+    const style = styles[i]!;
     const el = leaves[i];
     if (el.style.visibility) el.style.visibility = "";
-    el.style.transform = String(style.transform);
-    applyStableTriangleColor(
-      el,
-      i,
-      typeof style.color === "string" ? style.color : "",
-      options,
-    );
+    el.__polycssStableTriangleBasis = style.basis;
+    el.style.transform = style.transform;
+    applyStableTriangleColor(el, i, style.color, options);
   }
   return true;
 }
diff --git a/packages/vue/src/scene/PolyMesh.ts b/packages/vue/src/scene/PolyMesh.ts
index 9ce16a1d..41927e12 100644
--- a/packages/vue/src/scene/PolyMesh.ts
+++ b/packages/vue/src/scene/PolyMesh.ts
@@ -372,6 +372,7 @@ export const PolyMesh = defineComponent({
             ambientLight: atlasAmbient.value,
             textureLighting: atlasTextureLighting.value,
             colorFrame: ++stableTriangleColorFrame.value,
+            colorSteps: 8,
             colorFreezeFrames: 12,
             colorMaxStep: 8,
           })
diff --git a/packages/vue/src/scene/textureAtlas.ts b/packages/vue/src/scene/textureAtlas.ts
index 02dc4ae8..c6ef3bee 100644
--- a/packages/vue/src/scene/textureAtlas.ts
+++ b/packages/vue/src/scene/textureAtlas.ts
@@ -67,7 +67,13 @@ export interface PolyRenderStrategiesOption {
 
 interface RGB { r: number; g: number; b: number; }
 interface RGBFactors { r: number; g: number; b: number; }
+interface StableTriangleBasis {
+  a: number;
+  b: number;
+  c: number;
+}
 interface StableTriangleDomElement extends HTMLElement {
+  __polycssStableTriangleBasis?: StableTriangleBasis;
   __polycssStableTriangleColor?: string;
   __polycssStableTriangleColorRgb?: RGB;
 }
@@ -1171,6 +1177,23 @@ function shadePolygon(
     : rgbToHex({ r, g, b });
 }
 
+function quantizeCssColor(input: string, steps: number): string {
+  if (!Number.isFinite(steps) || steps <= 1) return input;
+  const parsed = parsePureColor(input);
+  if (!parsed) return input;
+  const channelStep = 255 / Math.max(1, Math.round(steps) - 1);
+  const quantize = (value: number) =>
+    Math.max(0, Math.min(255, Math.round(Math.round(value / channelStep) * channelStep)));
+  const rgb = {
+    r: quantize(parsed.rgb[0]),
+    g: quantize(parsed.rgb[1]),
+    b: quantize(parsed.rgb[2]),
+  };
+  return parsed.alpha < 1
+    ? `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${parsed.alpha})`
+    : rgbToHex(rgb);
+}
+
 function textureTintFactors(
   directScale: number,
   lightColor: string,
@@ -1196,10 +1219,295 @@ export interface StableTriangleDomUpdateOptions {
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
   colorFrame?: number;
+  colorSteps?: number;
   colorFreezeFrames?: number;
   colorMaxStep?: number;
 }
 
+interface StableTriangleDomStyle {
+  transform: string;
+  color: string;
+  basis: StableTriangleBasis;
+}
+
+function isStableTriangleBasis(value: StableTriangleBasis | undefined): value is StableTriangleBasis {
+  if (!value) return false;
+  const { a, b, c } = value;
+  return (
+    (a === 0 && b === 1 && c === 2) ||
+    (a === 1 && b === 2 && c === 0) ||
+    (a === 2 && b === 0 && c === 1)
+  );
+}
+
+function offsetStableTrianglePoints(
+  left: number,
+  right: number,
+  height: number,
+  amount: number,
+): number[] {
+  const baseWidth = left + right;
+  if (
+    amount <= 0 ||
+    height <= BASIS_EPS ||
+    baseWidth <= BASIS_EPS ||
+    !Number.isFinite(left + right + height + amount)
+  ) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const leftLen = Math.sqrt(left * left + height * height);
+  const rightLen = Math.sqrt(right * right + height * height);
+  if (leftLen <= BASIS_EPS || rightLen <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const leftOffsetX = -amount * height / leftLen;
+  const leftOffsetY = -amount * left / leftLen;
+  const rightOffsetX = amount * height / rightLen;
+  const rightOffsetY = -amount * right / rightLen;
+  const apexLineLeftX = left + leftOffsetX;
+  const apexLineLeftY = leftOffsetY;
+  const apexLineRightX = baseWidth + rightOffsetX;
+  const apexLineRightY = height + rightOffsetY;
+  const det = -height * baseWidth;
+  if (Math.abs(det) <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+
+  const qx = apexLineLeftX - apexLineRightX;
+  const qy = apexLineLeftY - apexLineRightY;
+  const t = (qx * height + qy * left) / det;
+  let apexX = apexLineRightX - t * right;
+  let apexY = apexLineRightY - t * height;
+  let baseLeftX = -amount * (left + leftLen) / height;
+  let baseLeftY = height + amount;
+  let baseRightX = baseWidth + amount * (right + rightLen) / height;
+  let baseRightY = baseLeftY;
+
+  const maxMiter = Math.max(2, amount * 4);
+  const apexDx = apexX - left;
+  const apexDy = apexY;
+  const apexMiter = Math.sqrt(apexDx * apexDx + apexDy * apexDy);
+  if (apexMiter > maxMiter) {
+    apexX = left + (apexDx / apexMiter) * maxMiter;
+    apexY = (apexDy / apexMiter) * maxMiter;
+  }
+  const leftMiter = Math.sqrt(baseLeftX * baseLeftX + amount * amount);
+  if (leftMiter > maxMiter) {
+    baseLeftX = (baseLeftX / leftMiter) * maxMiter;
+    baseLeftY = height + (amount / leftMiter) * maxMiter;
+  }
+  const rightDx = baseRightX - baseWidth;
+  const rightMiter = Math.sqrt(rightDx * rightDx + amount * amount);
+  if (rightMiter > maxMiter) {
+    baseRightX = baseWidth + (rightDx / rightMiter) * maxMiter;
+    baseRightY = height + (amount / rightMiter) * maxMiter;
+  }
+
+  return [apexX, apexY, baseLeftX, baseLeftY, baseRightX, baseRightY];
+}
+
+function formatStableTriangleTransformScalars(
+  x0: number,
+  x1: number,
+  x2: number,
+  y0: number,
+  y1: number,
+  y2: number,
+  z0: number,
+  z1: number,
+  z2: number,
+  tx0: number,
+  tx1: number,
+  tx2: number,
+): string {
+  const rx0 = Math.round(x0 * 1000) / 1000 || 0;
+  const rx1 = Math.round(x1 * 1000) / 1000 || 0;
+  const rx2 = Math.round(x2 * 1000) / 1000 || 0;
+  const ry0 = Math.round(y0 * 1000) / 1000 || 0;
+  const ry1 = Math.round(y1 * 1000) / 1000 || 0;
+  const ry2 = Math.round(y2 * 1000) / 1000 || 0;
+  const rz0 = Math.round(z0 * 1000) / 1000 || 0;
+  const rz1 = Math.round(z1 * 1000) / 1000 || 0;
+  const rz2 = Math.round(z2 * 1000) / 1000 || 0;
+  const rtx0 = Math.round(tx0 * 1000) / 1000 || 0;
+  const rtx1 = Math.round(tx1 * 1000) / 1000 || 0;
+  const rtx2 = Math.round(tx2 * 1000) / 1000 || 0;
+  return `matrix3d(${rx0},${rx1},${rx2},0,` +
+    `${ry0},${ry1},${ry2},0,` +
+    `${rz0},${rz1},${rz2},0,` +
+    `${rtx0},${rtx1},${rtx2},1)`;
+}
+
+function computeStableTriangleDomStyle(
+  polygon: Polygon,
+  options: StableTriangleDomUpdateOptions,
+  basisHint?: StableTriangleBasis,
+): StableTriangleDomStyle | null {
+  if (polygon.texture || polygon.vertices.length !== 3) return null;
+
+  const tile = DEFAULT_TILE;
+  const elev = tile;
+  const v0 = polygon.vertices[0];
+  const v1 = polygon.vertices[1];
+  const v2 = polygon.vertices[2];
+  const p0x = v0[1] * tile;
+  const p0y = v0[0] * tile;
+  const p0z = v0[2] * elev;
+  const p1x = v1[1] * tile;
+  const p1y = v1[0] * tile;
+  const p1z = v1[2] * elev;
+  const p2x = v2[1] * tile;
+  const p2y = v2[0] * tile;
+  const p2z = v2[2] * elev;
+  const e10x = p1x - p0x;
+  const e10y = p1y - p0y;
+  const e10z = p1z - p0z;
+  const e20x = p2x - p0x;
+  const e20y = p2y - p0y;
+  const e20z = p2z - p0z;
+  let nx = -(e10y * e20z - e10z * e20y);
+  let ny = -(e10z * e20x - e10x * e20z);
+  let nz = -(e10x * e20y - e10y * e20x);
+  const nLen = Math.sqrt(nx * nx + ny * ny + nz * nz);
+  if (nLen <= BASIS_EPS) return null;
+  nx /= nLen;
+  ny /= nLen;
+  nz /= nLen;
+
+  const len01Sq = e10x * e10x + e10y * e10y + e10z * e10z;
+  const e21x = p2x - p1x;
+  const e21y = p2y - p1y;
+  const e21z = p2z - p1z;
+  const e02x = p0x - p2x;
+  const e02y = p0y - p2y;
+  const e02z = p0z - p2z;
+  const len12Sq = e21x * e21x + e21y * e21y + e21z * e21z;
+  const len20Sq = e02x * e02x + e02y * e02y + e02z * e02z;
+  let a = isStableTriangleBasis(basisHint) ? basisHint.a : 0;
+  let b = isStableTriangleBasis(basisHint) ? basisHint.b : 1;
+  let c = isStableTriangleBasis(basisHint) ? basisHint.c : 2;
+  const retryWithoutBasis = (): StableTriangleDomStyle | null =>
+    basisHint ? computeStableTriangleDomStyle(polygon, options) : null;
+  if (!isStableTriangleBasis(basisHint)) {
+    let baseLengthSq = len01Sq;
+    if (len12Sq > baseLengthSq) {
+      a = 1;
+      b = 2;
+      c = 0;
+      baseLengthSq = len12Sq;
+    }
+    if (len20Sq > baseLengthSq) {
+      a = 2;
+      b = 0;
+      c = 1;
+    }
+  }
+
+  const cvx = c === 0 ? p0x : c === 1 ? p1x : p2x;
+  const cvy = c === 0 ? p0y : c === 1 ? p1y : p2y;
+  const cvz = c === 0 ? p0z : c === 1 ? p1z : p2z;
+  const avx = a === 0 ? p0x : a === 1 ? p1x : p2x;
+  const avy = a === 0 ? p0y : a === 1 ? p1y : p2y;
+  const avz = a === 0 ? p0z : a === 1 ? p1z : p2z;
+  const bvx = b === 0 ? p0x : b === 1 ? p1x : p2x;
+  const bvy = b === 0 ? p0y : b === 1 ? p1y : p2y;
+  const bvz = b === 0 ? p0z : b === 1 ? p1z : p2z;
+
+  const baseDx = bvx - avx;
+  const baseDy = bvy - avy;
+  const baseDz = bvz - avz;
+  const baseLength = Math.sqrt(baseDx * baseDx + baseDy * baseDy + baseDz * baseDz);
+  if (baseLength <= BASIS_EPS) return retryWithoutBasis();
+
+  const x0 = baseDx / baseLength;
+  const x1 = baseDy / baseLength;
+  const x2 = baseDz / baseLength;
+  const apexX = (cvx - avx) * x0 + (cvy - avy) * x1 + (cvz - avz) * x2;
+  let y0 = avx + x0 * apexX - cvx;
+  let y1 = avy + x1 * apexX - cvy;
+  let y2 = avz + x2 * apexX - cvz;
+  const height = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (height <= BASIS_EPS) return retryWithoutBasis();
+  y0 /= height;
+  y1 /= height;
+  y2 /= height;
+
+  const left = Math.max(0, Math.min(baseLength, apexX));
+  const right = Math.max(0, baseLength - left);
+  const expanded = offsetStableTrianglePoints(left, right, height, SOLID_TRIANGLE_BLEED);
+  const apex2x = expanded[0];
+  const apex2y = expanded[1];
+  const baseLeft2x = expanded[2];
+  const baseLeft2y = expanded[3];
+  const baseRight2x = expanded[4];
+  const baseRight2y = expanded[5];
+  const baseY = (baseLeft2y + baseRight2y) / 2;
+  const leftPx = apex2x - baseLeft2x;
+  const rightPx = baseRight2x - apex2x;
+  const heightPx = baseY - apex2y;
+  if (
+    leftPx <= BASIS_EPS ||
+    rightPx <= BASIS_EPS ||
+    heightPx <= BASIS_EPS ||
+    !Number.isFinite(leftPx + rightPx + heightPx)
+  ) {
+    return retryWithoutBasis();
+  }
+
+  const invCanonicalSize = 1 / SOLID_TRIANGLE_CANONICAL_SIZE;
+  const baseWidthPx = leftPx + rightPx;
+  const xScale = baseWidthPx * invCanonicalSize;
+  const yXScale = (rightPx - leftPx) * 0.5 * invCanonicalSize;
+  const yYScale = heightPx * invCanonicalSize;
+  const txXOffset = apex2x - left - baseWidthPx * 0.5;
+  const txYOffset = apex2y;
+  const transform = formatStableTriangleTransformScalars(
+    x0 * xScale,
+    x1 * xScale,
+    x2 * xScale,
+    x0 * yXScale + y0 * yYScale,
+    x1 * yXScale + y1 * yYScale,
+    x2 * yXScale + y2 * yYScale,
+    nx,
+    ny,
+    nz,
+    cvx + x0 * txXOffset + y0 * txYOffset,
+    cvy + x1 * txXOffset + y1 * txYOffset,
+    cvz + x2 * txXOffset + y2 * txYOffset,
+  );
+
+  const directionalCfg = options.directionalLight;
+  const ambientCfg = options.ambientLight;
+  const lightDir = directionalCfg?.direction ?? DEFAULT_LIGHT_DIR;
+  const lightColor = directionalCfg?.color ?? DEFAULT_LIGHT_COLOR;
+  const lightIntensity = Math.max(0, directionalCfg?.intensity ?? DEFAULT_LIGHT_INTENSITY);
+  const ambientColor = ambientCfg?.color ?? DEFAULT_AMBIENT_COLOR;
+  const ambientIntensity = Math.max(0, ambientCfg?.intensity ?? DEFAULT_AMBIENT_INTENSITY);
+  const lLen = Math.sqrt(
+    lightDir[0] * lightDir[0] +
+    lightDir[1] * lightDir[1] +
+    lightDir[2] * lightDir[2],
+  ) || 1;
+  const lx = lightDir[0] / lLen;
+  const ly = lightDir[1] / lLen;
+  const lz = lightDir[2] / lLen;
+  const directScale = lightIntensity * Math.max(0, nx * lx + ny * ly + nz * lz);
+  const shadedColor = shadePolygon(
+    polygon.color ?? "#cccccc",
+    directScale,
+    lightColor,
+    ambientColor,
+    ambientIntensity,
+  );
+  const color = options.colorSteps
+    ? quantizeCssColor(shadedColor, options.colorSteps)
+    : shadedColor;
+
+  return { transform, color, basis: { a, b, c } };
+}
+
 function stableTriangleColorAllowed(index: number, colorFrame: number, freezeFrames: number): boolean {
   return freezeFrames > 0 && (freezeFrames <= 1 || (colorFrame + index) % freezeFrames === 0);
 }
@@ -1249,30 +1557,18 @@ export function updateStableTriangleDom(
   );
   if (leaves.length !== polygons.length) return false;
 
-  const plans = polygons.map((polygon, index) => {
-    if (polygon.texture || polygon.vertices.length !== 3) return null;
-    const plan = computeTextureAtlasPlan(polygon, index, {
-      directionalLight: options.directionalLight,
-      ambientLight: options.ambientLight,
-    });
-    if (!plan || !isSolidTrianglePlan(plan)) return null;
-    const style = solidTriangleStyle(plan, "baked", "auto", {});
-    if (!style?.transform) return null;
-    return style;
-  });
-  if (plans.some((plan) => !plan)) return false;
+  const styles = polygons.map((polygon, index) =>
+    computeStableTriangleDomStyle(polygon, options, leaves[index].__polycssStableTriangleBasis)
+  );
+  if (styles.some((style) => !style)) return false;
 
   for (let i = 0; i < leaves.length; i += 1) {
-    const style = plans[i]!;
+    const style = styles[i]!;
     const el = leaves[i];
     if (el.style.visibility) el.style.visibility = "";
-    el.style.transform = String(style.transform);
-    applyStableTriangleColor(
-      el,
-      i,
-      typeof style.color === "string" ? style.color : "",
-      options,
-    );
+    el.__polycssStableTriangleBasis = style.basis;
+    el.style.transform = style.transform;
+    applyStableTriangleColor(el, i, style.color, options);
   }
   return true;
 }
diff --git a/website/src/components/VanillaScene/VanillaScene.tsx b/website/src/components/VanillaScene/VanillaScene.tsx
index a6c3d95f..79ad2e99 100644
--- a/website/src/components/VanillaScene/VanillaScene.tsx
+++ b/website/src/components/VanillaScene/VanillaScene.tsx
@@ -34,7 +34,7 @@ export type { GizmoMode, SceneOptionsState };
 // components in @layoutit/polycss-react and @layoutit/polycss-vue).
 const LIGHT_HELPER_TILE = 50;
 const ANIMATION_STABLE_TRIANGLE_COLOR_POLICY = "cadence";
-const ANIMATION_STABLE_TRIANGLE_COLOR_STEPS = 0;
+const ANIMATION_STABLE_TRIANGLE_COLOR_STEPS = 8;
 const ANIMATION_STABLE_TRIANGLE_COLOR_FREEZE_FRAMES = 12;
 const ANIMATION_STABLE_TRIANGLE_COLOR_MAX_STEP = 8;
 const ANIMATION_TRANSFORM_CACHE_FRAMES = 60;

From 230f527e5b31454d2e253cfc13940f8b53721aab Mon Sep 17 00:00:00 2001
From: agustin-littlehat <minotopo@gmail.com>
Date: Wed, 20 May 2026 20:38:10 -0300
Subject: [PATCH 2/5] chore: clean baked animation defaults

---
 bench/README.md                |  9 ++++-----
 bench/animated-human-bench.mjs |  5 +----
 bench/animated-human.html      | 18 +-----------------
 3 files changed, 6 insertions(+), 26 deletions(-)

diff --git a/bench/README.md b/bench/README.md
index e27b9560..1512046e 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -172,11 +172,10 @@ Playwright runner accepts `--mode baked,dynamic`, `--clip <name|index|run>`,
 `--animation-driver js|progressive-style-cache|js-style-cache|typed-om-style-cache|css-keyframes`,
 `--compare-stable-triangle-debug`, `--require-solid-triangles`, `--trace`, and
 the same GPU lane flags as the other browser benches. The default baked color
-policy uses 8-channel quantized colors and staggers leaf color writes over a
-12-frame cadence; adaptive color policy spends a capped write budget on leaves
-with the largest accumulated color error first. The max-step option caps the
-per-write RGB channel delta so cadence updates drift toward the next baked color
-instead of jumping directly to it. `css-keyframes` is a bench-only prototype that samples the clip into
+path uses 8-channel quantized colors, staggers leaf color writes over a
+12-frame cadence, and caps the per-write RGB channel delta so updates drift
+toward the next baked color instead of jumping directly to it. `css-keyframes`
+is a bench-only prototype that samples the clip into
 per-leaf CSS animations, removing per-frame JS playback from the measurement
 window. The solid-triangle guard fails the run if the page leaves the baked
 `<u>` path. Use `--stable-triangle-color-freeze-frames 0` to keep the initial
diff --git a/bench/animated-human-bench.mjs b/bench/animated-human-bench.mjs
index f50edebc..8b391768 100644
--- a/bench/animated-human-bench.mjs
+++ b/bench/animated-human-bench.mjs
@@ -81,7 +81,6 @@ const DISABLE_STRATEGIES = optStr("disable-strategies", optStr("disableStrategie
 const STABLE_TRIANGLE_DEBUG = optStr("stable-triangle-debug", optStr("stableTriangleDebug"));
 const ANIMATION_DRIVER = optStr("animation-driver", optStr("animationDriver", "js"));
 const ANIMATION_FRAME_CACHE = hasFlag("animation-frame-cache") || hasFlag("animationFrameCache");
-const TRIANGLE_FRAME = !hasFlag("no-triangle-frame") && !hasFlag("noTriangleFrame");
 const ANIMATION_FRAME_CACHE_FRAMES = optNum(
   "animation-frame-cache-frames",
   optNum("animationFrameCacheFrames", 60),
@@ -520,7 +519,6 @@ function buildUrl(port, scenario) {
     stableDom: scenario.stableDom ? "1" : "0",
     animationDriver: scenario.animationDriver,
     animationFrameCache: scenario.animationFrameCache ? "1" : "0",
-    triangleFrame: TRIANGLE_FRAME ? "1" : "0",
     animationFrameCacheFrames: String(ANIMATION_FRAME_CACHE_FRAMES),
     keyframeSamples: String(KEYFRAME_SAMPLES),
     animatedMeshOptimization: scenario.animatedMeshOptimization ? "1" : "0",
@@ -655,7 +653,7 @@ for (const mode of MODES) {
   }
 }
 
-console.log(`[animated-human] mesh=${MESH} clip=${CLIP} targetSize=${TARGET_SIZE} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms animatedMeshOptimization=${ANIMATED_MESH_OPTIMIZATION_VARIANTS.join(",")} animationDriver=${ANIMATION_DRIVER_VARIANTS.join(",")} animationFrameCache=${ANIMATION_FRAME_CACHE_VARIANTS.join(",")} triangleFrame=${TRIANGLE_FRAME ? "on" : "off"} animationFrameCacheFrames=${ANIMATION_FRAME_CACHE_FRAMES} keyframeSamples=${KEYFRAME_SAMPLES} stableTriangleDebug=${STABLE_TRIANGLE_DEBUG_VARIANTS.map((value) => value || "normal").join(",")} colorPolicy=${STABLE_TRIANGLE_COLOR_POLICY_LABEL} colorSteps=${STABLE_TRIANGLE_COLOR_STEPS_LABEL} colorFreezeFrames=${STABLE_TRIANGLE_COLOR_FREEZE_FRAMES_LABEL} colorBudget=${STABLE_TRIANGLE_COLOR_BUDGET_LABEL} colorMaxAge=${STABLE_TRIANGLE_COLOR_MAX_AGE_LABEL} colorMaxStep=${STABLE_TRIANGLE_COLOR_MAX_STEP_LABEL} matrixDecimals=${STABLE_TRIANGLE_MATRIX_DECIMALS_LABEL}`);
+console.log(`[animated-human] mesh=${MESH} clip=${CLIP} targetSize=${TARGET_SIZE} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms animatedMeshOptimization=${ANIMATED_MESH_OPTIMIZATION_VARIANTS.join(",")} animationDriver=${ANIMATION_DRIVER_VARIANTS.join(",")} animationFrameCache=${ANIMATION_FRAME_CACHE_VARIANTS.join(",")} animationFrameCacheFrames=${ANIMATION_FRAME_CACHE_FRAMES} keyframeSamples=${KEYFRAME_SAMPLES} stableTriangleDebug=${STABLE_TRIANGLE_DEBUG_VARIANTS.map((value) => value || "normal").join(",")} colorPolicy=${STABLE_TRIANGLE_COLOR_POLICY_LABEL} colorSteps=${STABLE_TRIANGLE_COLOR_STEPS_LABEL} colorFreezeFrames=${STABLE_TRIANGLE_COLOR_FREEZE_FRAMES_LABEL} colorBudget=${STABLE_TRIANGLE_COLOR_BUDGET_LABEL} colorMaxAge=${STABLE_TRIANGLE_COLOR_MAX_AGE_LABEL} colorMaxStep=${STABLE_TRIANGLE_COLOR_MAX_STEP_LABEL} matrixDecimals=${STABLE_TRIANGLE_MATRIX_DECIMALS_LABEL}`);
 if (BROWSER_EXECUTABLE) console.log(`[animated-human] browser=${BROWSER_EXECUTABLE}`);
 if (SOFTWARE_BACKEND) console.log("[animated-human] software backend=on");
 if (CHROMIUM_ARGS.length > 0) console.log(`[animated-human] chromium args=${CHROMIUM_ARGS.join(" ")}`);
@@ -723,7 +721,6 @@ try {
     animationFrameCache: ANIMATION_FRAME_CACHE_VARIANTS.length === 1
       ? ANIMATION_FRAME_CACHE_VARIANTS[0]
       : "compare",
-    triangleFrame: TRIANGLE_FRAME,
     animationFrameCacheFrames: ANIMATION_FRAME_CACHE_FRAMES,
     keyframeSamples: KEYFRAME_SAMPLES,
     stableTriangleDebug: STABLE_TRIANGLE_DEBUG || null,
diff --git a/bench/animated-human.html b/bench/animated-human.html
index 2ba48405..aaf39011 100644
--- a/bench/animated-human.html
+++ b/bench/animated-human.html
@@ -118,7 +118,6 @@
     const animationFrameCache = boolParam("animationFrameCache", false);
     const animationFrameCacheFrames = Math.max(2, Math.floor(numberParam("animationFrameCacheFrames", 60)));
     const animatedMeshOptimization = boolParam("animatedMeshOptimization", false);
-    const triangleFrame = boolParam("triangleFrame", true);
     const solidTextureSamples = boolParam("solidTextureSamples", true);
     const targetSize = numberParam("targetSize", 72);
     const timeScale = numberParam("timeScale", 1);
@@ -436,7 +435,6 @@
         animationDriver,
         animationFrameCache,
         animationFrameCacheFrames,
-        triangleFrame,
         stableTriangleDebug,
         stableTriangleColorPolicy,
         stableTriangleColorSteps,
@@ -597,7 +595,7 @@
           lastAnimatedPolygons = polygons.length;
         },
         [triangleFrameTargetSymbol](frame) {
-          if (!triangleFrame || typeof meshTriangleFrameTarget !== "function") return false;
+          if (typeof meshTriangleFrameTarget !== "function") return false;
           const start = performance.now();
           const applied = meshTriangleFrameTarget.call(
             mesh,
@@ -615,7 +613,6 @@
       const mixer = createPolyAnimationMixer(animationTarget, renderParsed.animation);
       const action = mixer.clipAction(clip.name);
       action.play();
-      const frameCacheStart = performance.now();
       const cachedAnimationFrames = animationFrameCache
         ? Array.from({ length: animationFrameCacheFrames }, (_, index) =>
             renderParsed.animation.sample(
@@ -624,19 +621,6 @@
             )
           )
         : null;
-      if (cachedAnimationFrames) {
-        const cachedPolygons = cachedAnimationFrames.reduce((sum, frame) => sum + frame.length, 0);
-        const cachedVertices = cachedAnimationFrames.reduce(
-          (sum, frame) => sum + frame.reduce((frameSum, polygon) => frameSum + polygon.vertices.length, 0),
-          0,
-        );
-        window.__perf__.animation.animationFrameCacheInfo = {
-          buildMs: performance.now() - frameCacheStart,
-          frameCount: cachedAnimationFrames.length,
-          cachedPolygons,
-          cachedVertices,
-        };
-      }
 
       let last = performance.now();
       let elapsedClipTime = 0;

From a7cd9ec7ba26006aee2e35627f6a54cfb7ae0f92 Mon Sep 17 00:00:00 2001
From: agustin-littlehat <minotopo@gmail.com>
Date: Thu, 21 May 2026 18:22:52 -0300
Subject: [PATCH 3/5] feat: improve polygon rendering and benches

---
 .github/scripts/bump-versions.mjs             |    3 +-
 .../scripts}/sync-package-readmes.mjs         |    2 +-
 .github/workflows/publish-packages.yml        |    2 +-
 .gitignore                                    |    7 +-
 AGENTS.md                                     |   14 +-
 bench/ITERATION_GUARDRAILS.md                 |  253 --
 bench/ITERATION_LOG.md                        |   62 -
 bench/NON_VOXEL_ROTATION_HYPOTHESES.md        |  151 -
 bench/TRACE_INVESTIGATION.md                  |  659 ---
 bench/VOXEL_FAST_PATH_HYPOTHESES.md           |  753 ----
 bench/animated-human.html                     |    2 +-
 bench/build.mjs                               |   34 +-
 bench/compositor-topology-probe.mjs           |  899 ----
 bench/coplanar-tolerance-report.mjs           |  417 --
 bench/entries/normalize.ts                    |   99 -
 bench/entries/react.tsx                       |    2 +-
 bench/entries/vue.ts                          |    2 +-
 bench/insurgent-semis-bench.mjs               |  636 ---
 bench/lossy-corpus-bench.mjs                  |  998 +++++
 bench/nonvoxel-drag-trace.mjs                 |   27 +-
 bench/nonvoxel-frame-buckets.mjs              |  626 ---
 bench/nonvoxel-rotation-bench.mjs             |  100 +-
 bench/nonvoxel-vanilla.html                   |    2 +-
 bench/nonvoxel-variants.mjs                   |  110 +
 bench/nonvoxel-visual-compare.mjs             |   17 +-
 bench/{README.md => notes/BENCH.md}           |   82 +-
 bench/notes/PERF_INVESTIGATION.md             |  426 ++
 bench/perf-cracks.html                        |  307 --
 bench/perf-html.html                          |    2 +-
 bench/perf-react.html                         |    4 +-
 bench/perf-serve.mjs                          |    2 +-
 bench/perf-shared.mjs                         |    2 +-
 bench/perf-vanilla.html                       |   10 +-
 bench/perf-vue.html                           |    4 +-
 bench/polycss-normalize.js                    | 3618 -----------------
 bench/snap-cracks.mjs                         |   51 -
 ...e-frame-buckets.mjs => trace-analysis.mjs} |  224 +-
 bench/trace-event-args.mjs                    |  162 -
 bench/trace-summary.mjs                       |  276 --
 bench/voxel-browser-summary.mjs               |   85 -
 bench/voxel-cadence-summary.mjs               |  184 -
 bench/voxel-depth-quantization-error.mjs      |  290 --
 bench/voxel-dom-order-probe.mjs               |  996 -----
 bench/voxel-interval-geometry-correlation.mjs |  611 ---
 bench/voxel-interval-order-diff.mjs           |  646 ---
 bench/voxel-interval-profiler.mjs             |  374 --
 bench/voxel-interval-screen-metrics.mjs       |  452 --
 bench/voxel-occlusion-potential.mjs           |  333 --
 bench/voxel-order-metrics.mjs                 |  767 ----
 bench/voxel-order-phase-metrics.mjs           |  598 ---
 bench/voxel-progress-dashboard.html           |  449 --
 bench/voxel-progress-dashboard.mjs            |  688 ----
 bench/voxel-report.mjs                        |  303 ++
 bench/voxel-static-metrics.mjs                |  607 ---
 package.json                                  |    5 +-
 packages/core/package.json                    |    2 +-
 .../core/src/merge/coverPlanarPolygons.ts     |    5 +
 packages/core/src/merge/mergePolygons.test.ts |   22 +
 packages/core/src/merge/mergePolygons.ts      |  100 +-
 .../core/src/merge/optimizePolygons.test.ts   |  190 +-
 packages/core/src/merge/optimizePolygons.ts   |  358 +-
 packages/polycss/package.json                 |    2 +-
 .../polycss/src/api/createPolyScene.test.ts   |    2 +-
 .../src/elements/PolyPolygonElement.test.ts   |    2 +-
 packages/polycss/src/render/polyDOM.test.ts   |  338 +-
 packages/polycss/src/render/polyDOM.ts        |    5 +-
 .../polycss/src/render/renderStats.test.ts    |    5 +-
 packages/polycss/src/render/textureAtlas.ts   |  371 +-
 packages/polycss/src/styles/styles.ts         |   13 +-
 packages/react/package.json                   |    2 +-
 packages/react/src/scene/PolyMesh.tsx         |   11 +-
 packages/react/src/scene/PolyScene.test.tsx   |   15 +
 packages/react/src/scene/PolyScene.tsx        |   22 +-
 packages/react/src/scene/sceneContext.ts      |    2 +
 packages/react/src/scene/textureAtlas.tsx     |  284 +-
 packages/react/src/shapes/Poly.test.tsx       |   17 +
 packages/react/src/styles/styles.test.ts      |    2 +-
 packages/react/src/styles/styles.ts           |   13 +-
 packages/vue/package.json                     |    2 +-
 packages/vue/src/scene/PolyMesh.ts            |   10 +-
 packages/vue/src/scene/PolyScene.test.ts      |   15 +
 packages/vue/src/scene/PolyScene.ts           |    2 +
 packages/vue/src/scene/sceneContext.ts        |    2 +
 packages/vue/src/scene/textureAtlas.ts        |  268 +-
 packages/vue/src/shapes/Poly.test.ts          |   17 +
 packages/vue/src/styles/styles.test.ts        |    2 +-
 packages/vue/src/styles/styles.ts             |   13 +-
 website/public/gallery/vox-manifest.json      |   33 +
 .../public/gallery/vox/floooh/cassette.vox    |  Bin 0 -> 1312 bytes
 .../gallery/vox/floooh/kc85-computer.vox      |  Bin 0 -> 35452 bytes
 .../gallery/vox/floooh/kc85-keyboard.vox      |  Bin 0 -> 3144 bytes
 website/public/gallery/vox/floooh/lcr-c.vox   |  Bin 0 -> 13848 bytes
 .../vox/opengameart-buildings/building-01.vox |  Bin 0 -> 89583 bytes
 .../vox/opengameart-buildings/building-02.vox |  Bin 0 -> 110691 bytes
 .../mini-building-01.vox                      |  Bin 0 -> 36911 bytes
 .../mini-building-02.vox                      |  Bin 0 -> 37643 bytes
 .../vox/opengameart-buildings/tower-01.vox    |  Bin 0 -> 164735 bytes
 .../public/gallery/vox/openhv/battleship.vox  |  Bin 0 -> 109810 bytes
 .../public/gallery/vox/openhv/dropship.vox    |  Bin 0 -> 40567 bytes
 .../public/gallery/vox/openhv/firetruck.vox   |  Bin 0 -> 31663 bytes
 website/public/gallery/vox/openhv/saucer.vox  |  Bin 0 -> 31597 bytes
 website/public/gallery/vox/openhv/turtle.vox  |  Bin 0 -> 43906 bytes
 .../BuilderWorkbench/hooks/useSidebarItems.ts |   15 +-
 .../Dock/folders/useRenderingFolder.ts        |    5 +-
 .../GalleryWorkbench/GalleryWorkbench.tsx     |   18 +-
 .../GalleryWorkbench/presets/attributions.ts  |  129 +-
 .../presets/presetBuilders.ts                 |   19 +-
 .../GalleryWorkbench/presets/presetFiles.ts   |  157 +-
 .../GalleryWorkbench/presets/presetList.ts    |  123 +-
 .../components/VanillaScene/VanillaScene.tsx  |   33 +-
 website/src/content/docs/api/types.mdx        |    2 +
 111 files changed, 4516 insertions(+), 16567 deletions(-)
 rename {tools => .github/scripts}/sync-package-readmes.mjs (97%)
 delete mode 100644 bench/ITERATION_GUARDRAILS.md
 delete mode 100644 bench/ITERATION_LOG.md
 delete mode 100644 bench/NON_VOXEL_ROTATION_HYPOTHESES.md
 delete mode 100644 bench/TRACE_INVESTIGATION.md
 delete mode 100644 bench/VOXEL_FAST_PATH_HYPOTHESES.md
 delete mode 100644 bench/compositor-topology-probe.mjs
 delete mode 100644 bench/coplanar-tolerance-report.mjs
 delete mode 100644 bench/entries/normalize.ts
 delete mode 100644 bench/insurgent-semis-bench.mjs
 create mode 100644 bench/lossy-corpus-bench.mjs
 delete mode 100644 bench/nonvoxel-frame-buckets.mjs
 create mode 100644 bench/nonvoxel-variants.mjs
 rename bench/{README.md => notes/BENCH.md} (84%)
 create mode 100644 bench/notes/PERF_INVESTIGATION.md
 delete mode 100644 bench/perf-cracks.html
 delete mode 100644 bench/polycss-normalize.js
 delete mode 100644 bench/snap-cracks.mjs
 rename bench/{trace-frame-buckets.mjs => trace-analysis.mjs} (64%)
 delete mode 100644 bench/trace-event-args.mjs
 delete mode 100644 bench/trace-summary.mjs
 delete mode 100644 bench/voxel-browser-summary.mjs
 delete mode 100644 bench/voxel-cadence-summary.mjs
 delete mode 100644 bench/voxel-depth-quantization-error.mjs
 delete mode 100644 bench/voxel-dom-order-probe.mjs
 delete mode 100644 bench/voxel-interval-geometry-correlation.mjs
 delete mode 100644 bench/voxel-interval-order-diff.mjs
 delete mode 100644 bench/voxel-interval-profiler.mjs
 delete mode 100644 bench/voxel-interval-screen-metrics.mjs
 delete mode 100644 bench/voxel-occlusion-potential.mjs
 delete mode 100644 bench/voxel-order-metrics.mjs
 delete mode 100644 bench/voxel-order-phase-metrics.mjs
 delete mode 100644 bench/voxel-progress-dashboard.html
 delete mode 100644 bench/voxel-progress-dashboard.mjs
 create mode 100644 bench/voxel-report.mjs
 delete mode 100644 bench/voxel-static-metrics.mjs
 create mode 100644 website/public/gallery/vox/floooh/cassette.vox
 create mode 100644 website/public/gallery/vox/floooh/kc85-computer.vox
 create mode 100644 website/public/gallery/vox/floooh/kc85-keyboard.vox
 create mode 100644 website/public/gallery/vox/floooh/lcr-c.vox
 create mode 100644 website/public/gallery/vox/opengameart-buildings/building-01.vox
 create mode 100644 website/public/gallery/vox/opengameart-buildings/building-02.vox
 create mode 100644 website/public/gallery/vox/opengameart-buildings/mini-building-01.vox
 create mode 100644 website/public/gallery/vox/opengameart-buildings/mini-building-02.vox
 create mode 100644 website/public/gallery/vox/opengameart-buildings/tower-01.vox
 create mode 100644 website/public/gallery/vox/openhv/battleship.vox
 create mode 100644 website/public/gallery/vox/openhv/dropship.vox
 create mode 100644 website/public/gallery/vox/openhv/firetruck.vox
 create mode 100644 website/public/gallery/vox/openhv/saucer.vox
 create mode 100644 website/public/gallery/vox/openhv/turtle.vox

diff --git a/.github/scripts/bump-versions.mjs b/.github/scripts/bump-versions.mjs
index f2c62e27..64ea28f2 100644
--- a/.github/scripts/bump-versions.mjs
+++ b/.github/scripts/bump-versions.mjs
@@ -3,7 +3,7 @@
  * Bump the version of every package under `packages/*` in lockstep.
  *
  * Usage:
- *   node scripts/bump-versions.mjs <patch|minor|major>
+ *   node .github/scripts/bump-versions.mjs <patch|minor|major>
  *
  * Reads the current version from the first package, applies the requested
  * semver bump, writes the new version back to every package.json with a
@@ -16,7 +16,6 @@ import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-// __dirname is .github/scripts — repo root is two levels up.
 const root = resolve(__dirname, "..", "..");
 const packages = ["core", "polycss", "react", "vue"].map((d) =>
   resolve(root, "packages", d, "package.json"),
diff --git a/tools/sync-package-readmes.mjs b/.github/scripts/sync-package-readmes.mjs
similarity index 97%
rename from tools/sync-package-readmes.mjs
rename to .github/scripts/sync-package-readmes.mjs
index 3111152d..f1ffe2aa 100644
--- a/tools/sync-package-readmes.mjs
+++ b/.github/scripts/sync-package-readmes.mjs
@@ -2,7 +2,7 @@ import { copyFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const source = resolve(repoRoot, "README.md");
 const targets = [
   "packages/core/README.md",
diff --git a/.github/workflows/publish-packages.yml b/.github/workflows/publish-packages.yml
index 8cb2e34e..4bd78872 100644
--- a/.github/workflows/publish-packages.yml
+++ b/.github/workflows/publish-packages.yml
@@ -1,7 +1,7 @@
 name: Publish packages
 
 # Manual-only. Bumps every package under `packages/*` in lockstep (using
-# scripts/bump-versions.mjs), builds them, publishes to npm, then commits
+# .github/scripts/bump-versions.mjs), builds them, publishes to npm, then commits
 # the version change and pushes a `v<X.Y.Z>` tag back to main.
 on:
   workflow_dispatch:
diff --git a/.gitignore b/.gitignore
index c0f1c49b..2875a6b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,12 +13,9 @@ packages/vue/tsconfig.tsbuildinfo
 
 # Perf bench — generated artifacts (the harness scripts in bench/ ARE
 # tracked, but the bundled output and per-run results are local-only).
-/bench/polycss.js
-/bench/polycss-elements.js
-/bench/polycss-react.js
-/bench/polycss-render-stats.js
-/bench/polycss-vue.js
+/bench/.generated/
 /bench/results/
+/bench/notes/results/
 
 # Agent-tool internal state — worktree refs, scheduled-task locks, etc.
 /.claude/
diff --git a/AGENTS.md b/AGENTS.md
index 6673accd..93f1741f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -20,7 +20,7 @@ Public API is **mirrored** across React and Vue. Adding a hook on one side witho
 
 ## Rendering model — the mental model
 
-**One visible `Polygon` → one leaf DOM element.** Leaves use canonical CSS primitives where possible and move scale into `matrix3d`; `border-shape` uses a larger fixed primitive because its paint geometry becomes unstable when collapsed to 1px. Textured polygons still pack their local-2D bounding rect (`canvasW × canvasH`) into the atlas. The HTML tag *is* the render strategy — the renderer picks one tag per polygon based on its shape and material.
+**One visible `Polygon` → one leaf DOM element.** Leaves use canonical CSS primitives where possible and move scale into `matrix3d`; clipped solids use fixed primitives because their paint geometry becomes unstable when collapsed to 1px. Textured polygons still pack their local-2D bounding rect (`canvasW × canvasH`) into the atlas. The HTML tag *is* the render strategy — the renderer picks one tag per polygon based on its shape and material.
 
 Raw MagicaVoxel `.vox` sources have a narrower baked-mode fast path: `parseVox` still returns the polygon mesh for bounds, fallback rendering, and public handles, but also preserves a `PolyVoxelSource` marker. Eligible vanilla meshes render exact visible voxel quads as hostless `<b>` leaves with canonical `matrix3d(...)` transforms and projected tile4 scanline DOM order. `.vox` normalization snaps to the nearest integer CSS cell size so direct voxel matrices use integer pixel coordinates without any scale wrapper. Brush colors still receive baked Lambert shading from the scene lights. Dynamic lighting, shadows, stable DOM animation, non-exact voxel geometry, and geometry replaced via `setPolygons` fall back to the polygon renderer.
 
@@ -30,15 +30,15 @@ Voxel-shaped meshes are the exception to "all polygons stay mounted": meshes wit
 
 | Tag | Strategy | When chosen | Paint mechanism | Atlas memory |
 |---|---|---|---|---|
-| `<b>` | **Quads** | Axis-aligned rectangle, or untextured convex quad when the homography passes stability guards | `background: currentColor` on a fixed 64px rectangle; affine and projective quads normalize their `matrix3d` to that primitive, with tiny solid bleed on projective quads to overlap antialias seams | None |
-| `<i>` | **Border-shape clipped solid** | Untextured non-rect on browsers with CSS `border-shape` (Chromium + `pointer:fine` + `hover:hover`) | `border-color: currentColor` on a fixed 64px border-shape primitive, clipped by `border-shape: polygon(...)`; polygon bbox scale and tiny solid bleed are folded into `matrix3d` | None |
+| `<b>` | **Quads** | Axis-aligned rectangle, or untextured convex quad when the homography passes stability guards on non-Safari engines | `background: currentColor` on a fixed 64px rectangle; affine and projective quads normalize their `matrix3d` to that primitive, with tiny solid bleed on projective quads to overlap antialias seams. Safari-family browsers skip the projective quad path and fall through because transformed projective rectangles composite incorrectly there. | None |
+| `<i>` | **Border-shape clipped solid** | Untextured non-rect not caught by the exact corner-shape solid path, on browsers with CSS `border-shape` (Chromium + `pointer:fine` + `hover:hover`) | `border-color: currentColor` on a fixed 16px border-shape primitive, clipped by `border-shape: polygon(...)`; polygon bbox scale and tiny solid bleed are folded into `matrix3d` | None |
 | `<s>` | **Atlas slice** | Textured polygons, or untextured non-rect on browsers without `border-shape` | `background-image` slice of packed bitmap on an auto-budgeted fixed primitive (128px for desktop-class `textureQuality="auto"`, 64px for mobile-class `auto` and explicit numeric quality); atlas position/size and `matrix3d` scale are normalized to the slice, shared textured edges get low-alpha atlas pixels repaired during atlas generation, and solid fallbacks get same-color edge bleed to avoid dark alpha fringes | Bounding-rect area |
-| `<u>` | **Stable solid triangle** | Opt-in for triangles via `renderPolygonsWithStableTriangles` on non-WebKit engines | CSS border-color triangle trick with a fixed canonical 64px border triangle; tiny solid bleed is folded into `matrix3d`. WebKit/Safari falls through to `<s>` because transformed CSS border triangles composite incorrectly there. | None |
+| `<u>` | **Stable solid triangle / corner-shape solid** | Triangles on non-WebKit engines; or untextured non-triangle polygons whose normalized outline is exactly a rectangle with one or more beveled corners on browsers with CSS `corner-shape` | Triangles use a 32px box with two beveled top corners and `background: currentColor` when CSS `corner-shape` support is present, progressively falling back to the CSS border-color triangle trick; exact corner-shape solids use a bare fixed 16px box with inline per-corner radii + `corner-*-shape: bevel` and `background: currentColor`. Tiny solid bleed is folded into `matrix3d`. WebKit/Safari falls through to `<s>` for border triangles because transformed CSS border triangles composite incorrectly there. | None |
 | `<q>` | **Cast shadow leaf** | Per casting polygon when `castShadow: true` and dynamic lighting mode. Applies regardless of caster strategy — `<b>`/`<i>`/`<s>`/`<u>` all produce a `<q>` shadow because only the polygon's outline matters, not its surface. | Same `border-color: currentColor` + `border-shape: polygon(...)` as `<i>`, but transform composes `var(--shadow-proj)` to project the polygon onto the ground plane along the CSS-space light direction | None |
 
-Strategies are ordered cheapest → most expensive. The mesher's job is to maximise `<b>` / `<i>` and minimise `<s>` (see "Meshing implications" below).
+Strategies are ordered cheapest → most expensive. The mesher's job is to maximise `<b>` / `<u>` / `<i>` and minimise `<s>` (see "Meshing implications" below).
 
-Callers can opt out of specific strategies via `strategies: { disable: ["b" | "i" | "u"] }` on `RenderTextureAtlasOptions`. Disabled or unsupported strategies fall through the chain (`b → i → s`, `u → i → s`, `i → s`). `<s>` is the universal fallback and cannot be disabled.
+Callers can opt out of specific strategies via `strategies: { disable: ["b" | "i" | "u"] }` on `RenderTextureAtlasOptions`. Disabled or unsupported strategies fall through the chain (`b → i → s`, `u → i → s`, `i → s`). Disabling `"i"` also disables the exact corner-shape solid branch even though that branch emits a bare `<u>`, because it belongs to the non-triangle clipped-solid family. `<s>` is the universal fallback and cannot be disabled.
 
 The `.vox` fast path emits plain `<b>` elements directly inside the mesh wrapper. They intentionally reuse the cheap quad tag, but they are exact voxel quads with one `matrix3d(...)` per visible quad, ordered by projected tile4 scanline order. Desktop-class documents use a canonical 1px primitive for the cheapest transform shape; mobile-class documents (`pointer: coarse` or `hover: none`) use an 8px primitive and divide the in-plane matrix scale by 8 to preserve identical CSS-space geometry while avoiding large GPU filtering gaps.
 
@@ -64,7 +64,7 @@ All solid/atlas tags work in both modes. The `.vox` direct-matrix fast path is b
 
 This is the load-bearing constraint behind the whole engine. **JavaScript should not run per-frame to paint polygons when the motion can be expressed as a scene, mesh, camera, or light update.** Once the scene is built and the atlas is rasterised, the browser drives most rendering through CSS — `matrix3d` transforms, `calc()`-driven custom properties, `background-blend-mode`, `border-shape`, etc.
 
-The current exception is imported skeletal animation. glTF/GLB skinning changes each polygon independently, so the vanilla stable-DOM animation path samples the active clip in JS, keeps the leaf set mounted, caches baked stable-triangle transform frames, and refreshes baked color on a cadence. That optimized path is the default; do not add a user-facing "baseline vs optimized" toggle or maintain a legacy slow path in product UI.
+The current exception is imported skeletal animation. glTF/GLB skinning changes each polygon independently, so the vanilla stable-DOM animation path samples the active clip in JS, keeps the leaf set mounted, caches baked stable-triangle transform frames, and refreshes baked color on a cadence. On WebKit/Safari, where stable CSS triangles fall through to solid atlas `<s>` leaves, same-topology animation updates keep the existing atlas elements and bitmap URLs mounted, cache transform frames once warmed, and hide briefly degenerate atlas triangles only until the next valid frame. That optimized path is the default; do not add a user-facing "baseline vs optimized" toggle or maintain a legacy slow path in product UI.
 
 | Where JS runs | Where JS does NOT run |
 |---|---|
diff --git a/bench/ITERATION_GUARDRAILS.md b/bench/ITERATION_GUARDRAILS.md
deleted file mode 100644
index f2ab0a09..00000000
--- a/bench/ITERATION_GUARDRAILS.md
+++ /dev/null
@@ -1,253 +0,0 @@
-# Perf-iteration guardrails
-
-Rules of engagement for an automated (or human-driven) loop that proposes
-performance changes to the polycss renderer. Lives next to the bench
-harness because the harness is the only legitimate way to claim a perf
-result — every change has to pass through it.
-
----
-
-## Philosophy: polycss is **CSS-based polygon rendering**
-
-The renderer's job is to translate parsed polygons into DOM + CSS such
-that the browser composites the scene **using the CSS engine, not
-JavaScript-driven per-frame paint**. JS exists at the API surface
-(setOptions, custom elements, React/Vue) but must not own the per-frame
-visual update.
-
-Every proposed change is judged against this rule first. If the change
-moves visual state from CSS into a per-frame JS write loop, it's out
-of scope — even if it's faster.
-
----
-
-## What's on the table
-
-### ✅ Allowed: things you can change
-
-- **CSS rules in `packages/polycss/src/styles/styles.ts`** — cascade
-  variables, `calc()` shapes, `contain` declarations,
-  `transform-style`, `backface-visibility`, `background-blend-mode`,
-  `@property` registrations, the dynamic-mode rule body. The whole
-  cascade is in scope.
-- **Atlas pipeline in `packages/polycss/src/render/textureAtlas.ts`** —
-  packing strategy, page count, encoding (canvas → blob URL), the
-  `applyAtlasBackground` per-element writes, mask-image vs alpha-clip,
-  page consolidation, atlas scale resolution.
-- **`createPolyScene.ts`** — `setOptions` diff logic, `applySceneStyle`
-  internals, the cull bin classifier (`classifyNormal`), how culled
-  polys are hidden, `recomputeAutoCenter`, the auto-center wrapper
-  structure.
-- **DOM structure inside the scene** — adding wrapper divs, changing
-  the parent-of-`<i>` chain, reorganizing how the cull/dir classes
-  attach, as long as the scene element class names users depend on
-  (`.polycss-scene`, `.polycss-mesh`, `<i>`) keep their public meaning.
-- **Mesh post-processing** — the merge / normalize pipeline, dedup,
-  poly-count reduction tactics that preserve visual output.
-- **Bench harness itself** — better filters, more bimodal detectors,
-  new mesh presets, new scenarios, smarter outlier rejection.
-
-### ❌ Off-limits: things you cannot change
-
-- **The four public APIs** — vanilla `createPolyScene` /
-  `<poly-scene>` / React `<PolyScene>` / Vue `<PolyScene>`.
-  Add fields if needed; never break existing ones in an iteration
-  commit. (A breaking change is its own discrete commit, reviewed
-  separately, never bundled with a perf-claim commit.)
-- **`SceneHandle` contract**: `add` / `setOptions` / `destroy` /
-  `host` / `getOptions`. Same rule — additive only mid-iteration.
-- **The CSS-only render philosophy.** No `requestAnimationFrame` loop
-  inside the renderer that writes inline styles per polygon per frame.
-  No JS-computed `style.backgroundColor` / `style.filter` /
-  `style.opacity` writes per polygon per frame to apply visual state.
-  The cascade is the renderer; JS sets the inputs.
-- **Visual output.** Every change must pass `pnpm bench:visual` (mean
-  ΔE per channel ≤ 0.01 on chicken + rock1 × 3 azimuths). A change
-  that fails visual is not a perf change — it's a different
-  rendering. Reject.
-- **Existing 820 tests.** All must stay green. A change that needs to
-  drop tests should also explain *why* the test was checking the
-  wrong thing.
-- **Browser support.** No `chrome://flags`-only features. No
-  experimental APIs not in evergreen Chrome / Safari / Firefox
-  baselines. Houdini Paint API in particular is still partial — only
-  acceptable as a progressive enhancement, not a requirement.
-
-### 🤔 Gray areas (need an explicit call)
-
-- **API surface additions.** Adding a new option (e.g., a
-  `mergeStrategy` knob) is fine in principle but should land as its
-  own commit with tests, not bundled with a perf claim that uses it.
-- **New `textureLighting` modes.** Allowed only if they stay
-  CSS-driven (e.g., a new cascade shape, a Houdini Paint worklet
-  with a CSS fallback). Specifically forbidden: any mode whose
-  per-frame work is JS DOM mutation.
-- **Removing back-compat shims.** Case-by-case, but never inside
-  an iteration commit — give it its own focused PR.
-
----
-
-## How an iteration is structured
-
-Each iteration follows a strict shape so results are reproducible and
-attributable.
-
-### 1. Hypothesis
-
-A single sentence about what changes and why it might help.
-
-> *Hoist the Lambert dot product into a per-poly registered
-> property so rgb() doesn't recompute it 3× per channel.*
-
-If the hypothesis spans multiple unrelated changes, split it. One
-hypothesis = one iteration commit.
-
-### 2. Baseline
-
-Run the bench against the *current* main on the relevant mesh **before**
-touching anything. Save:
-
-```sh
-pnpm bench:perf -- --label baseline
-```
-
-Output goes to `bench/results/baseline.json`.
-
-### 3. Apply the change
-
-Single, surgical diff. If the hypothesis turns out to need ancillary
-refactors, abandon and re-scope — surgical first, structural later.
-
-### 4. Re-bench + visual diff
-
-```sh
-pnpm bench:perf -- --label after
-pnpm bench:visual                # MUST pass
-pnpm -r test --run               # MUST pass
-```
-
-### 5. Decide
-
-Compare `baseline.json` vs `after.json` on these axes:
-
-| Metric                                | Acceptance criterion                         |
-| ------------------------------------- | -------------------------------------------- |
-| `dynamic.light_rotate.fps_p50`        | **Primary.** Improve ≥ 2 % on at least one mesh, OR |
-| `dynamic.camera_rotate.fps_p50`       | Improve ≥ 2 %, OR                             |
-| `dynamic.static.fps_p50`              | Improve ≥ 2 % without regressing the others  |
-| Any of the above                      | **Cannot regress** > 2 % on any mesh         |
-| `is_bimodal` flag                     | Cannot newly turn on for any scenario        |
-| Visual diff `mean_delta`              | Each frame ≤ 0.01 (no exceptions)            |
-| All package tests                     | All 820 must pass                            |
-| All four renderer paths               | Cross-renderer regression > 2 % cancels even if vanilla wins |
-
-Numbers below the noise floor (~2 %) don't count. Run-to-run variance
-of ~1 % is normal even with the fresh-chromium-per-scenario fix.
-
-### 6. Document outcome
-
-Each iteration leaves a row in the iteration log (proposed location:
-`bench/ITERATION_LOG.md`) with:
-
-- Hypothesis ID, one-line summary
-- Before / after p50 for the primary metric on each test mesh
-- Visual diff max ΔE
-- Verdict: **WIN** / **LOSE** / **FLAT** / **REJECT** (visual or test failure)
-- One-sentence "why" — especially important for LOSE/FLAT, because
-  knowing *why* an idea didn't work prevents the next iteration from
-  proposing a sibling that fails for the same reason.
-
-### 7. Tree-search winners; don't chase losers
-
-If a hypothesis WINs, generate 2–3 sibling hypotheses that **build on**
-the win (push the same lever further, combine with adjacent ideas,
-test on a different mesh). If it LOSEs/FLATS, *do not* propose a near-
-duplicate hypothesis — the cause that killed it likely kills the
-sibling too.
-
----
-
-## Standard test meshes
-
-These three together cover the surface area worth measuring:
-
-| Mesh     | Why it's interesting                                                |
-| -------- | ------------------------------------------------------------------- |
-| `chicken`| Small (648 polys), flat-color MTL materials. Cascade-driven path.   |
-| `rock1`  | Tiny (194 polys), UV-mapped texture (`map_Kd`). Atlas-blob path.    |
-| `saucer` | Large (6384 polys), procedural flat color. Stresses the cascade walk. |
-
-Run hypotheses against **all three** before drawing conclusions. A
-change that helps one and hurts another is a trade-off, not a win.
-
-For "where does it break down?" research, bench `synth-10k`,
-`synth-30k`, `synth-50k` — UV-sphere meshes built in the browser.
-
----
-
-## Standard scenarios
-
-The five always-on scenarios:
-
-```
-dynamic.static          (idle frame floor under cascade)
-dynamic.light_rotate    (light-direction changes per frame)   ← primary
-dynamic.camera_rotate   (camera transform changes per frame)
-baked.static            (idle frame floor without cascade)
-baked.camera_rotate     (camera transform changes, no light cost)
-```
-
-Per renderer (html / vanilla / react / vue) → 5 × 4 = 20 rows per mesh.
-Run all four renderers on the primary metric to spot framework-tax
-regressions.
-
----
-
-## Cataloged dead-ends (don't repropose)
-
-These have all been measured at one point or another and either
-violated the architecture or regressed the numbers. Save the cycle:
-
-| Hypothesis                                               | Why it doesn't work                                                          |
-| -------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| `textureLighting: "dynamic-js"` (per-frame JS Lambert)   | Architecturally out of scope (CSS-only philosophy).                          |
-| `style.filter` on per-poly elements driven by JS         | Same.                                                                        |
-| `clip-path` instead of `mask-image`                      | 4000+ `clip-path`s in `preserve-3d` = ~15 s/frame. Catastrophic.             |
-| `opacity: 0.999` to force compositor layer               | Triple regression on light + camera + visual fail. Layer promo fights `preserve-3d`. |
-| Per-poly `--polycss-tint` registered-property route      | Cascade walk still visits all polys; calc resolution into `background-color` re-paints. No win. |
-| `filter: brightness(calc(...))` on the CSS-driven path   | Same — `calc()` in CSS still triggers `UpdateLayoutTree`.                    |
-| `className`-swap to apply per-frame state                | Rule re-matching cost > inline style cost when `mask-image` is present.      |
-| Bench-only frame-rate quantization to inflate fps        | Not a real win — only "worked" because identical-value writes were skipped, not from temporal throttling. |
-| Atlas page consolidation (4 → 2 pages)                   | Larger atlas → much slower `toBlob()` encoding bleeds into the measurement window. Real regression. |
-
-Re-proposing one of these requires explaining what changed since last
-time — usually nothing has, and the answer is no.
-
----
-
-## Output / housekeeping
-
-- Per-iteration JSON lives in `bench/results/<label>.json` (gitignored).
-- Iteration log goes in `bench/ITERATION_LOG.md` (tracked).
-- Successful changes commit as `perf(<area>): <summary>`. Visual-diff
-  baselines re-record only when the iteration *intentionally* changes
-  pixel output — and that's its own commit (`fix(bench): re-record
-  baselines after <reason>`), separate from the perf change itself.
-- Failed changes don't commit code at all — only the log row.
-
----
-
-## When to stop
-
-The loop has natural stopping criteria. Stop when:
-
-- Three consecutive iterations land FLAT or LOSE on the primary metric.
-- The remaining hypothesis queue is exhausted and no new ones surface
-  from the most recent traces / measurements.
-- The trace-level cost driver (e.g., `UpdateLayoutTree` walking N
-  polys) is structural — solving it would require an architecture
-  change, not a tactical edit.
-
-Claiming "no more wins" early, with evidence, is more honest than
-churning. A loop that stops with a clear floor reading is a successful
-loop, not a failed one.
diff --git a/bench/ITERATION_LOG.md b/bench/ITERATION_LOG.md
deleted file mode 100644
index 2bf7997a..00000000
--- a/bench/ITERATION_LOG.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Perf-iteration log
-
-Append-only log of perf hypotheses tested against polycss. One row per
-hypothesis. Companion doc to `bench/ITERATION_GUARDRAILS.md` — read that
-first for what's allowed / off-limits.
-
-## Schema
-
-| Iter | ID    | Branch                  | Area | One-line hypothesis | chicken Δ% | rock1 Δ% | saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|-------|-------------------------|------|---------------------|-----------:|---------:|----------:|--------|-------|---------|-------|
-| 1    | H1-A  | perf/h1a-…              | …    | …                   |       +x.x |     +x.x |      +x.x | pass   | 820   | WIN     | …     |
-
-- **Δ%** = `dynamic.light_rotate.fps_p50` change vs current `perf-loop-v2`
-  baseline. Negative = regression.
-- **Verdict**: `WIN` (≥2% on at least one mesh, no >2% regression elsewhere),
-  `LOSE` (>2% regression), `FLAT` (within ±2% noise floor),
-  `REJECT` (visual or test failure — no perf claim possible).
-
-## Iterations
-
-<!-- Iteration rows go below this line. Newest at the bottom. -->
-
-### Iteration 1
-
-| ID   | Branch                         | Area | Hypothesis | chicken Δ% | rock1 Δ% | saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|--------------------------------|------|------------|-----------:|---------:|----------:|--------|-------|---------|-------|
-| H1-A | perf/h1a-content-visibility    | CSS containment / content-visibility | Replace `display:none` with `content-visibility:hidden` on cull-DIR rules to preserve rendering context across cull flips | -22.4 | -12.6 | +13.0 | pass | 820 | LOSE | content-visibility:hidden keeps culled `<i>` in layout so the cascade still walks them; saucer gains (saves layout teardown on 6k polys) but small meshes regress sharply — preserve-3d context pays per culled-but-laid-out element |
-| H1-B | perf/h1b-skip-redundant-setops | DOM shape / per-poly attribute writes | Skip redundant style writes in `setOptions`: dispatch only changed sub-sections (light vars vs camera vs cull) so light-only frames skip 6 `classList.toggle()` + 6 unchanged style writes | ~0 | 0 | 0 | pass | 820 | FLAT | JS overhead in the per-frame `setOptions` path is not the bottleneck. The 6 skipped `classList.toggle()` calls are completely eclipsed by the cascade walk recomputing `--polycss-lambert` + `background-color` on N `<i>` (~60 ms for saucer's 6 384 polys) |
-| H1-C | perf/h1c-premult-intensity     | @property count reduction | Pre-multiply light/ambient color × intensity into 6 vars; drop `--polycss-li`/`-ai`; simplify per-poly calc() from 5 → 3 var() reads per channel | +0.3 | ~0 | ~0 | pass | 820 | FLAT | Saucer (6k polys) flat at +0.3 %. Chicken/rock1 too noisy to read signal (±13 % run-to-run). Reducing cascade `@property` count from 11 → 9 doesn't move the per-frame UpdateLayoutTree cost on large meshes |
-
-#### Iteration 1 takeaways
-
-- **Convergent finding**: JS-side micro-opts (per-frame `setOptions` writes, `@property` count, `var()` read count) all measure FLAT. The bottleneck is the **CSS cascade walk over N `<i>` elements** when scene-root custom properties change — ~60 ms per `dynamic.light_rotate` frame on saucer (6 384 polys).
-- **Noise floor on small meshes is ±13 %** (chicken 648, rock1 192 polys) — useless for measuring sub-10 % effects. Treat saucer as the primary signal until we add larger synth meshes (synth-10k / synth-30k) or per-mesh repeated runs.
-- **`content-visibility: hidden` on cull rules splits by mesh size**: +13 % saucer, −22 % chicken, −12 % rock1 in `preserve-3d` context (LOSE overall). Worth re-attempting with mesh-size-aware dispatch in iteration 2.
-- **Three avenues left** for iteration 2: (a) make the cascade walk faster (containment, layer promotion, scope), (b) reduce effective N (poly grouping, mesh-tier dispatch), (c) move per-frame work to compositor-only (will-change, registered properties + transitions).
-
-### Iteration 2
-
-| ID   | Branch                       | Area | Hypothesis | chicken Δ% | rock1 Δ% | saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|------------------------------|------|------------|-----------:|---------:|----------:|--------|-------|---------|-------|
-| H2-A | perf/h2a-will-change-scene   | GPU layer promotion | (agent picks: `will-change: transform` on `.polycss-scene` to promote the scene to its own composited layer; theory is per-frame cascade var changes still trigger the walk but layout/paint work is bounded to the layer) | – | – | – | – | – | pending | – |
-| H2-B | perf/h2b-mesh-tier-dispatch  | Mesh-size-aware cull | JS sets `data-poly-tier="large"` on `.polycss-scene` when total poly count ≥ 4000; CSS cull rules use `content-visibility:hidden` for large tier and keep `display:none` for default — composes H1-A's saucer win without small-mesh loss | +46.8 (noise) | +1.2 | +13.4 | pass | 826 | WIN | Saucer +13.4 % (matches H1-A's +13 %). Chicken/rock1 no regression (chicken +46.8 % is run-to-run noise at 648 polys, well within ±13 % floor; no mesh went negative). Threshold 4000 puts saucer (6384) on content-visibility path, chicken (648) and rock1 (192) on unchanged display:none path. |
-| H2-C | perf/h2c-paint-containment   | Per-mesh paint containment | (agent picks: add `contain: paint` on `.polycss-mesh` so each mesh is a paint-isolated subtree; theory is paint invalidation is bounded per mesh and the compositor can reuse cached rasters across light-rotate frames) | – | – | – | – | – | pending | – |
-
-### Iteration 3
-
-| ID   | Branch                    | Area | Hypothesis | chicken Δ% | rock1 Δ% | saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|---------------------------|------|------------|-----------:|---------:|----------:|--------|-------|---------|-------|
-| H3-C | perf/h3c-css-scope        | CSS cascade scope | Wrap all `.polycss-scene`-rooted CSS rules in `@scope (.polycss-scene)` so the browser can skip these candidate rules for elements outside any `.polycss-scene` subtree, reducing selector-matching work in the cascade walk | – | – | +6.7 | pass | 826 | WIN | Vanilla saucer +6.7 % (12.45 → 13.29 fps; confirmed across two after-runs). HTML saucer also +0.3 % (noise). Per-poly cascade walk sees fewer candidate rules even for in-scope elements — likely because `@scope` allows the engine to short-circuit rule-set evaluation at the scope boundary before descending. `@scope` is live in Chrome 118+, Safari 17.4+, Firefox 128+ (all current evergreen baselines). Chicken/rock1 not measured (noise floor dominates at small poly counts). |
-
-### Iteration 4
-
-| ID   | Branch                          | Area | Hypothesis | chicken Δ% | rock1 Δ% | saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|---------------------------------|------|------------|-----------:|---------:|----------:|--------|-------|---------|-------|
-| H4-B | perf/h4b-coplanar-merge         | Parse-time N reduction | Apply `mergePolygons` in `loadMesh` so `parseResult.polygons` is already merged; React/Vue bench entries were rendering raw fan-triangulated polygons (N=6384) directly as `<Poly>` children, bypassing the merge that vanilla `createPolyScene.add()` applied. Moving merge to parse time fixes all four renderer paths at once. | ~0 (noise) | ~0 (noise) | +22.6 (vanilla), +56 (react), +279 (vue) | pass | 826 | WIN | Saucer N: 6384 → 4052 (36.5% reduction). Vanilla saucer `dynamic.light_rotate`: 10.87 → 13.33 fps (+22.6%); React: 9.23 → 14.42 fps (+56.2%); Vue: 4.47 → 16.95 fps (+279%). Root cause: React/Vue bench entries used `parseResult.polygons.map((p) => <Poly>)` which bypassed the merge that lived in `createPolyScene.add()` — React/Vue were walking 6384 `<i>` elements in the cascade while vanilla had 4052. Chicken/rock1 are noise-floor dominated. Visual diff max ΔE 0.00029 (well below 0.01 threshold). |
-
-### Iteration 5
-
-| ID   | Branch                    | Area | Hypothesis | vanilla saucer Δ% | react saucer Δ% | vue saucer Δ% | Visual | Tests | Verdict | Notes |
-|------|---------------------------|------|------------|------------------:|----------------:|--------------:|--------|-------|---------|-------|
-| H5-C | perf/h5c-other-lever      | React reconciliation | Wrap `<Poly>` in `React.memo()` so stable polygon children skip re-renders when parent state changes (e.g. `rotY` or `lightDir` updates) — eliminates O(N) JS function-body cost across 4052 `<Poly>` instances per frame. | +1.0 (noise) | +27.7 | -8.5 (noise) | pass | 826 | WIN | Baseline: vanilla 10.82 / react 13.32 / vue 15.00 fps (`dynamic.light_rotate`). After: vanilla 10.93 / react 17.01 / vue 13.73. React `light_rotate` +27.7% (memo prevents 4052 function-body calls per frame when only scene-root CSS vars change). Vanilla FLAT — change is React-only. Vue FLAT (−8.5% within ±13% noise floor; Vue does not use the React `Poly` component). `camera_rotate` partial improvement: react 12.08 → 13.33 fps (+10.3%); residual cost is React's O(N) props-comparison pass over 4052 `<Poly>` children even when memo skips their bodies (children prop is recreated each frame from `polygons.map()`). Visual diff max ΔE 0.00032. |
diff --git a/bench/NON_VOXEL_ROTATION_HYPOTHESES.md b/bench/NON_VOXEL_ROTATION_HYPOTHESES.md
deleted file mode 100644
index f5c8181f..00000000
--- a/bench/NON_VOXEL_ROTATION_HYPOTHESES.md
+++ /dev/null
@@ -1,151 +0,0 @@
-# Non-Voxel Rotation Hypotheses
-
-Actionable ledger for non-voxel rotation performance work. This tracks
-bench-only experiments first; product renderer changes need visual validation
-and API/cross-package review before they move out of `bench/`.
-
-## Corpus
-
-The first pass uses eight representative non-voxel models:
-
-| ID | Model | Why it is in the set |
-| --- | --- | --- |
-| `chicken` | OBJ + MTL | Small flat-color mesh, mostly merged quads. |
-| `rock1` | OBJ + MTL | Small UV-textured atlas-heavy mesh. |
-| `saucer` | OBJ | Larger untextured rotation stress case. |
-| `teapot` | OBJ | Smooth curved solid mesh with many quads. |
-| `ducky` | GLB | Small GLB with many solid triangles. |
-| `elephant` | GLB | Organic low-poly shape. |
-| `policecar` | GLB | Mechanical rectilinear shape. |
-| `bicycle` | GLB | Thin separated geometry with many parts. |
-
-Run the corpus with:
-
-```sh
-node bench/nonvoxel-rotation-bench.mjs
-```
-
-Use targeted variants while iterating:
-
-```sh
-node bench/nonvoxel-rotation-bench.mjs \
-  --models teapot,bicycle,elephant,policecar \
-  --variants baseline,force-atlas,no-stable-tri,order-tile4,no-will-change \
-  --warmup 2000 --sample 3000 \
-  --run-order round-robin \
-  --json bench/results/nonvoxel-rotation-a2-confirm.json
-```
-
-Use frame buckets when whole-run p95 is ambiguous:
-
-```sh
-node bench/nonvoxel-frame-buckets.mjs \
-  --mesh glb:Elephant.glb \
-  --variant baseline \
-  --warmup 2000 \
-  --sample 5000 \
-  --no-trace \
-  --label nonvoxel-buckets-elephant-baseline
-```
-
-Check visual parity before treating transform-topology variants as candidates:
-
-```sh
-node bench/nonvoxel-visual-compare.mjs \
-  --mode baked \
-  --models bicycle,elephant,policecar \
-  --variants scene-split-target,scene-host-perspective,scene-transform-perspective,no-will-change,scene-matrix3d \
-  --json bench/results/nonvoxel-visual-a12-baked-transform-topology.json
-```
-
-## Current Read
-
-- Current active scope is baked rotation. Dynamic-mode probes remain in the
-  history below, but they are paused while the baked path is being isolated.
-- Do not generalize voxel DOM-order wins directly to non-voxel meshes. The
-  corrected post-render DOM-order probes preserve tag counts, and Tile4 still
-  regresses or flattens on most non-voxel meshes under interleaved repeats.
-- Force-atlas is rejected as a general rotation optimization. A short-window
-  Teapot win disappeared with a normal warmup; confirmed runs lose on Teapot,
-  Bicycle, Elephant, and Policecar.
-- Disabling stable CSS triangles is not a broad win. Short Bicycle movement
-  flattened under longer confirmation; Teapot regressed and Elephant/Policecar
-  were flat.
-- Removing scene `will-change` is mixed/flat, matching the voxel conclusion
-  that root transform flags are not the missing browser path.
-- Baked transform-topology probes produced large p95 wins only when they
-  changed projection. `split-target`, `host-perspective`, and
-  `transform-perspective` fail static visual parity on GLBs and are invalid as
-  optimization candidates in their current form.
-- The visual-safe transform variants (`matrix3d`, `no-will-change`) are not
-  broad wins. A full eight-model baked random run rejected them: Saucer
-  regressed hard, Teapot/Bicycle/Rock/Ducky/Elephant were flat, and Policecar
-  was seed/bucket sensitive.
-- Fixed-size baked leaf buckets are visually safe but not broad. They regress
-  Saucer, flatten Bicycle/Elephant/Policecar, and produce a repeatable Teapot
-  win. Treat that as a targeted clue about dense curved solid meshes, not a
-  default renderer change.
-- CSS keyframe rotation remains an auto-rotate-only probe. It can change p50 in
-  short windows, but p95 does not consistently improve for interactive-style
-  rotation comparisons.
-- Older `polygonOrder` results changed render planning as well as DOM order,
-  because basis-hint selection depends on polygon array order. The runner now
-  uses `domOrder` for order variants so strategy tag counts stay stable.
-- The next useful work is lower-level attribution for the remaining slow
-  baked buckets, not more broad strategy toggles. Whole-run p95 alone is too
-  noisy near cadence thresholds.
-
-## Measurement Notes
-
-- Generic gallery meshes now support `glb:path`, `obj:path`, and `vox:path`.
-  Numeric URL params use explicit fallback parsing; older direct generic-mesh
-  runs before this fix are invalid if they omitted `zoom`, `targetSize`,
-  `rotX`, or `rotY`.
-- The new non-voxel scripts also use explicit numeric fallback parsing. Missing
-  `--warmup` and `--sample` now resolve to the documented defaults instead of
-  `0`.
-- `nonvoxel-rotation-bench.mjs` supports `--run-order grouped|round-robin|random`
-  and `--seed`. Use `round-robin` or `random` for any near-threshold comparison;
-  grouped runs are only for quick triage.
-- `nonvoxel-frame-buckets.mjs --no-trace` is the least perturbing cadence
-  view. Trace mode is still useful for event attribution, but it changed the
-  cadence enough in early Elephant runs that no-trace bucket counts should be
-  checked first.
-- `nonvoxel-visual-compare.mjs` compares static baked screenshots against the
-  baseline with the FPS overlay hidden. Treat any performance win that fails
-  this parity gate as invalid until the transform math is made equivalent.
-
-## Experiments
-
-| ID | Status | Hypothesis | Result | Next |
-| --- | --- | --- | --- | --- |
-| NV-A1 | Tested | Voxel-inspired variants may produce immediate non-voxel rotation wins. | Short 8-model pass (`700ms` warmup, `1500ms` sample) found apparent wins, but also obvious counterexamples: Tile4 order hurt Chicken/Rock, force-atlas hurt most models, and Teapot force-atlas was likely an atlas warmup artifact. Results in `bench/results/nonvoxel-rotation-a1-short.json`. | Treat only as a triage pass. Confirm any large signal with normal warmup. |
-| NV-A2 | Rejected | Force-atlas, no-stable-triangle, Tile4 order, or no-will-change are broad wins. | Normal-warmup confirmation on Teapot/Bicycle/Elephant/Policecar rejected force-atlas hard (`-37%` to `-40%` on GLBs, `-10%` on Teapot). No-stable-triangle and no-will-change were flat/mixed. Tile4 was flat except a one-run Elephant p95 bump. Results in `bench/results/nonvoxel-rotation-a2-confirm.json`. | Keep strategy toggles as diagnostics, not product candidates. |
-| NV-A3 | Flat | Elephant Tile4 order is a real organic-mesh ordering win. | Three repeats at `2000ms` warmup / `5000ms` sample flattened p95 (`23.9 -> 24.0 fps`) but improved median p99 tail (`58.3 -> 50.0ms`). Results in `bench/results/nonvoxel-rotation-a3-elephant-order.json`. | Reopen order only with frame-bucket evidence showing a repeatable tail reduction without p95 loss. |
-| NV-A4 | Tested | Frame buckets can explain the Elephant Tile4 p99 tail. | Added `bench/nonvoxel-frame-buckets.mjs`. No-trace baked Elephant baseline had 616 leaves (`b/i/s/u/q=445/0/1/170/0`) with `x4_plus:47`, `dt p95=83.5ms`; Tile4 had the same tag mix with `x4_plus:41`, but `dt p95=100.2ms`. Results in `bench/results/nonvoxel-buckets-elephant-*-a6-notrace-fixed-defaults.json`. | Tile4 is not a clean Elephant win. Use buckets to find slow cadence classes before adding new variants. |
-| NV-A5 | Rejected | Dynamic mode changes the winner set for GLB strategy/order probes. | Single-run dynamic GLBs showed large apparent wins, but three repeats rejected them: Bicycle Tile4 was flat and no-stable/no-will-change were `-19%`; Elephant and Policecar were flat within about `1%`. Results in `bench/results/nonvoxel-rotation-dynamic-a2-glb-repeats.json`. | Do not ship dynamic-specific strategy toggles from this signal. |
-| NV-A6 | Inconclusive | Teapot dynamic Tile4/no-stable/no-will-change are real wins. | Three repeats showed `+17%` to `+19%` p95, but an order-sanity run produced baseline p95 values from `10.8` to `23.4` fps in the same process while identical-tag `no-will-change` was also positive. Results in `bench/results/nonvoxel-rotation-dynamic-a3-teapot-repeats.json` and `bench/results/nonvoxel-rotation-dynamic-a4-teapot-order-sanity.json`. | Add randomized/interleaved order or frame-bucket attribution before using Teapot dynamic p95 for decisions. |
-| NV-A7 | Fixed | Ordering probes should test DOM order, not render-planning order. | Added dedicated `nonvoxel-vanilla.html` with `domOrder` and moved runner order variants to post-render DOM reordering, leaving the shared `perf-vanilla.html` clean. Teapot smoke confirmed Tile4 now keeps baseline tags (`3071/0/40/10/0`). Results in `bench/results/nonvoxel-rotation-smoke-dom-order.json`. | Treat earlier `polygonOrder` results as diagnostic only; use corrected `domOrder` results for decisions. |
-| NV-A8 | Rejected | Corrected Teapot dynamic Tile4 is a stable win. | Round-robin corrected Tile4 showed `+11%` p95 with identical tags, but deterministic random ordering flattened Tile4 to `-0.3%`. `no-stable-tri` and `no-will-change` also failed randomized confirmation. Results in `bench/results/nonvoxel-rotation-dynamic-a7-teapot-domorder-round-robin.json` and `bench/results/nonvoxel-rotation-dynamic-a8-teapot-domorder-random.json`. | Do not move Tile4 into product from Teapot dynamic alone. |
-| NV-A9 | Mostly rejected | Corrected Tile4 DOM order helps representative GLBs. | Baked/dynamic GLB pass with identical tags rejected Tile4 on Bicycle, flattened Elephant, and only showed a one-pass Policecar baked bump. Results in `bench/results/nonvoxel-rotation-a9-glb-domorder-both.json`. | Check any isolated positive with randomized repeats and buckets. |
-| NV-A10 | Rejected | Policecar baked Tile4 is a stable corrected DOM-order win. | A no-trace bucket pair showed fewer very slow frames for Tile4, but randomized five-repeat rotation flattened to `+0.6%` p95 with identical tags. Results in `bench/results/nonvoxel-buckets-policecar-baked-*-a10-domorder.json` and `bench/results/nonvoxel-rotation-a11-policecar-baked-domorder-random.json`. | Leave Tile4 as a diagnostic variant, not a product rule. |
-| NV-A11 | Invalid | Baked scene transform topology can improve GLB rotation without changing DOM leaves. | `split-target`, `host-perspective`, and `transform-perspective` gave large p95 wins on Bicycle/Elephant/Policecar with identical tag counts, but static visual parity failed badly (`meanDelta` about `0.04-0.09`, `24-48%` changed pixels). `matrix3d` and `no-will-change` passed visual parity. Results in `bench/results/nonvoxel-rotation-a12-baked-transform-topology.json` and `bench/results/nonvoxel-visual-a12-baked-transform-topology.json`. | Do not use projection-changing topology variants as candidates until equivalence is proven. |
-| NV-A12 | Rejected | Visual-safe baked topology variants are broad wins. | Five-repeat random on Teapot/Bicycle/Elephant/Policecar showed `matrix3d` flat except one Policecar run and `no-will-change` positive on Elephant/Policecar, but three-run no-trace buckets showed Policecar was cadence-noisy. A full eight-model random pass then rejected both broadly: Chicken `-2%`, Saucer `-12%` to `-19%`, Teapot/Bicycle/Rock/Ducky/Elephant flat, Policecar `matrix3d +0.9%` and `no-will-change -22.8%`. Results in `bench/results/nonvoxel-rotation-a13-baked-visual-safe-topology-random.json`, `bench/results/nonvoxel-buckets-*-a14-visualsafe.json`, and `bench/results/nonvoxel-rotation-a16-baked-visual-safe-full-corpus-random.json`. | Leave `matrix3d` and `no-will-change` as diagnostics, not defaults. |
-| NV-A13 | Tested | Trace can explain the Elephant `no-will-change` no-trace p95 bump. | No-trace buckets showed Elephant baseline at `20.0-20.2 fps` p95 with `x4_plus=61-66`, and `no-will-change` at `24.0 fps` with `x4_plus=54-58`; however trace mode flattened both variants back to about `20 fps` p95 with the same `x4_plus=69`. Results in `bench/results/nonvoxel-buckets-elephant-baked-*-a14-visualsafe.json` and `bench/results/nonvoxel-buckets-elephant-baked-*-a15-trace.json`. | Prefer no-trace cadence for decision-making; use trace only after a signal survives multiple seeds. |
-| NV-A14 | Mixed | Fixed-size baked leaf buckets improve compositor subtree shape without changing pixels. | Added `leafBucketSize` and `leaf-buckets-64/128/256`. Static visual parity passed with zero pixel delta on Saucer, Teapot, Bicycle, Elephant, and Policecar. Rotation was mixed: Saucer regressed (`-13%` to `-15%`), Bicycle/Elephant/Policecar were flat, and Teapot improved about `+12%`. Results in `bench/results/nonvoxel-visual-a17-baked-leaf-buckets.json` and `bench/results/nonvoxel-rotation-a18-baked-leaf-buckets-random.json`. | Not a broad default. Confirm Teapot separately before treating it as a mesh-class clue. |
-| NV-A15 | Confirmed narrow | Teapot's fixed leaf-bucket win is repeatable. | Teapot-only five-repeat random confirmed `leaf-buckets-64/128/256` at `+10.0%/+11.2%/+11.9%` p95. No-trace buckets show the same 3121 leaves and tags; `leaf-buckets-256` removes the rare `x4_plus` frame and shifts some frames from `x3` to `x2`, but does not help other representative meshes. Results in `bench/results/nonvoxel-rotation-a19-teapot-baked-leaf-buckets-random.json` and `bench/results/nonvoxel-buckets-teapot-baked-*-a20*.json`. | Investigate why dense solid curved quads react to shallow wrapper chunking; keep the variant bench-only. |
-
-## Candidate Next Tests
-
-1. Use `nonvoxel-frame-buckets.mjs --no-trace` on the remaining slow cases
-   first, then trace only the buckets that stay reproducible.
-2. Look for baked-only non-order hypotheses on the slow classes: per-normal
-   grouping shape, stable triangle vs atlas only on triangle-heavy meshes,
-   atlas/solid mixed scenes, and whether compositor cadence correlates with
-   leaf transform magnitude or projected depth span.
-3. For Teapot-like dense solid quad meshes, compare fixed leaf chunks against
-   normal/area/depth-preserving chunks to find whether the benefit is wrapper
-   count, local spatial coherence, or a Chrome scheduling threshold.
-4. Test active CSS keyframes only as an auto-rotate feature path, separate from
-   interactive camera rotation, because JS-scrubbed transform changes still
-   dirty the 3D subtree in the voxel probes.
diff --git a/bench/TRACE_INVESTIGATION.md b/bench/TRACE_INVESTIGATION.md
deleted file mode 100644
index d18ea150..00000000
--- a/bench/TRACE_INVESTIGATION.md
+++ /dev/null
@@ -1,659 +0,0 @@
-# Trace Investigation
-
-This is the next phase after the voxel fast-path comparison. The goal is no
-longer "close the voxcss gap". Polycss is already in the same performance
-class and wins on several model classes. The next breakthrough has to come
-from understanding the Chrome trace: which browser subsystem burns frame
-budget, what DOM/CSS shape triggers it, and which renderer changes are worth
-testing because the trace predicts them.
-
-## Current Read
-
-Earlier trace captures that established the compositor-heavy shape, current
-voxel fast path, one run each:
-
-| Model | Leaves | FPS p95 | PAC ms/frame | Layerize ms/frame | DrawProps ms/frame | Draw ms/frame | Paint ms/frame | Raster ms/frame |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| `scene_vehicles1.vox` | 752 | 112.4 | 0.48 | 0.48 | 0.38 | 0.45 | 0.00 | 0.00 |
-| `MechaGolem.vox` | 1789 | 62.6 | 1.11 | 1.11 | 1.09 | 1.20 | 0.01 | 0.00 |
-| `AncientCrashSite.vox` | 5233 | 40.0 | 3.84 | 3.84 | 3.77 | 4.65 | 0.02 | 0.00 |
-| `Garden.vox` | 7186 | 24.0 | 4.62 | 4.62 | 5.18 | 6.42 | 0.09 | 0.00 |
-
-`PAC` is `PaintArtifactCompositor::Update`. These trace events are nested, so
-the columns are not additive. They are diagnostic landmarks.
-
-Deeper control traces, same DOM:
-
-| Model | Motion | FPS p95 | PAC ms/frame | DrawProps ms/frame | Script ms/frame |
-| --- | --- | ---: | ---: | ---: | ---: |
-| `Garden.vox` | no transform update | 111.2 | 0.00 | 0.00 | 0.08 |
-| `Garden.vox` | repeated same transform value | 113.6 | 0.00 | 0.00 | 0.13 |
-| `Garden.vox` | changing rotation | 20.5 | 4.65 | 5.15 | 0.37 |
-| `AncientCrashSite.vox` | no transform update | 112.5 | 0.00 | 0.00 | 0.08 |
-| `AncientCrashSite.vox` | repeated same transform value | 112.4 | 0.00 | 0.00 | 0.14 |
-| `AncientCrashSite.vox` | changing rotation | 40.0 | 3.85 | 3.80 | 0.25 |
-| `MechaGolem.vox` | no transform update | 112.4 | 0.00 | 0.00 | 0.07 |
-| `MechaGolem.vox` | repeated same transform value | 111.1 | 0.00 | 0.00 | 0.13 |
-| `MechaGolem.vox` | changing rotation | 62.3 | 1.10 | 1.07 | 0.16 |
-
-This separates three things:
-
-- Mounted DOM by itself is cheap when the composed transform does not change.
-- Calling the same update path every frame is cheap when the transform value
-  stays identical.
-- The expensive path appears when the root camera transform changes over the
-  preserve-3d subtree.
-
-The per-leaf camera-rotation slope is also consistent enough to be useful:
-
-| Scene | Renderer class | Leaves | PAC us/leaf | DrawProps us/leaf | Draw us/leaf |
-| --- | --- | ---: | ---: | ---: | ---: |
-| `scene_vehicles1.vox` | voxel brushes | 752 | 0.637 | 0.503 | 0.598 |
-| `MechaGolem.vox` | voxel brushes | 1789 | 0.612 | 0.598 | 0.661 |
-| `AncientCrashSite.vox` | voxel brushes | 5233 | 0.736 | 0.727 | 0.887 |
-| `Garden.vox` | voxel brushes | 7186 | 0.647 | 0.717 | 0.866 |
-| `ducky.glb` | normal polygon leaves | 471 | 0.722 | 0.979 | 1.520 |
-| `apocalypse/car.glb` | normal polygon leaves | 3359 | 0.680 | 0.774 | 1.135 |
-
-So the camera-motion cost is not voxel-specific. It is the general cost of
-changing a 3D root transform over many preserve-3d DOM leaves. Voxel scenes
-benefit because they reduce the active leaf count; non-voxel scenes still pay
-the same browser-side slope per active transformed leaf.
-
-Dynamic light rotation is a different problem. On `apocalypse/car.glb`,
-`dynamic.light_rotate` spent roughly 40 ms/frame in style update and 7 ms/frame
-in raster, while camera rotation spent roughly 2.3-2.5 ms/frame in PAC and
-draw properties. Keep those investigations separate.
-
-Clean matrix-vs-slice cadence runs, current browser, five runs each:
-
-| Model | Path | FPS p95 | P99 ms | 1-vsync frames | 2-vsync frames | 3-vsync frames | 4+-vsync frames |
-| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
-| `MechaGolem.vox` | matrix fallback | 117.6 | 9.2 | 100.0% | 0.0% | 0.0% | 0.0% |
-| `MechaGolem.vox` | voxel slices | 117.6 | 9.0 | 100.0% | 0.0% | 0.0% | 0.0% |
-| `Treasure.vox` | matrix fallback | 58.0 | 25.0 | 30.6% | 64.9% | 3.5% | 0.6% |
-| `Treasure.vox` | voxel slices | 30.0 | 33.4 | 6.5% | 51.6% | 33.1% | 7.3% |
-| `AncientCrashSite.vox` | matrix fallback | 39.8 | 33.4 | 7.5% | 64.4% | 20.5% | 3.7% |
-| `AncientCrashSite.vox` | voxel slices | 58.4 | 25.0 | 14.9% | 82.5% | 2.5% | 0.0% |
-| `Garden.vox` | matrix fallback | 24.3 | 41.8 | 4.9% | 29.0% | 39.2% | 24.5% |
-| `Garden.vox` | voxel slices | 24.0 | 50.1 | 0.0% | 9.6% | 26.5% | 63.8% |
-| `scene_vehicles1.vox` | matrix fallback | 117.6 | 9.1 | 100.0% | 0.0% | 0.0% | 0.0% |
-| `scene_vehicles1.vox` | voxel slices | 119.0 | 9.1 | 100.0% | 0.0% | 0.0% | 0.0% |
-
-This reframes the adaptive matrix-vs-slice idea. Matrix and slice have the same
-active leaf ranges and the same two visible-face transitions:
-
-| Model | Active leaves, matrix | Active leaves, voxel slices |
-| --- | ---: | ---: |
-| `MechaGolem.vox` | 1199-1789 | 1199-1789 |
-| `Treasure.vox` | 2582-4010 | 2582-4010 |
-| `AncientCrashSite.vox` | 4158-5240 | 4158-5240 |
-| `Garden.vox` | 4668-7186 | 4668-7186 |
-
-The two paths are no longer separated by mounted leaf count. When one wins, it
-wins by browser cadence: how often Chrome lands on 1/2/3/4+ vsync buckets.
-Current trace samples still show the matrix path doing more per-frame PAC and
-draw-property work than slices, even when matrix has better p95 on `Treasure`.
-So the remaining question is a hidden scheduling/property-tree behavior, not a
-simple "less compositor CPU" result.
-
-The wider clean corpus keeps that read. Use the corpus summarizers after adding
-more runs:
-
-```sh
-node bench/voxel-cadence-summary.mjs
-node bench/voxel-static-metrics.mjs
-node bench/voxel-browser-summary.mjs
-```
-
-Current corpus: 86 models, with validation runs preferred over exploratory
-runs.
-
-| Class | Models |
-| --- | --- |
-| Matrix p95 win | `desert2`, `scene_hazmat`, `scene_house`, `scene_mechanic2`, `scene_sidewalk`, `Treasure` |
-| Slice p95 win | `AncientCrashSite`, `armchair`, `christmas_tree`, `ff1`, `mailbox`, `obj_house3`, `obj_house8`, `obj_trashcan4`, `pyramid`, `scene_park` |
-| Mostly flat / capped | 66 of 86 models |
-| P99-only split | `Garden` favors matrix p99 |
-| Slice p99-only split | `dual`, `scene_fall`, `scene_house3` favor slice p99 |
-
-No simple structural metric explains the full corpus yet. `scene_park` and
-`scene_hazmat` have similar active leaves, screen fill, and broad model shape
-but opposite winners. `HUT` has very high screen fill and is flat;
-`AncientCrashSite` has lower screen fill and prefers slices; `Treasure`
-prefers matrix. Local brush area, active leaves, visible planes, color count,
-and screen fill each fail on at least one model.
-
-The static metrics pass adds one useful partial selector: visible shaded brush
-color count, computed from the same polygon plans and baked light math the
-voxel renderer uses. This is not the raw `.vox` source color count. With the
-current 86-model corpus, `visibleShadedColors >= 52` captures
-`scene_hazmat`, `scene_house`, `scene_mechanic2`, and `Treasure`, hits no
-validated strong slice winners, and leaves `desert2` and `scene_sidewalk`
-unexplained. It also hits many flat/capped scenes, so it is a safe-looking
-partial gate, not a full classifier. Against always-slice it gives four p95
-wins and no p95 losses in the current corpus, but it does introduce one p99
-loss: `scene_house3`. A stricter diagnostic gate,
-`visibleShadedColors >= 52 && visiblePlanes < 200`, keeps the same four p95
-wins and removes that p99 loss on the current corpus.
-
-The follow-up structural-neighbor sweep did not find a repeatable second rule
-for `desert2` or `scene_sidewalk`. `desert2` sits among low-color/high-area
-neighbors where `ff1`, `pyramid`, and `christmas_tree` prefer slices and
-`MechaGolem`, `mecha`, `obj_house5`, and `StarMarineTrooper` are flat.
-`scene_sidewalk`'s low-plane/high-fill neighbors were mostly flat or
-slice-favored (`armchair`, `mailbox`, `obj_trashcan4`), so treat
-`scene_sidewalk` as a browser-ceiling case, not a classifier anchor.
-
-Target-size sweeps do not explain the remaining stable matrix wins. On
-`desert2`, slice local area moved from ~10M to ~34M px across target sizes
-50-90, but slice stayed at ~30 FPS p95 while matrix stayed ~59.5 FPS p95.
-On `scene_mechanic2`, slice p95 wandered between ~30 and ~39 FPS while
-matrix stayed ~59 FPS p95. This rules out CSS cell size / local brush area as
-the root cause for those matrix wins.
-
-A bench-only adaptive selector, `polycss-adaptive-shaded`, now computes the
-same source-plan gate before mounting:
-
-```txt
-use matrix when visibleShadedColors >= 52 && visiblePlanes < 200
-```
-
-Short two-repeat route checks:
-
-| Model | Metrics | Matrix p95 | Slice p95 | Adaptive p95 | Adaptive route | Read |
-| --- | --- | ---: | ---: | ---: | --- | --- |
-| `Treasure.vox` | 58 colors, 132 planes | 40.0 | 30.0 | 40.0 | matrix | Correctly catches a slice-slow model. |
-| `AncientCrashSite.vox` | 44 colors, 191 planes | 30.0 | 40.0 | 39.8 | slice | Correctly avoids a slice-favored model. |
-| `scene_vehicles1.vox` | 53 colors, 90 planes | 113.6 | 113.6 | 111.1 | matrix | Flat/capped; routing costs no material p95 but adds nodes. |
-| `scene_hazmat.vox` | 84 colors, 130 planes | 114.9 | 111.1 | 114.9 | matrix | Correctly routes, though this browser run is mostly capped. |
-| `scene_house3.vox` | 80 colors, 217 planes | 39.8 | 39.8 | 39.8 | slice | The plane cutoff avoids the known p99-risk model. |
-| `desert2.vox` | 21 colors, 102 planes | 111.1 | 59.2 | 59.5 | slice | Major miss; the selector is incomplete. |
-
-This is not ready as a production default. It proves the route can be computed
-before mount and catches high-shaded slice-slow models, but `desert2` remains a
-large matrix win outside the gate. The next useful selector work is to explain
-`desert2` without adding slice-favored false positives.
-
-Browser probes confirm that browser mode changes the apparent class:
-
-| Model | Bundled Chromium headless | Chrome 148 headless | Canary 150 headless | Chrome 148 headed |
-| --- | --- | --- | --- | --- |
-| `scene_hazmat` | matrix | flat | matrix | not run |
-| `scene_house` | matrix | matrix | matrix | flat |
-| `scene_mechanic2` | matrix | matrix | matrix | matrix |
-| `Treasure` | matrix | matrix | matrix | matrix-p99 |
-| `desert2` | matrix | matrix | matrix | matrix |
-| `scene_sidewalk` | matrix | flat | flat | not run |
-| `AncientCrashSite` | slice | slice-p99 | slice | slice-p99 |
-| `obj_house3` | slice | flat | slice | not run |
-| `pyramid` | slice | flat | flat | not run |
-| `scene_house3` | slice-p99 | flat | flat | not run |
-
-The useful read: the refined high-shaded gate is cross-browser safe in this
-sample because it turns some wins into flats, not losses. `desert2` is the
-only stable matrix win outside that gate. The low-color slice wins are often
-ceiling-sensitive across installed browsers. Headed Chrome makes this stricter:
-`scene_house` flattens even though headless browsers usually favor matrix, so
-any production selector has to be justified as "avoid known slow slice cases",
-not as "always faster".
-
-Five-repeat validation is mandatory before promoting a two-run split. The
-expanded sweep produced several mirages that flattened under validation:
-`scene_sumo`, `scene_parked`, `scene_hunt`, and `scene_house5`. The later
-low-plane sweep found exploratory slice wins (`armchair`, `mailbox`,
-`obj_trashcan4`) that should not become anchors until validated.
-
-Strong validated winners:
-
-| Model | Winner | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 | Leaves | Nodes M/S | Planes | Colors | Screen |
-| --- | --- | ---: | ---: | ---: | ---: | ---: | --- | ---: | ---: | ---: |
-| `pyramid` | slice | 59.9 | 104.2 | 16.9 | 9.8 | 1774 | 3057/1812 | 68 | 19 | 1.247 |
-| `scene_park` | slice | 59.9 | 103.1 | 16.8 | 10.0 | 1694 | 3210/1722 | 193 | 30 | 3.280 |
-| `scene_hazmat` | matrix | 101.0 | 59.3 | 10.6 | 17.6 | 1586 | 2979/1624 | 130 | 59 | 3.181 |
-| `ff1` | slice | 63.4 | 102.7 | 16.7 | 10.6 | 1569 | 3133/1627 | 54 | 2 | 1.925 |
-| `scene_house` | matrix | 98.0 | 59.2 | 16.7 | 17.7 | 1619 | 2928/1647 | 182 | 69 | 3.215 |
-| `AncientCrashSite` | slice | 23.8 | 57.8 | 63.1 | 20.7 | 5233 | 10459/5268 | 192 | 44 | 1.585 |
-| `obj_house3` | slice | 29.9 | 59.2 | 41.6 | 17.4 | 1057 | 2179/1140 | 142 | 15 | 9.533 |
-| `Treasure` | matrix | 57.8 | 32.5 | 25.0 | 33.4 | 4010 | 7121/4038 | 140 | 59 | 2.600 |
-| `desert2` | matrix | 59.9 | 38.0 | 17.0 | 33.4 | 1984 | 4167/2012 | 102 | 21 | 4.866 |
-| `scene_mechanic2` | matrix | 59.5 | 40.0 | 17.1 | 25.3 | 2216 | 4264/2244 | 166 | 89 | 2.409 |
-| `obj_house8` | slice | 97.1 | 112.4 | 16.9 | 10.1 | 452 | 909/489 | 90 | 24 | 3.482 |
-| `christmas_tree` | slice | 103.1 | 117.6 | 10.1 | 9.8 | 1464 | 2693/1493 | 73 | 13 | 1.332 |
-| `scene_sidewalk` | matrix | 117.6 | 104.1 | 10.0 | 10.1 | 436 | 972/482 | 47 | 32 | 1.215 |
-
-Two focused DOM-shape probes closed:
-
-- Leaf `transform-style: flat` is not a simplification. It caused order-of-
-  magnitude regressions (`Garden` slice p95 ~24 -> ~2.4, `AncientCrashSite`
-  slice ~40 -> ~4.9, `MechaGolem` slice ~60 -> ~13.3). The current
-  `preserve-3d` leaf style appears to be part of Chrome's valid 3D fast path.
-- Keeping the three voxel hosts but turning each brush into a 1px
-  `matrix3d(...)` scale/translate leaf collapsed local layout area but stayed
-  in the slice cadence class. On `Treasure`, where matrix fallback wins, the
-  host+brush-matrix variant stayed around 30 FPS p95 while matrix fallback
-  reached ~58 FPS p95.
-- Removing the three voxel hosts and emitting direct matrix leaves from the
-  voxel renderer was not robust. After restoring visible backfaces it looked
-  close in static screenshots, but still had measurable image diffs and
-  regressed several models (`AncientCrashSite`, `Garden`, `army`, `desert2`).
-  It is useful evidence that host count is not the sole issue.
-
-The later direct-matrix revisit clarified that result. The first broken
-prototype used singular-ish matrices for side planes. Adding the same kind of
-normal column the real polygon matrix path uses fixed the flat/invalid
-projection on `desert2` and exposed the actual transferable property:
-
-```txt
-hosted slice brush:
-  axis host rotate + left/top/width/height + leaf translateZ
-
-matrix-like brush:
-  direct scene child + 1px primitive + matrix3d(rect basis, normal, translate)
-```
-
-Bench-only `polycss-voxlocal-direct-matrix` keeps the voxel source brush plan
-and culling, but folds each axis host into a direct canonical matrix leaf.
-Current one-run reads:
-
-| Model | Matrix p95 | Slice p95 | Direct matrix p95 | Direct split8 p95 | Read |
-| --- | ---: | ---: | ---: | ---: | --- |
-| `desert2.vox` | 113.6 | 59.5 | 107-110 | 59.9 | Direct canonical matrices transfer the win; splitting destroys it. |
-| `Treasure.vox` | 40.0 | 30.0 | 30-39 | 29.9 | Direct shape helps inconsistently; full polygon matrix is still steadier. |
-| `AncientCrashSite.vox` | 39.7 | 39.8 | 18-24 | 24.0 | Direct source matrices are a regression. |
-| `ff1.vox` | 111.1 | 112.4 | 116.6 | not run | Capped/flat; direct matrix is safe here. |
-| `pyramid.vox` | 114.9 | 112.4 | 60.2 | 59.9 | Direct source matrices regress a slice-favored model. |
-| `scene_park.vox` | 111.3 | 117.6 | 107.6 | not run | Slice path remains better. |
-
-Trace on `desert2` confirms that this is no longer just a hidden cadence
-artifact. Direct matrix source brushes lower compositor work:
-
-| Path | FPS p95 | P99 ms | 1x vsync | PAC ms/frame | DrawProps ms/frame | Draw ms/frame |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: |
-| Matrix fallback | 113.4 | 9.2 | 100.0% | 1.49 | 1.55 | 1.88 |
-| Voxel slices | 59.5 | 17.1 | 37.1% | 1.33 | 1.27 | 1.63 |
-| Voxel direct matrix | 107.5 | 16.8 | 95.6% | 0.76 | 0.77 | 0.90 |
-
-Trace on `AncientCrashSite` shows the constraint: direct matrices also lower
-PAC/draw-props there, but cadence gets worse (`18.1` FPS p95, `62.8ms` p99).
-So lower compositor-summary cost is necessary but not sufficient; draw
-scheduling and/or the coarse source-rectangle geometry still matter.
-
-The exact-quad revisit found a stronger version of the same idea. Instead of
-using merged source rectangles, `polycss-voxlocal-direct-matrix-exact` emits
-one direct child `<b>` per exact parsed voxel quad. That keeps the same active
-leaf count as slices while using the matrix leaf shape:
-
-```txt
-scene root
-  b matrix3d(...)
-  b matrix3d(...)
-  ...
-```
-
-The remaining variable is DOM order. Parsed polygon order transfers the
-`desert2` and `Treasure` matrix wins, but leaves `AncientCrashSite` in the
-bad 30 FPS p95 bucket. Coarse face grouping fixes `AncientCrashSite` but
-breaks `desert2`/`Treasure`. Six face wrappers, whether hidden with
-`display:none` or detached, also break the `desert2` win. That isolates the
-candidate shape:
-
-```txt
-direct child canonical matrix leaves, no transformed axis hosts, no face
-wrappers, order chosen at cull-boundary time
-```
-
-Projected-depth ordering was the first ordering rule that worked across the
-initial tradeoff set. It sorts the visible exact matrix leaves by approximate
-camera depth only when the visible face signature changes; no per-frame leaf
-updates are added.
-
-Validated with wall-time rotation, 5 repeats, 1280x800, bundled Chromium:
-
-| Model | Path | FPS p50 | FPS p95 | P99 ms | Read |
-| --- | --- | ---: | ---: | ---: | --- |
-| `AncientCrashSite.vox` | voxcss 3d | 59.9 | 39.4 | 33.4 | Baseline ceiling class. |
-| `AncientCrashSite.vox` | voxel slices | 59.9 | 40.0 | 25.2 | Current accepted path. |
-| `AncientCrashSite.vox` | exact direct matrix, parsed order | 59.9 | 30.0 | 33.6 | Bad order. |
-| `AncientCrashSite.vox` | exact direct matrix, depth-front | 59.9 | 39.8 | 33.3 | Recovers p95, p99 still worse. |
-| `AncientCrashSite.vox` | exact direct matrix, depth-back | 59.9 | 39.8 | 26.1 | Recovers p95 and nearly slice p99. |
-| `desert2.vox` | voxcss 3d | 119.0 | 59.5 | 17.4 | Voxcss stays in 60 FPS p95 bucket. |
-| `desert2.vox` | voxel slices | 60.2 | 59.3 | 17.4 | Current slice path is also 60 FPS. |
-| `desert2.vox` | exact direct matrix, parsed order | 120.5 | 112.4 | 9.2 | Matrix win. |
-| `desert2.vox` | exact direct matrix, depth-front | 120.5 | 112.4 | 9.2 | Keeps the win. |
-| `desert2.vox` | exact direct matrix, depth-back | 120.5 | 112.4 | 9.3 | Keeps the win. |
-| `Treasure.vox` | voxcss 3d | 59.9 | 29.9 | 33.6 | Voxcss/slices are slow here. |
-| `Treasure.vox` | voxel slices | 41.0 | 29.8 | 41.7 | Current slice path is slow. |
-| `Treasure.vox` | exact direct matrix, parsed order | 60.2 | 40.2 | 25.1 | Matrix win. |
-| `Treasure.vox` | exact direct matrix, depth-front | 59.9 | 40.0 | 25.2 | Keeps the win. |
-| `Treasure.vox` | exact direct matrix, depth-back | 60.2 | 40.1 | 25.2 | Keeps the win. |
-
-The trace read is supportive but not the primary proof, because tracing can
-perturb the exact cadence bucket. In one trace pass, depth-back reduced script
-and style time versus parsed order on `desert2`/`Treasure` and matched slice
-p99 on `AncientCrashSite`; compositor totals were still large. Treat the
-clean cadence validation as the decision signal and traces as explanation.
-
-The broader corpus disproved a single fixed depth order as the default. A
-157-model exploratory pass and targeted validation found:
-
-| Model | Slice p95/p99 | Depth-front p95/p99 | Depth-back p95/p99 | Read |
-| --- | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 112.4/9.2 | 59.9/17.3 | 58.8/25.0 | Hard counterexample to global depth order. |
-| `obj_house5.vox` | 114.9/9.1 | 113.6/9.2 | 59.9/16.8 | Direction-sensitive; front is fine, back breaks. |
-| `HUT.vox` | 59.9/17.2 | 59.9/17.3 | 57.9/25.0 | Back has p99 risk; front is flat. |
-| `skyscraper.vox` | 29.6/40.6 | 24.0/42.2 | 24.2/41.8 | Direct matrix order is not reliably better. |
-| `army.vox` | 40.0/25.1 | 39.8/33.3 | 59.5/17.4 | Back is the win; front has p99 risk. |
-| `house.vox` | 60.1/16.7 | 112.4/9.2 | 114.9/9.2 | Depth order is a large win. |
-| `scene_mechanic2.vox` | 59.5/17.3 | 112.1/9.3 | 111.1/9.3 | Depth order is a large win. |
-| `desert2.vox` | 59.4/17.4 | 111.1/9.2 | 112.4/9.2 | Depth order is a large win. |
-| `Treasure.vox` | 30.0/33.9 | 58.0/25.0 | 58.7/25.0 | Depth order is a large win. |
-| `AncientCrashSite.vox` | 40.0/25.2 | 39.8/25.9 | 40.0/25.6 | Flat and visually acceptable. |
-
-The strongest counterexample, `obj_house3`, isolates the issue further. It is
-not rejecting direct matrix leaves. Existing polygon matrix, exact direct
-matrix in parsed order, and global depth order all sit around 59 FPS p95,
-while direct child face order returns to the slice-class 110+ FPS p95. So the
-browser fast path is order-sensitive:
-
-```txt
-same direct child <b> matrix leaf shape
-different DOM order -> different cadence bucket
-```
-
-Testing face-major plus depth-within-face order did not unify the paths. It
-keeps the face-order rescue on `obj_house3`, but loses the depth-order wins on
-`desert2`, `house`, and `scene_mechanic2`. The current best interpretation is
-that there are at least two useful compositor ordering classes:
-
-- global projected-depth order for large wins such as `desert2`, `house`,
-  `scene_mechanic2`, `Treasure`, and back-order `army`;
-- coarse face order for `obj_house3` and similar capped house-like cases.
-
-The strongest current explanation:
-
-- Matrix wins are caused by direct canonical matrix leaves that avoid the
-  axis-host transform chain and layout-sized brush surfaces.
-- The normal column in `matrix3d` matters. Without it, side-plane matrices are
-  effectively degenerate and render flat/wrong.
-- Merged source rectangles are not reliable enough. Naively splitting them
-  adds dirty transform nodes and loses the win.
-- Exact voxel quads plus direct matrix leaves remain the current best one
-  leaf-shape candidate.
-- A single fixed DOM order is not proven. Global projected-depth order wins
-  several heavy models but regresses `obj_house3`; face order fixes
-  `obj_house3` but loses key depth-order wins.
-- The remaining proof work is now an order policy or a structural renderer
-  route. If the route only changes ordering while keeping the same direct
-  matrix leaf shape, it is still better than switching render strategies.
-
-The important read is stable:
-
-- Raster is not the limiting phase in these captures.
-- Paint is not the limiting phase in these captures.
-- Style and layout are too small to explain the frame time.
-- The recurring cost is compositor/layer lifecycle:
-  `PaintArtifactCompositor::Update`, `Layerize`,
-  `LayerTreeImpl::UpdateDrawProperties`, `LayerTreeHostImpl::PrepareToDraw`,
-  and `MainFrame.Draw`.
-- For camera rotation, active transformed leaf count is now the best first
-  predictor. It is not the whole model, but the per-leaf slope is stable enough
-  to guide renderer work.
-
-## Chromium Source Read
-
-Chromium's public RenderingNG docs match the trace shape we are seeing. Visual
-changes can skip layout/pre-paint/paint when they are compositor-thread visual
-effect animations, but the pipeline still has layerize, activate, aggregate,
-and draw stages. Property trees are the transform/clip/effect/scroll state the
-compositor uses to answer where content is on screen, and paint chunks are
-layerized into cc layers by trading GPU memory against future update cost.
-
-The relevant source path is narrower:
-
-- `PaintArtifactCompositor::Update` is the expensive full path. It rebuilds
-  pending layers, runs `Layerizer(...).Layerize()`, creates/updates compositor
-  property tree nodes, and sets the layer list.
-- `PaintArtifactCompositor::TryFastPathUpdate` handles repaint/raster-scroll
-  cases without full layerization.
-- `PaintArtifactCompositor::DirectlyUpdateTransform` can skip full PAC
-  layerization only when the transform node is known composited and has active
-  transform animation. The call site in `paint_property_tree_builder.cc`
-  explicitly gates the downgrade from `kChangedOnlySimpleValues` to
-  `kChangedOnlyCompositedValues` on `transform.HasActiveTransformAnimation()`.
-- Even the successful direct transform path updates the cc transform node,
-  marks the transform tree dirty, and calls `SetNeedsCommit()`. That means the
-  win is "skip PAC/layerize", not "free rotation".
-- `TransformTree::UpdateAllTransforms` iterates transform nodes when dirty.
-  `draw_property_utils::CalculateDrawProperties` then updates property trees,
-  finds visible layers, computes screen/target transforms, visible rects, and
-  drawable content rects. This is the remaining per-frame cost after PAC is
-  gone.
-
-This explains why the current JS orbit path keeps showing PAC: polycss mutates
-`sceneEl.style.transform` through `scene.setOptions()` every frame. The scene
-root has `will-change: transform`, so it is composited, but a JS style mutation
-is not the same as an active compositor transform animation for the direct
-update gate.
-
-Quick source-driven probes confirm this on `apocalypse/car.glb` through the
-vanilla bench page. Same DOM, baked lighting, trace enabled, 1280x800:
-
-| Motion | FPS p50 | FPS p95 | PAC count | PAC total ms | DrawProps total ms | Draw total ms |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: |
-| Static | 120.5 | 114.9 | 0 | 0.0 | 35.4 | 72.8 |
-| JS `scene.setOptions({ rotY })` | 13.3 | 13.2 | 40 | 91.1 | 103.9 | 151.4 |
-| CSS keyframe `transform` on `.polycss-scene` | 59.9 | 13.4 | 0 | 0.0 | 186.2 | 303.6 |
-| Running WAAPI `transform` animation | 59.9 | 13.4 | 0 | 0.0 | 181.5 | 298.5 |
-| Paused WAAPI animation scrubbed with `currentTime` from JS | 13.3 | 12.0 | 39 | 88.9 | 101.8 | 151.3 |
-| Scroll-timeline animation scrubbed by JS `scrollLeft` | 13.3 | 12.0 | 38 | 81.2 | 158.0 | 199.6 |
-
-The exact FPS from these probes is trace-perturbed and should not be treated as
-a shipping benchmark. The source-level result is the important part:
-declarative running transform animation removes PAC, but draw-property and draw
-costs remain large for a big preserve-3d subtree. JS scrubbing an otherwise
-compositor-backed mechanism (`Animation.currentTime` or `scrollLeft`) does not
-preserve the PAC win.
-
-The first synthetic topology probe confirms the lower-level transform-node
-cost. It used 2500 `<b>` leaves under the same running CSS-animated
-preserve-3d root, so PAC stayed zero and the comparison isolates draw-property
-and draw work:
-
-| Leaf topology | FPS p95 | PAC ms/frame | DrawProps ms/frame | Draw ms/frame |
-| --- | ---: | ---: | ---: | ---: |
-| `left/top`, no leaf transform | 112.4 | 0.000 | 0.016 | 0.066 |
-| 2D `translate(...)` leaf transform | 113.6 | 0.000 | 0.017 | 0.066 |
-| `translateZ(0)` leaf transform | 112.4 | 0.000 | 0.639 | 1.851 |
-| Real `translateZ(...)` leaf transform | 111.1 | 0.000 | 0.914 | 2.310 |
-| `matrix3d(...)` leaf transform | 112.4 | 0.000 | 0.956 | 2.276 |
-
-This is the clearest browser-level result so far: a syntactically 3D leaf
-transform, even `translateZ(0)`, moves the page into the expensive transform
-tree / draw-properties class. A 2D translate is decomposed or otherwise handled
-like `left/top`. That directly matches `PendingLayer::DecompositeTransforms`,
-which only decomposes identity/2D translations.
-
-The depth-grouping follow-up moved leaf `translateZ(...)` into one wrapper per
-axis/depth plane while keeping the same leaf count. This gives a sharper
-threshold than the earlier real-renderer wrapper tests:
-
-| Leaves | Root motion | Variant | FPS p95 | P99 ms | PAC ms/frame | DrawProps ms/frame | Draw ms/frame |
-| ---: | --- | --- | ---: | ---: | ---: | ---: | ---: |
-| 2500 | JS transform mutation | leaf-z17 | 113.6 | 9.3 | 1.131 | 1.427 | 2.007 |
-| 2500 | JS transform mutation | group-z17 | 113.6 | 9.2 | 0.419 | 0.033 | 0.083 |
-| 2500 | JS transform mutation | leaf-z50 | 116.3 | 9.2 | 1.130 | 1.468 | 2.036 |
-| 2500 | JS transform mutation | group-z50 | 117.6 | 9.1 | 0.445 | 0.062 | 0.163 |
-| 2500 | JS transform mutation | leaf-z250 | 40.0 | 25.1 | 1.151 | 1.449 | 2.049 |
-| 2500 | JS transform mutation | group-z250 | 113.6 | 16.6 | 0.522 | 0.249 | 0.494 |
-| 5000 | JS transform mutation | leaf-z17 | 59.5 | 17.3 | 2.508 | 3.162 | 4.139 |
-| 5000 | JS transform mutation | group-z17 | 114.9 | 9.2 | 0.807 | 0.035 | 0.155 |
-| 5000 | JS transform mutation | leaf-z50 | 40.0 | 25.7 | 2.537 | 3.236 | 4.197 |
-| 5000 | JS transform mutation | group-z50 | 29.9 | 41.6 | 0.825 | 0.060 | 0.294 |
-| 5000 | JS transform mutation | leaf-z250 | 29.7 | 33.9 | 2.585 | 3.417 | 4.623 |
-| 5000 | JS transform mutation | group-z250 | 13.3 | 75.0 | 26.844 | 1.312 | 2.540 |
-| 5000 | CSS transform animation | leaf-z17 | 59.5 | 16.9 | 0.000 | 1.773 | 4.072 |
-| 5000 | CSS transform animation | group-z17 | 116.3 | 9.2 | 0.000 | 0.025 | 0.154 |
-| 5000 | CSS transform animation | leaf-z50 | 58.8 | 24.9 | 0.000 | 1.912 | 4.213 |
-| 5000 | CSS transform animation | group-z50 | 29.3 | 41.7 | 0.000 | 0.046 | 0.306 |
-| 5000 | CSS transform animation | leaf-z250 | 20.0 | 50.6 | 0.000 | 1.896 | 4.130 |
-| 5000 | CSS transform animation | group-z250 | 8.0 | 133.2 | 0.000 | 0.678 | 2.233 |
-
-This is not a green light for depth wrappers as the default renderer. It
-explains why the earlier real-renderer wrapper attempts lost: many real `.vox`
-models have too many visible depth planes. Strong current winners sit at
-47-191 visible planes (`scene_sidewalk` 47, `ff1` 54, `pyramid` 68,
-`desert2` 102, `Treasure` 132, `AncientCrashSite` 191). The synthetic result
-only looks clean at very low wrapper count. Around 50 wrappers, trace events
-look cheap but cadence can get worse; by 250 wrappers the wrapper hierarchy is
-catastrophic. The actionable hypothesis is therefore a strict low-plane gate,
-not a replacement for leaf `translateZ(...)`.
-
-A bench-only real-model variant, `polycss-voxlocal-depth-groups`, then tested
-that gate against actual voxel plans:
-
-| Model | Visible planes | Current voxlocal p95 | Depth groups p95 | Read |
-| --- | ---: | ---: | ---: | --- |
-| `armchair.vox` | 22 | 109.9-112.4 | 108.7-109.9 | Capped/flat; extra nodes do not buy anything. |
-| `obj_trashcan4.vox` | 16 | 109.9-111.1 | 111.0-112.3 | Capped/flat within noise. |
-| `mailbox.vox` | 28 | 109.9 | 112.4-113.6 | Capped/flat within noise. |
-| `scene_sidewalk.vox` | 47 | 113.6-116.3 | 111.1-112.4 | Near the unstable zone; slight regression. |
-| `ff1.vox` | 54 | 114.9 | 29.9 | Confirms the 50-wrapper synthetic warning. |
-
-So the low-plane gate has no current product payoff. Available low-plane real
-models are already near the browser cadence ceiling, and the first meaningful
-near-threshold model regresses hard. Reopen only if we find a high-leaf,
-sub-30-visible-plane real scene.
-
-An early synthetic distribution probe used 1200 `matrix3d` leaves and JS root
-rotation, varying only projected distribution:
-
-| Distribution | FPS p95 | PAC ms/frame | DrawProps ms/frame | Draw ms/frame |
-| --- | ---: | ---: | ---: | ---: |
-| Clustered | 112.4 | 0.609 | 0.629 | 0.785 |
-| Spread | 116.3 | 0.592 | 0.757 | 0.942 |
-| Overlap-heavy | 111.1 | 0.594 | 0.758 | 0.919 |
-
-This does not prove a layerization-sparsity win yet: PAC/layerize were almost
-the same, and a shorter rerun was noisier. Treat this as a conditional
-secondary hypothesis: projected distribution may move draw-properties and draw
-at equal leaf count, but it needs controlled repeats before it can guide
-renderer work.
-
-Actionable consequences:
-
-- Test a product-shaped declarative camera animation path separately from
-  interactive drag. If it wins cleanly, auto-rotate demos can use CSS/WAAPI
-  compositor animations while pointer-driven controls stay imperative.
-- Do not expect `will-change` alone to solve JS camera rotation. It can force
-  compositing, but the direct-update source gate still wants active transform
-  animation.
-- Do not chase more nested coordinate wrappers as a PAC fix. More transform
-  nodes increase property-tree and draw-property work, which is exactly the
-  remaining source path.
-- The next non-voxel optimization target is still active transformed leaf
-  count, render-surface count, and transform-node count. For voxel scenes the
-  accepted fast path attacks active leaves; for non-voxel scenes the equivalent
-  lever is mesh reduction / merging / LOD, not transform-chain cleverness.
-
-## Next Actionable Hypotheses
-
-| ID | Hypothesis | Why it is plausible | Test | Accept if | Reject if |
-| --- | --- | --- | --- | --- | --- |
-| C1 | A dedicated declarative auto-rotate path can skip PAC for demos. | Chromium gates direct transform updates on active transform animation; CSS keyframes and running WAAPI both showed zero PAC. | Add a bench-only `motion=css-rot` or `motion=waapi-rot` page mode, run clean FPS and traces on `AncientCrashSite`, `Garden`, `Treasure`, `apoc-car`, and `ducky`, then screenshot-check at fixed angles. | PAC stays zero and clean p95/p99 improve without visual drift. | Clean cadence does not improve, or screenshots/interaction semantics become messy. |
-| C2 | JS-scrubbed compositor animations are not a viable interactive camera fix. | Paused WAAPI `currentTime` and JS `scrollLeft` scroll-timeline probes both hit PAC once per frame. | Repeat once in headed Chrome/Canary to rule out a headless artifact, then close. | A current browser shows zero PAC while scrubbed from JS. | PAC count tracks frame count again. |
-| C3 | The remaining slope is proportional to dirty 3D transform nodes, not just DOM leaves. | `TransformTree::UpdateAllTransforms` iterates transform nodes when dirty; `PendingLayer::DecompositeTransforms` only removes identity/2D-translation transforms. The synthetic topology probe shows `translateZ(0)`, real `translateZ`, and `matrix3d` are far more expensive than `left/top` or 2D translate. | Keep `bench/compositor-topology-probe.mjs` in the loop and repeat in headed/current browsers; use it as the benchmark for any future DOM topology idea. | Already accepted as a browser cost model. | Reopen only if another browser version makes 3D leaves decompose cheaply. |
-| C4 | Projected distribution/overlap may be a secondary cost model after leaf count and 3D transform-node count. | One longer synthetic distribution run moved DrawProps/Draw by about 20% at equal `matrix3d` leaf count, though PAC/layerize stayed similar; a shorter rerun was noisier. | Extend the synthetic probe with controlled screen coverage and optional intrusive layer counts; then compare real models with similar leaves but different bounds. | Distribution explains stable model-to-model variance that leaf count misses. | Repeated controlled runs collapse to noise. |
-| C5 | Splitting one preserve-3d scene into multiple independently animated islands is only useful if it reduces active leaves per dirty transform tree enough to offset extra roots. | Source says more transform nodes are costly, but smaller dirty subtrees may reduce draw-property work if only one island moves. | Synthetic scene with N leaves split into 1/2/4 mesh roots; animate one root vs all roots; compare draw-property slope and visual correctness. | Animating one island is cheaper in proportion to its leaves and all-roots is not much worse than one root. | Extra roots/render surfaces dominate. |
-| C6 | Depth-plane wrappers may be viable only for tiny visible-plane-count voxel scenes. | Synthetic depth grouping is excellent at 17 wrappers and 5000 leaves, but 50 wrappers already loses cadence and 250 wrappers collapses. | Done in `polycss-voxlocal-depth-groups` on available low-plane real models plus nearby counterexamples. | Reopen only if a high-leaf, sub-30-visible-plane real scene appears. | Current corpus has no useful payoff: sub-30-plane scenes are capped/flat, and `ff1` at 54 planes regresses to ~30 FPS p95. |
-| C7 | The adaptive matrix-vs-slice gate needs a second structural predicate for low-color matrix wins. | `visibleShadedColors >= 52 && visiblePlanes < 200` catches `Treasure`/high-shaded wins and avoids `AncientCrashSite`/`scene_house3`, but misses `desert2`, which is still a large matrix win. | Search source-plan metrics for a predicate that captures `desert2` without hitting validated strong slice winners; then rerun `polycss-adaptive-shaded` or a new adaptive case. | Captures `desert2` and keeps p95/p99 neutral on `ff1`, `pyramid`, `christmas_tree`, `AncientCrashSite`, and `scene_park`. | Any predicate that catches `desert2` also routes strong slice winners to matrix. |
-| C8 | Hostless direct canonical matrix brushes are the portable part of the matrix win. | `polycss-polybox` proved parsed polygons in axis hosts still fall to slice cadence; `polycss-voxlocal-direct-matrix` proved hostless canonical matrices transfer the win on `desert2`. | Turn the bench prototype into a cleaner renderer experiment with visual diff gates. Test unsplit source brushes, exact parsed brushes, and a cheap predicate for source plans that stay browser-friendly. | Direct matrix source brushes pass visual checks and improve validated p95/p99 on a class broader than `desert2` without hurting slice-favored models. | The source-plan predicate collapses, or visual-correct direct matrices only reproduce the existing polygon fallback. |
-| C9 | Exact direct matrix leaves can be the single voxel leaf shape, but DOM order needs a compositor-aware policy. | Depth order keeps the `desert2`/`Treasure`/`house`/`scene_mechanic2`/`army` wins, but `obj_house3` needs face/top-first order and `AncientCrashSite` rejects normal/depth-band variants. Static face permutations, face-normal order, face-depth, face-block, and depth-band hybrids all have hard counterexamples. | Stop adding face-order permutations. Build a metric for projected overlap and depth-order inversions at cull-boundary angles, then validate it on the hard split set. | One leaf shape plus a geometry-derived order policy is neutral-or-better than slices on validated p95/p99 and passes screenshots. | Any policy still leaves strong slice-favored regressions, requires benchmark feedback, or fails visual checks. |
-| C10 | The order win is a cadence threshold, not lower measured main-thread work per frame. | Same-node-count traces on `scene_mechanic2` and `obj_house3` show PAC, DrawProps, Draw, paint, raster, and script are nearly identical per inferred frame between fast and slow orders; the difference is 1x-vsync share. Chromium docs also put preserve-3d quad sorting/intersection in the compositor frame path. | Add overlap/inversion metrics and, if needed, an intrusive layer/quad diagnostic only after clean FPS runs. | The metric predicts 1x-vsync vs 2x/3x-vsync cadence without relying on model names. | Per-frame trace groups start diverging materially under cleaner instrumentation. |
-
-## Trace Rules
-
-- Do not optimize against `RunTask` by itself. It is a wrapper around nested
-  work and mostly tells us the frame was expensive.
-- Do not sum top trace events as if they were exclusive. Many are nested.
-- Compare per-frame event medians, not only total trace milliseconds.
-- Keep `LayerTree.enable` out of primary FPS runs. It perturbs the path.
-- Keep trace and raw-sample diagnostics separate from clean cadence sweeps.
-  Mid-sized models can jump back to a perfect 120Hz cadence under diagnostic
-  capture, even when five clean repeats show a stable split.
-- Always record browser executable, headless/headed mode, DPR, warmup, sample
-  window, viewport, model, leaves, and trace categories.
-
-## Tooling
-
-Use the trace summarizer for any result JSON containing trace summaries:
-
-```sh
-node bench/trace-summary.mjs bench/results/<file>.json
-```
-
-Use the synthetic compositor probe for browser-shape hypotheses:
-
-```sh
-node bench/compositor-topology-probe.mjs
-node bench/compositor-topology-probe.mjs --mode=topology --leaves=5000
-node bench/compositor-topology-probe.mjs --mode=distribution --headed
-node bench/compositor-topology-probe.mjs --mode=depth-groups --root=js --leaves=5000
-```
-
-Useful current voxel command pattern:
-
-```sh
-TRACE=1 REPEATS=1 WARMUP_MS=1000 SAMPLE_MS=2500 PRINT_JSON=0 \
-  CASES=polycss-baked-voxzoom MODEL_FILE=Garden.vox POLY_ZOOM=voxcss \
-  node bench/results/ancient-rotation-compare.mjs
-```
-
-Then summarize:
-
-```sh
-node bench/trace-summary.mjs bench/results/garden-vox-rotation-compare.json
-```
-
-## Trace-Backed Hypotheses
-
-| ID | Status | Hypothesis | What would prove it |
-| --- | --- | --- | --- |
-| T1 | Accepted | The real camera-motion cost is 3D property-tree/compositor maintenance, not paint. | Current traces show PAC/layerize/draw-props dominate while paint/raster stay near zero. |
-| T2 | Accepted | Chrome rebuilds compositor state when the root transform changes over the preserve-3d subtree. | Static and repeated-same-value traces drop PAC/layerize/draw-props to zero; changing rotation restores them. |
-| T3 | Watch | Bounds complexity may modulate the per-leaf slope. | Models with similar leaf counts but different projected bounds should separate in `DrawProperties`/`PrepareToDraw` per frame. |
-| T4 | Accepted | A cheap first-order predictor is active transformed leaves times a browser slope. | Voxel and non-voxel camera traces cluster around ~0.6-0.75 us/leaf for PAC and draw-props, with draw slightly higher. |
-| T5 | Test next | The next valid ceiling prototype must lower PAC/draw-props while preserving the exact 3D visual contract. | A prototype beats current polycss on `PAC ms/frame` and screenshots, not just p95 FPS. |
-| T6 | Test next | Dynamic-light perf is a separate cascade/raster problem, not the camera compositor problem. | Dynamic light traces should be tracked with style/raster columns and not mixed with camera-motion conclusions. |
-| T7 | Flat | Moving voxel `translateZ` to depth-plane wrappers reduces per-leaf transform cost only at very low wrapper count. | Synthetic probes show a clean 17-wrapper ceiling case, but real sub-30-plane models are already capped and `ff1` at 54 planes regresses hard. No current production path. |
-| T8 | Rejected | Canonical 1x1 voxel brushes with `translate3d(... ) scale(...)` reduce layout/GPU bounds enough to improve FPS. | Screenshot smoke was clean, and local layout area collapsed, but FPS was flat across `MechaGolem`, `Treasure`, `stairs`, `desert2`, `army`, `Garden`, `AncientCrashSite`, `HUT`, and `scene_vehicles1`. |
-| T9 | Rejected | `backface-visibility:hidden` is the missing voxel fast path. | Plain hidden backfaces improves several models but fails visual checks badly. Face-flipped hidden backfaces passes screenshot smoke, but FPS is flat. |
-| T10 | Watch | Some voxel models should use the matrix renderer instead of slice brushes. | Current 86-model corpus: matrix wins `desert2`, `scene_hazmat`, `scene_house`, `scene_mechanic2`, `scene_sidewalk`, `Treasure`; slice wins `AncientCrashSite`, `armchair`, `christmas_tree`, `ff1`, `mailbox`, `obj_house3`, `obj_house8`, `obj_trashcan4`, `pyramid`, `scene_park`; 66 models are flat/capped. `visibleShadedColors >= 52 && visiblePlanes < 200` is the only safe-looking partial matrix gate; it misses stable `desert2` and browser-sensitive `scene_sidewalk`. |
-| T11 | Rejected | Leaf `transform-style: flat` reduces property-tree work. | It catastrophically regressed matrix and slice paths across all tested voxel models. Leaves have no transformed children, but Chrome still needs them in the preserve-3d path for this renderer. |
-| T12 | Rejected | Keep voxel hosts but encode brush rectangles as 1px `matrix3d(...)` leaves. | Local layout area collapsed from tens of millions of px to thousands, but FPS stayed flat or regressed. It did not inherit the plain matrix fallback's cadence on `Treasure`. |
-| T13 | Conditional | Remove voxel hosts and emit direct canonical matrix leaves from the voxel renderer. | The corrected normal-column prototype transfers the `desert2` matrix win and lowers PAC/draw-props, but still regresses `AncientCrashSite`, `pyramid`, and `scene_park`; splitting large source rectangles makes it worse. This is a candidate renderer shape only behind a strong source-plan predicate or with exact polygon granularity. |
-
-## Next Work
-
-1. Treat camera rotation as a per-active-leaf compositor budget. Renderer
-   changes are interesting only if they reduce active transformed leaf count or
-   the per-leaf PAC/draw-props slope while preserving visuals.
-2. Treat adaptive matrix-vs-slice as a cadence-classifier problem. Prototype
-   the `visibleShadedColors >= 52 && visiblePlanes < 200` gate as a
-   benchmark-only adaptive case before changing defaults; it should prove
-   net-neutral-or-better on p95 and p99, not just p95, and keep validation
-   repeats as the source of truth.
-3. Capture raw trace events for a short run when needed. The current summary is
-   enough for direction, but raw events are needed to inspect property-tree and
-   compositor internals more deeply.
-4. Keep dynamic-light traces separate. That path is style/raster-heavy and
-   should not drive camera-renderer decisions.
-5. Do not pursue depth wrappers, split direct matrices, or voxel
-   backface-hidden variants without a new trace signal. Hostless direct
-   canonical matrices remain open because they transferred the `desert2` win,
-   but only as a visual-gated renderer experiment.
-6. The two useful optimization paths left are:
-   - adaptive matrix-vs-slice selection for `.vox` models, once cadence can be
-     predicted safely;
-   - actual active-leaf reduction through better exact voxel planning or
-     better non-voxel mesh merging.
diff --git a/bench/VOXEL_FAST_PATH_HYPOTHESES.md b/bench/VOXEL_FAST_PATH_HYPOTHESES.md
deleted file mode 100644
index 05ddd7bd..00000000
--- a/bench/VOXEL_FAST_PATH_HYPOTHESES.md
+++ /dev/null
@@ -1,753 +0,0 @@
-# Voxel Fast Path Hypotheses
-
-Actionable ledger for the `.vox` renderer performance investigation. This file
-tracks DOM shape, renderer strategy, paint/composite cost, and hidden browser
-fast paths. It intentionally avoids website UI hypotheses.
-
-## Status Legend
-
-| Status | Meaning |
-| --- | --- |
-| ✅ Accepted | Keep this direction unless stronger evidence appears. |
-| ❌ Rejected | Do not retest without a new reason. |
-| 🧪 Test next | High-signal experiment to run soon. |
-| ⚠️ Conditional | Promising only if a cheap, general gate predicts wins. |
-| 🟡 Flat | Tested; no useful movement. |
-| 🔬 Ceiling | Useful to understand an upper bound, not current architecture. |
-| 👀 Watch | Track while testing nearby hypotheses. |
-
-## Marking Rules
-
-- Mark ✅ only when the result works across renderer-only voxel model classes:
-  dense, sparse, tall, wide, flat, multi-color, high-plane-count, and noisy.
-- Mark ❌ when a hypothesis regresses p95/p99 materially, fails visual checks,
-  or contradicts trace evidence.
-- Mark ⚠️ only when the win is real but needs a cheap structural predicate.
-- Keep raw FPS tables and traces in result artifacts; keep this file focused on
-  hypotheses and decisions.
-
-## Current Baseline
-
-Current accepted voxel fast path:
-
-| Layer | Shape |
-| --- | --- |
-| Scene | One transform/perspective scene root. |
-| Mesh | One `.polycss-mesh` wrapper. |
-| Voxel hosts | None. |
-| Leaves | Plain hostless `<b>` direct-matrix voxel quads. |
-| Primitive | Desktop-class documents use 1px; mobile-class documents use 8px with divided matrix scale to avoid GPU filtering gaps. |
-| Positioning | One canonical `matrix3d(...)` per mounted voxel quad. |
-| DOM order | Projected screen-space `tile4-scanline-forward`. |
-| Culling | Only camera-facing face directions are mounted. |
-
-Current read:
-
-- Extra 3D wrappers are expensive.
-- Lower DOM count alone is not a reliable cost model.
-- Direct-matrix voxel leaves still need `transform-style: preserve-3d`.
-- A1 traces show the current polycss-vs-voxcss delta is compositor/layerization
-  work, especially `PaintArtifactCompositor::Update`, `Layerize`, and
-  `LayerTreeImpl::UpdateDrawProperties`. Raster is zero in these samples.
-- `LayerTree.enable` is intrusive enough to perturb FPS; use it only as an
-  opt-in layer-shape diagnostic, not as the primary FPS comparison.
-- Naive scene-box variants can hit a much faster compositor path on
-  `AncientCrashSite.vox`, but current versions are visually invalid: blank,
-  cropped, or off-center. Origin-pinned, scene-matrix-compensated, and
-  mesh-compensated versions preserve the image but lose the win, so the fast
-  path appears tied to the invalid transform chain itself.
-- Corpus runs must normalize visual fit before conclusions. Fixed
-  `POLY_ZOOM=0.35` cropped `army.vox` badly; the apparent voxshell win there
-  was mostly a different fit, not a renderer win.
-- First zoom-normalized corpus pass: `AncientCrashSite`, `Treasure`, `army`,
-  and `HUT` are roughly flat; `Garden`, `skyscraper`, and `MechaGolem` favor
-  polycss; `scene_vehicles1` slightly favors voxcss. Brush count alone does
-  not predict those outcomes.
-- Mounted brush count changes can explain isolated p99 spikes, but not steady
-  slow paths. `army.vox` voxcss had a 58ms frame at a brush-count transition;
-  `Garden.vox` voxcss kept a constant brush count and still stayed slow.
-- A12 structural metrics improved observability but did not produce a complete
-  predictor yet. Brush count, local area, plane-fill ratio, and screen bounds
-  each fail on at least one representative model.
-- Matched-zoom `targetSize` sweeps from 50 to 90 changed local brush area by
-  several multiples but were flat on `Garden`, `skyscraper`, `MechaGolem`, and
-  `AncientCrashSite`.
-- Equivalent `<div>` voxel brushes, leaf `will-change: auto`, a broader
-  voxel-brush CSS reset, and `inert`/`aria-hidden` were flat. Host clipping was
-  visually invalid.
-- DPR 1 vs DPR 2 in headless Chromium was flat on `Garden`, `MechaGolem`, and
-  `AncientCrashSite`; the browser-mode question is now headed/current-vs-canary
-  rather than device pixel ratio.
-- Headed/system/Canary browser mode changes absolute ceilings and can shrink
-  apparent gaps. `MechaGolem` is a major example: bundled Playwright Chromium
-  made polycss look far ahead, while installed Chrome/Canary put polycss and
-  voxcss near parity. `Garden` still favored polycss across browser modes.
-- Paint and style are not the current bottleneck. On high-color `army.vox`,
-  traces showed single-digit milliseconds in style/paint across the whole
-  sample while compositor/layer lifecycle was hundreds of milliseconds.
-- Synthetic classes are useful. Dense cubes and thin slabs are flat, sparse
-  separated voxels favor voxcss, and noisy/high-color scenes are mostly flat;
-  this exposes thresholds that the gallery corpus alone hides.
-- Pre-default matrix-vs-slice selection work is now historical evidence, not a
-  routing plan. The 86-model cadence corpus found matrix p95 wins on
-  `desert2`, `scene_hazmat`, `scene_house`, `scene_mechanic2`,
-  `scene_sidewalk`, and `Treasure`; slice p95 wins on `AncientCrashSite`,
-  `armchair`, `christmas_tree`, `ff1`, `mailbox`, `obj_house3`, `obj_house8`,
-  `obj_trashcan4`, `pyramid`, and `scene_park`; 66 models are flat or capped.
-  Active leaves, local area, visible planes, raw source color count, and screen
-  fill each have counterexamples, so do not revive this as a gate without new
-  GPU-hard proof.
-- Visible shaded brush color count was a useful partial historical selector,
-  and it is different from raw source color count. `visibleShadedColors >= 52`,
-  computed from the current polygon brush plan and baked lighting, captures four
-  validated strong matrix wins (`scene_hazmat`, `scene_house`,
-  `scene_mechanic2`, `Treasure`) and no validated strong slice wins, but it
-  misses `desert2` and `scene_sidewalk`, hits many flat/capped scenes, and
-  creates one p99 regression on `scene_house3` if used by itself. Adding
-  `visiblePlanes < 200` keeps the same p95 wins and removes that p99 loss in
-  the old corpus, so it remains a diagnostic only.
-- Browser probes on Chrome 148 and Canary 150 keep the refined high-shaded
-  gate safe but not universally profitable: `scene_house`, `scene_mechanic2`,
-  `Treasure`, and `desert2` stay matrix; `scene_hazmat` can flatten in Chrome;
-  `scene_sidewalk`, `pyramid`, and `obj_house3` are browser-ceiling sensitive.
-- Headed Chrome tightens that warning: `scene_house` flattens in headed mode
-  even though it is a headless matrix win. Treat the old selector as diagnostic
-  evidence, not a reason to add a router.
-- The browser compositor backend is first-order. Bundled Playwright Chromium
-  can fall onto `SoftwareRenderer::DoDrawQuad`; the perf-facing bench scripts
-  now default to the GPU lane (`--use-angle=metal` on macOS plus
-  `--enable-gpu-rasterization`) because that removes the software renderer and
-  can move medium voxel scenes from the 60fps bucket to the 110+fps bucket
-  without changing DOM.
-- A bench-only adaptive route (`polycss-adaptive-shaded`) proved the
-  high-shaded gate could be computed before mount and route the renderer. It
-  catches `Treasure`, keeps `AncientCrashSite` and `scene_house3` on slices,
-  and routes capped high-shaded models as expected. It still misses `desert2`,
-  which remains a large low-color matrix win, so the selector is incomplete
-  and superseded by the one-strategy direct-matrix baseline.
-- Target-size sweeps on `desert2` and `scene_mechanic2` rule out CSS cell size
-  and local brush area as the cause of the matrix wins. Slice area changed by
-  several multiples while p95 stayed in the same cadence bucket.
-- Five-repeat validation is required for selector work. Two-run sweeps created
-  apparent wins on `scene_sumo`, `scene_parked`, `scene_hunt`, and
-  `scene_house5` that disappeared under validation.
-- Existing non-product prototypes are not valid ceiling proof. `polycss-slice-
-  proto` can improve p95, but screenshots fail the visual check by flattening
-  or otherwise changing the 3D render.
-- Chromium source confirms a real but partial fast path for declarative
-  transform animation. Active compositor transform animation can directly
-  update the cc transform node and skip full `PaintArtifactCompositor::Update`;
-  JS `style.transform` mutation from `scene.setOptions()` does not hit that
-  gate in our traces. The direct path still marks the transform tree dirty, so
-  `LayerTreeImpl::UpdateDrawProperties` and draw remain the next bottleneck.
-- Follow-up probes narrow that animation fast path: running CSS keyframes and
-  running WAAPI skip PAC, but paused WAAPI scrubbed with `currentTime` and a
-  scroll-timeline scrubbed by JS `scrollLeft` both fall back into PAC. Treat
-  declarative animation as an auto-rotate-only candidate until a browser probe
-  proves otherwise.
-- Software-lane synthetic depth-group probes originally suggested only a very
-  strict low-wrapper gate: 17 wrappers could win, 50 already lost cadence, and
-  250 collapsed. A218 supersedes the absolute threshold for the default bench
-  lane: GPU keeps grouped 2D children clean to roughly 112 wrappers, then
-  falls around 128+ and collapses by 136/192.
-- A bench-only real-model depth-group variant still does not justify a default
-  product path. The old sub-30-plane gate was too conservative for GPU, but
-  the currently hard high-leaf models still exceed the clean GPU wrapper range.
-  Use exact depth wrappers only if a real model is GPU-hard, visually exact,
-  and at or below the validated wrapper threshold.
-- A corrected hostless direct-matrix voxel prototype identifies the portable
-  part of matrix wins. `polycss-polybox` showed that parsed polygons inside
-  axis hosts still fall to slice cadence on `desert2`; `polycss-voxlocal-
-  direct-matrix` folds the axis host into each leaf's canonical `matrix3d`
-  with a normal column and transfers the `desert2` win. That shape became the
-  current default after visual checks, cleanup, and tile4 order validation; the
-  remaining question is no longer slice-vs-matrix routing, but why high-leaf
-  GPU-hard scenes still fall below the cap.
-- Exact direct matrix is now the one-leaf-shape baseline, and the hard part is
-  DOM/paint order. Global projected-depth order transfers matrix wins to
-  `desert2`, `house`, `scene_mechanic2`, `Treasure`, and `army`, while fixed
-  face order rescues `obj_house3` and stays neutral on
-  `AncientCrashSite`/`skyscraper`.
-- Hybrid order attempts did not produce a universal rule. Face-depth sorting
-  and depth bands with face locality regress key cases; alternate static face
-  orders and face-normal order trade one model class for another. The most
-  important trace result: same-node-count order flips have almost identical
-  PAC/DrawProps/Draw cost per frame, but radically different vsync cadence.
-  That points at Chromium's 3D compositor sorting/overlap critical path rather
-  than normal style, layout, paint, or node-count costs.
-- Scene-shell transform decomposition does not appear to be the missing fast
-  path. Bench-only A112-A114 variants serialized the root transform to
-  `matrix3d(...)`, moved target translation to an inner shell, moved
-  `perspective` to the host, folded `perspective(...)` into the transform
-  list, and removed the scene `will-change` pin. The only apparent win was a
-  short Desert2 cadence artifact; longer default-vs-no-will-change validation
-  was flat across Garden, `obj_house3`, Desert2, and `scene_house3`.
-- Synthetic A115-A128 sharpen the compositor model. With a fixed synthetic
-  scene of identical `matrix3d` leaves, DOM order can flip p95 near a cadence
-  threshold, especially when projected leaf boxes overlap and adjacent DOM
-  entries jump across Z planes. But the effect is threshold-only: flat-Z scenes
-  are fast, 5000-leaf mixed-depth scenes are unstable across fresh browsers,
-  and heavier 6000-8000-leaf scenes are governed by total dirty 3D leaf load
-  regardless of spatial/depth/random order. Active CSS transform animation
-  still skips PAC/layerize in traces, but no-trace heavy synthetic cadence is
-  not rescued once draw-property/draw work dominates.
-- Synthetic A129-A137 rule out several nearby browser API shortcuts. Leaf
-  `transform-style: flat` catastrophically collapses the synthetic 3D case;
-  backface hiding, leaf `will-change`, leaf containment, root
-  `will-change:auto`, and transform-function spelling are flat/noisy. Larger
-  root scale and primitive/screen footprint increase the share of 3x+ frames;
-  rotation delta is mostly flat, confirming that dirtying the 3D subtree is the
-  cost, not how far it rotates. Static root with the same 7000 leaves stays
-  near the 120fps bucket; JS transform mutation falls to 30-40 p95. Updating a
-  CSS var used in `transform`, registering that var, or updating the individual
-  `rotate` property still hits PAC/layerize around 3.5ms/frame. Active CSS
-  keyframes remain the only tested path that skips PAC.
-- Synthetic A138-A146 identify the cleanest lower-level cost model so far:
-  dirty transformed 3D descendant count dominates, and the fast shape is fewer
-  3D wrappers with many 2D children. In the original software-lane run, the
-  clean wrapper range was very small: 8-12 wrappers were all 1x frames, 16
-  leaked a few 2x frames, 17-28 landed in the 60fps p95 bucket, 32-34 fell to
-  30-40, and 50+ collapsed. Trace confirmed DrawProps dropped from
-  ~4.8ms/frame with per-leaf 3D transforms to ~0.03-0.06ms/frame with grouped
-  2D children. A218 reran the same browser shape on the GPU lane and moved the
-  clean threshold to roughly 112 wrappers, so the old "low teens" number was a
-  backend threshold, not a renderer law. Wrapper `transform-style: flat` is
-  worse, wrapper `will-change` is flat, and valid boxed paint containment is
-  flat; invalid 0x0 paint containment clips all children and only looks fast
-  because it paints nothing. With wrapper count fixed at 8, 2D child count
-  becomes the secondary limit: 10k children stay 120fps, 20k falls to ~60, and
-  30k collapses, with PAC/layerize scaling from ~1.6ms/frame to ~2.6ms/frame
-  between 10k and 20k.
-- A147 checked the real-model feasibility of the software-lane grouped shape.
-  A218 updates the threshold upward for GPU, but the conclusion stays: the
-  hardest visible-plane models still sit beyond the clean exact-wrapper range
-  (`Treasure` 132, `obj_house3` 142, `scene_mechanic2` 163,
-  `scene_house` 182, AncientCrashSite and `scene_park` 191). So the grouped
-  shape is real, but exact depth wrappers are not a universal renderer path
-  for current gallery scenes.
-- GPU-lane reread: every software-only p95 conclusion is now evidence, not a
-  promotion gate. Visual-invalid rejections still stand. Medium direct-matrix
-  scenes that jump to 100+ on GPU (`obj_house3`, `scene_mechanic2`, `treasure`,
-  `desert2`) should be treated as capped/tie cases unless a variant improves
-  p99 without hurting high-plane models. The live optimization target is the
-  GPU-hard class: high visible exact-plane count and high active leaf count
-  (`AncientCrashSite`, `skyscraper`, long-window `army`, plus nearby
-  high-plane scenes).
-- GPU-lane reread of depth wrappers: the old low-teens wrapper threshold was a
-  software-backend result. On ANGLE/Metal, grouped 2D children stay fast until
-  roughly 112 exact depth wrappers, then fall at 128+ and collapse by 136/192.
-  This reopens wrappers only as a narrow GPU-lane special case; it still does
-  not cover the hard models whose exact visible planes sit above that range.
-- A31's first compositor-order metric closes the naive version of that idea.
-  `bench/voxel-order-metrics.mjs` now samples visible exact-matrix voxel leaves
-  over rotation and counts projected AABB overlaps, depth-order inversions,
-  crossing/tie pairs, overlap components, face switches, and depth jumps. The
-  simple depth-inversion metric does not predict FPS: pure depth order has zero
-  inversions but is slow on `obj_house3`, `army` depth-front, and
-  `scene_mechanic2`, while parsed/source order can be fast with 30-40%
-  overlapping depth inversions. The next test should preserve source/spatial
-  locality while applying depth only at block scale.
-- Two-run A31 order sweep, `REPEATS=2`, `WARMUP_MS=1000`, `SAMPLE_MS=3000`,
-  `MOTION=rotate-time`: exact parsed order is now a major candidate, not just
-  global depth. It wins or stays within the fast bucket on `desert2`, `house`,
-  `scene_mechanic2`, `Treasure`, `army`, `obj_house5`, and `skyscraper`, but
-  still fails `obj_house3` and `AncientCrashSite`.
-- A32 rejects source-block-depth ordering as a universal direct-matrix order.
-  Keeping source order inside fixed-size blocks and sorting only block roots by
-  projected depth is a useful middle form: it gets close on `obj_house5`,
-  `desert2`, `scene_mechanic2`, `Treasure`, and `AncientCrashSite`. It still
-  loses badly on `obj_house3`, misses `army` and `skyscraper`, and the winning
-  front/back direction plus block size are model-specific. This is a reusable
-  diagnostic primitive, not a renderer policy.
-- A33 is the strongest order result so far. Projected screen-space tile groups
-  with exact direct-matrix leaves beat the prior A31 best on 8 of 9 quick
-  two-run models, with `skyscraper` still in its capped/noisy class. The best
-  tile policy remains model-specific, but `tile4-scanline-forward` is the first
-  plausible single policy: it rescues `obj_house3`, stays in the high bucket on
-  `obj_house5`, `desert2`, `house`, `scene_mechanic2`, `Treasure`, and
-  `AncientCrashSite`, and improves `army` over A31 exact. Later validation made
-  this the D3 baseline order; remaining order work must improve GPU-hard
-  intervals rather than re-prove tile4.
-- A34 validated `tile4-scanline-forward` as the broad direct-matrix default
-  order before it became D3, but not as the full solution. With five repeats and
-  only the minimum comparator set, it produces large p95 wins on
-  `obj_house3`, `obj_house5`, `desert2`, `house`, `scene_mechanic2`, and
-  `Treasure`, is neutral on `AncientCrashSite`, modest on `skyscraper`, and
-  unstable/near-flat on `army`. The next single-strategy validation is
-  `tile4-depth-front`, because A33 suggests it may cover weak scanline cases.
-- Probe A35 rejects `tile4-depth-front` as the one strategy. It helps `army`
-  and ties several high-bucket models, but collapses `obj_house3` and
-  `Treasure`; its hard-set average is lower than A34 `tile4-scanline-forward`.
-  Do not pursue a gate here: the requirement is one strategy, so the useful
-  path is testing nearby single scanline policies.
-- Probe A36 rejects nearby scanline tile sizes as replacements. `tile3`,
-  `tile5`, and `tile6` each have hard counterexamples and lower hard-set
-  averages than validated `tile4-scanline-forward`. The next one-strategy idea
-  should keep tile4 grouping and vary only tile traversal order, e.g.
-  serpentine or Morton/Z-order locality.
-- Probe A37 rejects tile4 serpentine and Morton traversal as replacements.
-  Morton helps `desert2`/`Treasure` slightly and serpentine helps `army`, but
-  both lose `obj_house3`; serpentine also loses `house`, and both have lower
-  hard-set averages than row-major `tile4-scanline-forward`. The incumbent
-  remains the only broad one-strategy candidate.
-- Probe A38 rejects direct-matrix voxel leaf `transform-style: flat`. This was
-  not just an old slice-host requirement: on the current hostless matrix shape
-  it collapsed every hard-set model (`AncientCrashSite` p95 39.9 -> 5.7,
-  `desert2` 107.0 -> 14.5, `MechaGolem` 112.3 -> 23.8). Preserve-3d on each
-  leaf appears to be part of Chromium's valid 3D compositor path.
-- Probe A39 rejects `backface-visibility: hidden` on direct voxel leaves. The
-  FPS result is tempting (`Treasure` 40.0 -> 59.6, `army` 39.9 -> 57.8,
-  `scene_mechanic2` 60.8 -> 109.8), but static screenshot diffs are visually
-  invalid: 21-96% of pixels changed on the checked hard-set models. Hidden
-  backface is a different render, not a perf win.
-- Probe A40 rejects `contain: layout style` on `.polycss-voxel-mesh`. It is
-  mostly flat and helps `skyscraper`, but it collapses `desert2` p95
-  107.0 -> 60.1. Wrapper containment changes the same hidden compositor
-  ordering class we are trying to exploit, so it is not a general renderer
-  boundary.
-- Probe A41 rejects the corrected version of hidden backfaces: orienting each
-  direct matrix so the CSS front face matches the voxel normal restores visual
-  parity (mean screenshot deltas around 0.00002-0.00007), but the perf win
-  disappears and `desert2` regresses 107.0 -> 60.7 p95. A39's speedup came
-  from dropping real faces, not from a safe backface compositor fast path.
-- Probes A42-A46 reject changing the off-plane normal-column magnitude. Static
-  screenshots stay visually equivalent because local `z=0`, but any tested
-  non-unit normal scale (`0.1`, `2`, `50`, side-only, or z-only) collapses
-  `desert2` from ~107 p95 into the ~60 cadence class. Some variants improve
-  `scene_mechanic2`, so this is a real compositor classification lever, but
-  the current exact `±1` normal column is the only broadly safe single policy.
-  Paired traces did not show a proportional PAC/Layerize/DrawProps reduction
-  when cadence changed (`scene_mechanic2` normal `0.1` jumped p95 while those
-  buckets stayed within roughly 1%), reinforcing that the win/loss is hidden
-  compositor scheduling or property-tree classification rather than measured
-  style, paint, or compositor CPU.
-- Probes A47-A66 reject moving visible scale out of the direct matrix as a
-  default strategy. Fixed 64px canonical quads, CSS `width/height` plus an
-  orient/translate matrix, fixed `BASE_TILE` quads, and one mesh-global max
-  primitive all regress or flatten the split models. Per-leaf square
-  normalization (`primitive = max(width,height)`, matrix columns <= 1) looked
-  like the only real signal in early short-window runs, but cleanly rebuilding
-  the bench bundles from source and re-running with 100+ p95 treated as a
-  capped tie changes the read: exact square and `<=600px` fallback do not
-  reliably move `desert2` or `scene_mechanic2`, axis-only and face-only splits
-  are flat, and inverse `>600px` / `>300px` bands are flat. A narrow
-  `300-600px` band briefly put `scene_mechanic2` into the 100+ bucket in a
-  3s two-run sample, but an 8s confirmation returned to baseline. The
-  actionable conclusion is that primitive-size normalization is a noisy
-  cadence lever, not a shippable single renderer shape.
-- Probe A67 adds `bench/trace-frame-buckets.mjs`, which aligns raw Chromium
-  trace events with rAF frame intervals using `performance.mark`/`timeStamp`
-  markers. The key read is per-cadence-bucket, not whole-run totals:
-  `Garden.vox` slow buckets have PAC/layerize/draw-props/draw several times
-  higher than x1 frames, while `desert2.vox` and `scene_mechanic2.vox` sit near
-  a steady 8.3ms budget edge with only small compositor deltas between x1 and
-  x2 frames. Optional `--dom-samples` child-count sampling shows those buckets
-  are not explained by face-cull swaps: Garden stayed at 6572 mounted leaves,
-  Desert2 at 1984, and scene_mechanic2 at 2216 in the checked windows.
-- Probes A70-A86 confirm DOM order phase is a real hidden compositor lever,
-  but reject the tested forms as a default. Fixed `rotY` order lookahead
-  offsets found large wins (`+30deg`: Garden ~30 -> ~39 p95, Desert2 ~60 ->
-  100+, Treasure ~40 -> ~58), but `obj_house3` regressed ~60 -> ~40. Centering
-  the order within the current visible-face interval kept the Garden/Desert2/
-  Treasure wins and avoided the worst `obj_house3` p95 drop, but introduced an
-  `obj_house3` p99 tail loss and left Skyscraper borderline. Interval
-  fractions and per-item huge-rectangle fallback did not remove that
-  counterexample. Boundary screen-span anchors and adaptive 3x3/5x5 tile
-  density then produced the best short-window result so far, but the 8s
-  confirmation rejected it as a universal rule: it won Garden/Treasure and
-  helped `scene_mechanic2`, but regressed AncientCrashSite and `obj_house3`.
-  Slot-churn analysis showed the phase wins are not from fewer pooled-element
-  style rewrites at cull boundaries. The actionable conclusion is that order
-  phase is still the most promising lever, but aggregate p95 is now too blunt:
-  the next metric must bucket frames by visible-face interval and identify
-  which interval/order pair causes each win or loss.
-- Probe A87 adds `bench/voxel-interval-profiler.mjs` and compares baseline
-  against the rejected adaptive screen-span order by visible-face interval.
-  The result explains why the global rule failed: Garden's `t|br|fr` interval
-  improves ~30 -> ~39.5 p95, Treasure's `t|br|fr` improves ~40 -> ~60, and
-  `scene_mechanic2` improves in `t|br|fr`/`t|fr|fl`; but AncientCrashSite's
-  `t|bl|br` interval drops ~39 -> ~30 and `obj_house3` drops hard in
-  `t|br|fr` and `t|fr|fl`. Signature alone is not enough because the same
-  signature can be a win on one geometry distribution and a loss on another.
-  The next useful test is per-interval geometry correlation, not another
-  whole-model aggregate order sweep.
-- Probes A88-A91 add per-interval geometry/face-pair correlation and reject
-  two derived order variants. Top-face anchoring was meant to protect the
-  harmful top/top or top/side changed pairs, but it also removed the useful
-  Garden/Scene/Treasure wins. Reversing scanline traversal inside the same
-  adaptive phase rule regressed the hard set, especially `obj_house3`. The
-  face-pair read is still valuable: losses are not explained by count or
-  span alone, but the tested pair-level fixes are too blunt.
-- Probes A92-A93 add exact interval order replay. A92 was discarded because
-  it computed order at interval midpoint; A93 corrects this by computing order
-  at visible-face interval entry, matching when the renderer actually patches
-  DOM order. The corrected diff shows two different failure modes:
-  `obj_house3` losses are dominated by huge top leaves spanning ~1.45 coarse
-  tiles, while AncientCrashSite's loss comes from massive all-leaf rank motion
-  among much smaller primitives and only ~11% changed overlap area. That rules
-  out a signature-only or count-only order policy.
-- Probes A94-A95 reject the first structural guards derived from A93. A94 kept
-  product tile4 slots, phased movable leaves toward the interval center, and
-  pinned very large top occluders; it regressed `obj_house3` hard and did not
-  recover Garden/Treasure. A95 removed the top pinning and only enabled
-  centered order when an interval had a large projected blocker; it still
-  regressed `obj_house3` and stayed flat elsewhere. The lesson is that coarse
-  "large blocker present" and "large top occluder" predicates are too blunt;
-  the useful order signal is lower-level than per-face/per-span guards.
-- Probes A96-A103 reopen plain tile granularity under a matched current
-  baseline. Tile3 current-screen order improves AncientCrashSite in a short
-  window but collapses `obj_house3`; tile6 current-screen order is flat/worse.
-  Tile5 current-screen order is the only adjacent single-shape candidate that
-  survived 8s two-run validation: `garden` improves ~30 -> ~39.5 p95, no
-  checked model loses more than 8 p95, `obj_house3`/`mecha-golem` stay in their
-  high buckets, and Treasure/Skyscraper p99 tails improve. It is not a broad
-  breakthrough because Ancient/Army p99 tails worsen by ~3ms and most models
-  are flat, but it is cleaner than phase/guard attempts and worth one more
-  traversal-direction probe.
-- Probes A104-A105 reject tile5 traversal-direction variants. Tile5
-  serpentine loses `obj_house3`, Skyscraper, and the Garden win. Tile5 reverse
-  scanline finds a large short-window Desert2 win, but also loses `obj_house3`
-  and does not keep Garden. The surviving single-shape candidate remains
-  tile5 scanline-forward, not a traversal change.
-- Probes A106-A107 trace Garden tile4 vs tile5-forward. Tracing perturbs the
-  FPS enough that the p95 win does not reproduce directly, but both runs keep
-  the same 7186 mounted leaves and the same compositor-cost class. Tile5
-  reduces the sampled x4+ bucket count in the trace window, which supports the
-  current read: tile count is changing Chromium's cadence/scheduling threshold,
-  not reducing style, paint, DOM count, or raster work.
-- Probes A108-A111 reject tile5 scanline-forward as the default after a broader
-  corpus pass. A108/A109 add generic `vox:filename.vox` bench IDs and run 24
-  additional files. The filter finds no strong p95 wins, one strong p95 loss
-  (`scene_house3` ~40 -> ~30), and p99 tail regressions on capped-looking
-  models (`mailbox`, `scene_house`, `scene_house5`, `scene_army`). A110/A111
-  confirm the risk set at 8s: `scene_house3` loses ~9.8 p95, `mailbox` p99
-  worsens by ~7.5ms, `scene_house` p99 worsens by ~5.5ms, and `scene_army`
-  p99 worsens by ~3.7ms. Tile5 remains a useful diagnostic for Garden, but it
-  is not the one-shape policy.
-
-Latest A66 long-window square-band confirmation, p95 FPS medians:
-
-| Model | Baseline | `300-600px` square band | Read |
-| --- | ---: | ---: | --- |
-| `Garden.vox` | 30.0 / 57.8ms p99 | 30.0 / 60.5ms p99 | Flat, slight tail noise. |
-| `desert2.vox` | 60.1 / 16.8ms p99 | 60.1 / 16.8ms p99 | Flat. |
-| `scene_mechanic2.vox` | 60.1 / 16.8ms p99 | 60.1 / 16.8ms p99 | Short 100+ win did not hold. |
-| `skyscraper.vox` | 29.9 / 43.2ms p99 | 29.9 / 45.9ms p99 | Flat, slight tail noise. |
-
-Latest A74 centered-interval order validation, p95 FPS medians:
-
-| Model | Baseline | Centered interval order | Read |
-| --- | ---: | ---: | --- |
-| `Garden.vox` | 30.1 / 47.8ms p99 | 39.8 / 39.4ms p99 | Win. |
-| `desert2.vox` | 60.4 / 16.7ms p99 | 100+ / 9.3ms p99 | Win to capped bucket. |
-| `Treasure.vox` | 40.1 / 25.4ms p99 | 57.3 / 28.4ms p99 | Win. |
-| `scene_mechanic2.vox` | 61.6 / 16.7ms p99 | 59.9 / 16.9ms p99 | Flat. |
-| `obj_house3.vox` | 60.1 / 16.9ms p99 | 57.5 / 28.8ms p99 | Tail loss. |
-| `skyscraper.vox` | 34.5 / 41.8ms p99 | 29.4 / 44.5ms p99 | Borderline/flat. |
-
-Latest hard-split validation, p95 FPS medians:
-
-| Model | Slice | Face | Normal F | Depth F | Depth B | Read |
-| --- | ---: | ---: | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 112.6 | 114.9 | 111.2 | 59.9 | 58.8 | Needs top/face locality. |
-| `obj_house5.vox` | 116.3 | 113.6 | 114.9 | 114.9 | 59.9 | Front/top orders safe; depth-back bad. |
-| `desert2.vox` | 59.7 | 59.9 | 59.9 | 113.6 | 114.9 | Needs projected depth. |
-| `house.vox` | 59.9 | 113.6 | 59.9 | 116.3 | 116.3 | Depth is best; face is usable. |
-| `scene_mechanic2.vox` | 59.5 | 59.9 | 59.9 | 114.9 | 115.1 | Needs projected depth. |
-| `Treasure.vox` | 29.9 | 30.0 | 40.0 | 57.6 | 40.0 | Needs depth-front for the high bucket. |
-| `army.vox` | 40.0 | 40.2 | 30.0 | 30.1 | 58.5 | Needs depth-back. |
-| `AncientCrashSite.vox` | 39.8 | 40.0 | 30.0 | 39.8 | 39.9 | Face/top neutral; normal sorting bad. |
-| `skyscraper.vox` | 29.8 | 29.7 | 29.9 | 24.0 | 29.9 | Mostly capped; depth-front bad. |
-
-Latest A31 two-run order-metric sweep, p95 FPS medians:
-
-| Model | Slice | Exact | Face | Normal F | Depth F | Depth B | Read |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 59.9 | 40.0 | 109.3 | 109.9 | 39.7 | 30.0 | Needs face/normal-front locality; depth correctness is actively bad. |
-| `obj_house5.vox` | 59.9 | 113.0 | 112.4 | 111.7 | 113.0 | 59.9 | Many front/local orders are fast; depth-back is bad. |
-| `desert2.vox` | 59.7 | 114.3 | 58.8 | 59.7 | 112.3 | 111.1 | Parsed/depth-like order wins; face locality is bad. |
-| `house.vox` | 59.8 | 112.3 | 59.9 | 59.5 | 109.0 | 59.9 | Parsed/depth-front order wins; face locality is bad. |
-| `scene_mechanic2.vox` | 40.0 | 111.7 | 59.3 | 59.3 | 59.9 | 59.9 | Parsed source order wins; pure depth no longer explains it. |
-| `Treasure.vox` | 39.2 | 58.6 | 39.9 | 49.4 | 58.7 | 58.1 | Parsed and depth are tied in the fast bucket. |
-| `army.vox` | 39.8 | 49.3 | 39.8 | 30.0 | 30.0 | 40.0 | Parsed order is best in this quick run. |
-| `AncientCrashSite.vox` | 34.7 | 29.9 | 39.9 | 30.0 | 39.0 | 39.6 | Face/top/depth are neutral; exact parsed is bad. |
-| `skyscraper.vox` | 21.5 | 29.8 | 29.9 | 29.8 | 26.7 | 34.5 | Mostly capped; depth-back is best in this quick run. |
-
-Latest A32 source-block-depth sweep, p95 FPS medians:
-
-| Model | Best A32 | Strategy | Prior A31 best | Delta | Read |
-| --- | ---: | --- | ---: | ---: | --- |
-| `obj_house3.vox` | 59.6 | block128-depth-back | 109.9 | -50.3 | Source blocks do not preserve the face/normal locality this model needs. |
-| `obj_house5.vox` | 111.9 | block64-depth-front | 113.6 | -1.7 | Coarse front depth plus source locality is close to the best static order. |
-| `desert2.vox` | 114.3 | block128-depth-back | 114.3 | -0.1 | Source-block depth transfers the matrix win. |
-| `house.vox` | 108.1 | block128-depth-front | 112.3 | -4.2 | Only one block size/direction reaches the high bucket. |
-| `scene_mechanic2.vox` | 111.1 | block64-depth-front | 111.7 | -0.6 | Coarse front depth transfers most of the parsed-order win. |
-| `Treasure.vox` | 58.4 | block64-depth-front | 58.7 | -0.3 | Source-block depth stays in the high bucket. |
-| `army.vox` | 40.2 | block256-depth-front | 49.3 | -9.1 | Block depth cannot reproduce parsed-order benefit. |
-| `AncientCrashSite.vox` | 39.8 | block64-depth-front | 39.9 | -0.1 | Neutral; does not improve the hard case. |
-| `skyscraper.vox` | 30.0 | block256-depth-front | 34.5 | -4.4 | Still capped/slow relative to depth-back. |
-
-Latest A33 projected-tile sweep, p95 FPS medians:
-
-| Model | Best A33 | Strategy | Prior A31 best | Delta | Read |
-| --- | ---: | --- | ---: | ---: | --- |
-| `obj_house3.vox` | 114.9 | tile4-scanline-forward | 109.9 | +5.1 | Screen scanline order rescues the model that source/depth could not. |
-| `obj_house5.vox` | 115.6 | tile4-scanline-reverse | 113.6 | +2.0 | Many tile orders are high; direction is not fragile here. |
-| `desert2.vox` | 117.6 | tile4-depth-front | 114.3 | +3.3 | Tile depth-front beats parsed/depth order. |
-| `house.vox` | 112.4 | tile8-depth-front | 112.3 | +0.1 | Ties the prior best; tile8 scanline variants are bad. |
-| `scene_mechanic2.vox` | 117.0 | tile8-scanline-forward | 111.7 | +5.2 | Screen grouping beats parsed source order. |
-| `Treasure.vox` | 59.7 | tile4-depth-back | 58.7 | +1.0 | Still around the high bucket; no major new ceiling. |
-| `army.vox` | 58.8 | tile8-scanline-reverse | 49.3 | +9.6 | Screen grouping finds the missing win that source blocks missed. |
-| `AncientCrashSite.vox` | 40.0 | tile4-depth-front | 39.9 | +0.1 | Neutral; this model remains at its ~40 p95 class. |
-| `skyscraper.vox` | 30.0 | tile4-scanline-forward | 34.5 | -4.5 | Still capped/noisy; quick A31 depth-back needs validation before treating this as a regression. |
-
-Latest A34 `tile4-scanline-forward` validation, p95 FPS medians:
-
-| Model | Slice | Tile4 scanline F | Delta | Tile p50 | Tile p99 ms | Read |
-| --- | ---: | ---: | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 59.9 | 113.6 | +53.8 | 120.5 | 9.2 | Validated win; this rescues the main face/locality counterexample. |
-| `obj_house5.vox` | 59.9 | 113.4 | +53.6 | 120.5 | 9.2 | Validated win. |
-| `desert2.vox` | 59.5 | 113.6 | +54.1 | 120.5 | 9.2 | Validated win, though A33 depth-front was slightly higher. |
-| `house.vox` | 59.9 | 114.7 | +54.9 | 120.5 | 9.3 | Validated win. |
-| `scene_mechanic2.vox` | 40.0 | 113.5 | +73.5 | 120.5 | 9.2 | Validated win. |
-| `Treasure.vox` | 30.5 | 58.5 | +28.0 | 60.2 | 24.0 | Validated win into the ~60 FPS class. |
-| `army.vox` | 39.8 | 42.1 | +2.2 | 60.2 | 25.1 | Not enough; runs split between ~40 and ~58 p95. |
-| `AncientCrashSite.vox` | 39.8 | 39.8 | +0.0 | 59.9 | 27.9 | Neutral; this model remains in the ~40 p95 class. |
-| `skyscraper.vox` | 23.7 | 29.9 | +6.2 | 40.0 | 39.8 | Modest win, still capped/slow. |
-
-Probe A35 `tile4-depth-front` single-strategy check, p95 FPS medians:
-
-| Model | Slice | Scanline F | Depth F | Depth - scanline | Read |
-| --- | ---: | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 59.9 | 113.6 | 59.9 | -53.8 | Depth-front fails the face/locality class. |
-| `obj_house5.vox` | 59.9 | 113.4 | 114.7 | +1.2 | Tie. |
-| `desert2.vox` | 59.5 | 113.6 | 113.6 | -0.0 | Tie. |
-| `house.vox` | 59.9 | 114.7 | 111.1 | -3.6 | Scanline is better. |
-| `scene_mechanic2.vox` | 40.0 | 113.5 | 114.9 | +1.4 | Tie. |
-| `Treasure.vox` | 30.5 | 58.5 | 40.0 | -18.5 | Depth-front loses the high bucket. |
-| `army.vox` | 39.8 | 42.1 | 48.7 | +6.7 | Depth-front helps but not enough to justify losing other models. |
-| `AncientCrashSite.vox` | 39.8 | 39.8 | 39.8 | +0.0 | Tie. |
-| `skyscraper.vox` | 23.7 | 29.9 | 29.9 | +0.0 | Tie. |
-
-Probe A36 scanline tile-size sweep, p95 FPS medians:
-
-| Model | Tile3 | Tile4 | Tile5 | Tile6 | Read |
-| --- | ---: | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 59.7 | 113.6 | 111.1 | 111.7 | Tile3 fails; tile4 remains best. |
-| `obj_house5.vox` | 111.0 | 113.4 | 114.3 | 113.7 | Tile5 is slightly higher in a two-run probe. |
-| `desert2.vox` | 113.0 | 113.6 | 84.6 | 84.6 | Tile5/6 are unstable or slow. |
-| `house.vox` | 59.9 | 114.7 | 61.2 | 112.4 | Tile3/5 fail. |
-| `scene_mechanic2.vox` | 114.2 | 113.5 | 108.7 | 60.2 | Tile6 fails; tile3 only marginally higher. |
-| `Treasure.vox` | 58.1 | 58.5 | 58.3 | 58.3 | Flat; tile4 remains best. |
-| `army.vox` | 40.0 | 42.1 | 39.9 | 40.0 | No tile-size variant fixes the weak case. |
-| `AncientCrashSite.vox` | 39.8 | 39.8 | 30.1 | 39.5 | Tile5 fails; tile3/tile4 tie. |
-| `skyscraper.vox` | 30.0 | 29.9 | 30.0 | 30.0 | Flat. |
-
-Probe A37 tile4 traversal sweep, p95 FPS medians:
-
-| Model | Row-major | Serpentine | Morton | Read |
-| --- | ---: | ---: | ---: | --- |
-| `obj_house3.vox` | 113.6 | 60.2 | 59.9 | Row-major is required for the main counterexample. |
-| `obj_house5.vox` | 113.4 | 112.4 | 111.7 | Row-major holds. |
-| `desert2.vox` | 113.6 | 112.7 | 114.9 | Morton slightly higher in a two-run probe. |
-| `house.vox` | 114.7 | 59.9 | 107.7 | Serpentine fails; row-major holds. |
-| `scene_mechanic2.vox` | 113.5 | 112.3 | 111.7 | Row-major holds. |
-| `Treasure.vox` | 58.5 | 48.7 | 58.8 | Morton ties/slightly higher; serpentine loses. |
-| `army.vox` | 42.1 | 48.9 | 44.0 | Serpentine helps, but not enough to offset losses. |
-| `AncientCrashSite.vox` | 39.8 | 39.8 | 40.0 | Flat. |
-| `skyscraper.vox` | 29.9 | 30.0 | 30.0 | Flat. |
-
-## Accepted Decisions
-
-| ID | Status | Decision | Why it stays |
-| --- | --- | --- | --- |
-| D1 | ✅ Accepted | Preserve raw `PolyVoxelSource` and render eligible `.vox` meshes through a dedicated fast path. | This produced the major win over polygon `matrix3d` leaves. |
-| D2 | ✅ Accepted | Keep the hostless direct-matrix DOM shape as the default. | It removes voxel hosts, uses one canonical `<b>` matrix per visible quad, and is the only one-shape baseline that survives the GPU reread. |
-| D3 | ✅ Accepted | Keep `tile4-scanline-forward` as the default DOM order. | Most order alternatives were either model-specific or software-lane artifacts; tile4 row-major remains the broadest single policy while medium GPU cases are now capped/ties. |
-| D4 | ✅ Accepted | Prefer exact parsed voxel quads over source overpaint for default rendering. | The exact path preserves visual correctness; lower-node source variants did not reliably win. |
-| D5 | ✅ Accepted | Keep camera-facing culling. | Mounting all faces regressed hard. |
-| D6 | ✅ Accepted | Keep integer CSS cell snapping for `.vox` normalization. | It avoids a scale wrapper and keeps brush coordinates on integer pixels. |
-| D7 | ✅ Accepted | Normalize visual fit before comparing voxel renderer FPS. | Fixed zoom can crop or resize large voxel scenes enough to change the benchmark question. |
-| D8 | ✅ Accepted | Treat GPU as the default bench lane and software as an explicit stress lane. | A211-A217 show the default bundled software renderer can manufacture 60fps ceilings that disappear under normal GPU compositing. |
-
-## Active Hypotheses
-
-| ID | Status | Hypothesis | Experiment | Mark ✅ if | Mark ❌ if |
-| --- | --- | --- | --- | --- | --- |
-| A1 | ✅ Accepted | Polycss and voxcss differ mainly in compositor/layerization work, not raster/layout. | Done on `AncientCrashSite.vox` and `Treasure.vox`: polycss shows higher `PaintArtifactCompositor::Update`, `Layerize`, and draw-property work; raster is zero for both engines. | Next tests can target style/transform/layer-shape causes. | Reopen only if broader traces contradict the compositor/layerization read. |
-| A2 | ❌ Rejected | Computed-style differences point mainly at scene shell/transform shape, not raster/layout. | Scene-shell differences identified the invalid 120fps path, but visual-preserving compensation, perspective, tags, CSS resets, and containment did not keep the win. | Reopen only with a new visual-preserving shell form. | All current shell/style variants are flat or visually invalid. |
-| A3 | ✅ Accepted | Current spot checks are hiding model classes. | Done on a starter corpus with zoom-normalized polycss/voxcss comparison. | Keep corpus sweeps as the default proof path. | Reopen only if later full-corpus data collapses to one uniform behavior. |
-| A4 | 🟡 Flat | Host containment is useful for a structural class of models. | `polycss-shell-host-only` was flat/noisy on `Garden`, `MechaGolem`, `scene_vehicles1`, `AncientCrashSite`, and `army`; `polycss-baked-voxshell` changed visual fit and is not a clean containment result. | Reopen only with a narrower containment-only variant or layer-bound evidence. | Host-only containment remains flat across representative classes. |
-| A5 | ❌ Rejected | A visual-preserving scene box/transform chain may keep the compositor fast path. | Tested naive `scene-size`, `scene-position`, `host-size`, `box-only`, origin-pinned boxes, scene-matrix compensation, and mesh compensation on `AncientCrashSite.vox`. | Reopen only if a different shell form preserves both visual output and the fast compositor path. | Visual-preserving variants drop back to baseline; fast variants are blank, cropped, or off-center. |
-| A6 | 🟡 Flat | Perspective placement/value changes compositor behavior. | Tested current huge finite perspective against `perspective:none` and `100000px` on `AncientCrashSite`, `Garden`, `MechaGolem`, `skyscraper`, and `scene_vehicles1`. | Reopen only for a different transform-chain placement, not value alone. | Perspective value changes were visually equivalent and flat. |
-| A7 | 🟡 Flat | Target size/cell size changes compositor pressure enough to matter after visual fit is normalized. | Matched-zoom sweep from target 50/60/70/80/90 on `Garden`, `skyscraper`, `MechaGolem`, and `AncientCrashSite`. | Reopen only if a different matched-fit policy changes actual screen bounds or brush count. | Local area changed by multiples while p95/p99 stayed effectively flat. |
-| A8 | 🟡 Flat | A different brush tag hits a cheaper UA/style path. | Compared `<b>` against equivalent `<div>` voxel brush leaves across representative corpus. | Reopen only with another tag/style pair that is visually equivalent and moves trace/FPS. | Equivalent `<div>` brushes track `<b>` within noise. |
-| A9 | 🟡 Flat | A minimal voxel-only CSS reset reduces style or paint cost. | Tested leaf `will-change: auto` and a broader voxel-only reset for box/font/background-repeat/will-change. | Reopen only with trace evidence for style-rule cost. | CSS reset variants were flat; `army` apparent wins collapsed under longer runs. |
-| A10 | 🟡 Flat | Accessibility/event trees add measurable overhead for thousands of semantic leaves. | Added `aria-hidden`/`inert` to the polycss mesh subtree across representative corpus. | Reopen only outside headless rotation or with accessibility-tree-specific evidence. | FPS/task metrics stayed flat. |
-| A11 | 🟡 Flat | Paint chunks are fragmented by color/style cardinality. | Traced high-color `army`, medium-color `Garden`, and low-color `MechaGolem`. Style/paint stayed tiny relative to compositor/layer lifecycle. | Reopen only if a future renderer increases paint/raster time. | Paint/style are not the current bottleneck. |
-| A12 | ✅ Accepted | The planner needs a browser/compositor cost model, not a rectangle-count minimum. | Added brush area, depth-plane count, color count, local union/overdraw, plane fill, screen bounds, browser-mode checks, and synthetic classes. | Future planner work should use compositor/browser metrics and synthetic thresholds. | Reopen only if a simple DOM metric later predicts the corpus. |
-| A13 | ❌ Rejected | View-dependent mounted brush count explains p95/p99 drops broadly. | Sampled mounted brushes during rotation. Counts changed on several models, but `Garden.vox` voxcss stayed slow with constant brush count. | Reopen only as a narrow mutation-spike hypothesis. | Stable mounted count can still have poor p95/p99. |
-| A14 | ❌ Rejected | Cull-boundary mutation is the parity path. | Sampled transition spikes, then tested a cull-freeze diagnostic on `army` and `scene_vehicles1`. Removing swaps did not improve the path and could regress by holding the wrong visible set. | Reopen only with a concrete predictive/batched swap algorithm, not freeze/no-swap. | Cull changes can cause isolated spikes, but are not the broad parity gap. |
-| A15 | ✅ Accepted | Browser mode changes the apparent fast path. | DPR 1/2 was flat; headed mode changed absolute cadence; installed Chrome/Canary changed `MechaGolem` from a large polycss win to near parity. | Benchmark reports must include browser executable, headed/headless, and DPR. | Reopen if CI/browser standardization makes this stable again. |
-| A16 | 🟡 Flat | CSS rule matching remains a cost even for voxel fast path. | Minimal CSS/reset variants were flat, and traces showed style recalc is tiny compared with compositor/layer lifecycle. | Reopen only with trace evidence that style recalc dominates. | Current traces show compositor/raster lifecycle dominates instead. |
-| A17 | ❌ Rejected | Host clipping/isolation can reduce paint bounds without leaf clipping. | Host containment was flat; host `overflow: clip` plus `contain: paint` was screenshot-tested on `AncientCrashSite.vox`. | Reopen only with a different boundary that passes screenshots. | Host clipping split the slice planes and dropped visible geometry. |
-| A18 | ❌ Rejected | Existing non-product prototypes establish a valid ceiling. | Ran `polycss-slice-proto` and `polycss-polybox` on `AncientCrashSite`, `Garden`, and synthetic sparse grid. `slice-proto` can be faster but fails visual checks; `polybox` is not a consistent win. | Reopen only with a render-correct ceiling prototype. | Current prototypes change the visual render or do not beat the fast path. |
-| A19 | ✅ Accepted | Benchmark instrumentation can perturb results. | `LayerTree.enable` changed the AncientCrashSite FPS path, especially for polycss; keep layer-tree capture opt-in and separate from FPS traces. | Use low-intrusion traces for FPS comparisons and isolated diagnostic runs for layer counts. | Reopen if a cheaper layer-shape probe is found. |
-| A20 | ✅ Accepted | Synthetic model classes are needed to expose thresholds. | Generated dense cube, sparse grid, thin slab, and noisy/high-color `.vox` models. Dense/thin cases are flat; sparse separated voxels favor voxcss; noisy/high-color is mostly flat. | Keep synthetic classes in future benchmark sweeps. | Reopen only if synthetic behavior diverges from future real-model findings. |
-| A21 | ❌ Rejected | Route only some `.vox` models between voxel slices and matrix fallback. | 86-model cadence corpus plus the bench-only `polycss-adaptive-shaded` route proved selectors are partial and browser-sensitive. D2/D3 supersede this direction: hostless direct matrix plus tile4 order is now the one-strategy baseline, and GPU reread makes many old medium-scene routing wins capped/tie evidence. | Reopen only if a future second renderer is visually exact and wins the GPU-hard class behind a cheap static predicate. | Do not use old slice-vs-matrix selector data to add a router. |
-| A22 | 🧪 Test next | Declarative camera animation can skip PAC for auto-rotate scenes, but cannot solve interactive JS rotation by itself. | Chromium source read plus `apocalypse/car.glb` probes: JS rotation hit PAC every sample frame; CSS keyframe and running WAAPI hit zero PAC; paused WAAPI `currentTime` and JS `scrollLeft` scroll-timeline probes still hit PAC. Build a bench-only WAAPI/CSS camera mode and run voxel + non-voxel traces without treating trace FPS as final. | Accept a separate auto-rotate path if validated runs show lower PAC and better cadence without visual drift or API contortions. | Reject as a general renderer fix if interactive pointer-driven controls still require JS transform mutation and draw-property cost remains dominant. |
-| A23 | ✅ Accepted | Dirty 3D transform-node count is the next lower-level cost model after active DOM leaves. | `bench/compositor-topology-probe.mjs` confirmed the source read: at equal 2500 leaves, `left/top` and 2D `translate` were near-free in draw properties, while `translateZ(0)`, real `translateZ`, and `matrix3d` were ~40-60x higher. | Use this as the browser-shape benchmark for future topology ideas. | Reopen only if another Chromium version makes 3D leaves decompose cheaply. |
-| A24 | ⚠️ Conditional | Projected distribution/overlap may explain model variance that leaf count misses. | One longer synthetic distribution probe at equal 1200 `matrix3d` leaves moved DrawProps/Draw by about 20%, but PAC/layerize stayed similar; a shorter rerun was noisier. | Promote if controlled screen-coverage runs and real-model pairs show the same separation. | Reject if the effect collapses under controlled repeats. |
-| A25 | ⚠️ Conditional | Exact depth-plane wrappers are backend-specific and only useful under a visible-plane gate. | Software-lane `depth-groups` made 17 wrappers fast and 50+ unstable; A218 updates the GPU-lane threshold to roughly <=112 wrappers before cadence falls. The bench-only real-model variant found no default product payoff, and current GPU-hard models exceed the clean range. | Reopen only for a high-leaf GPU-hard real model at or below the validated exact-plane threshold. | Reject as a default renderer; it cannot cover the high-plane hard class. |
-| A26 | ✅ Accepted | Hostless direct canonical matrix brushes are the transferable part of matrix wins. | `polycss-polybox` uses parsed polygons but keeps axis hosts and falls to slice cadence; `polycss-voxlocal-direct-matrix` removes hosts, folds scale/orientation/depth into `matrix3d`, and transfers the `desert2` win while lowering PAC/draw-props. The baseline is 1px on desktop and 8px on mobile-class documents to avoid mobile GPU filtering gaps while preserving the same CSS-space quad. | Keep direct matrix as the baseline leaf shape while testing only changes that target GPU-hard residual cost. | Reopen only if a visual-equivalent shape beats it on high-leaf GPU-hard scenes without adding routing. |
-| A27 | ✅ Accepted | Exact direct matrix leaves are the single voxel leaf shape; order is the optimization layer. | Same exact `<b>` matrix leaves, same active nodes, and same culling produced opposite cadence depending only on DOM order. Tile4 scanline-forward became the baseline because it was the broadest validated one-strategy order; later GPU reread changes which old wins matter, not the baseline DOM shape. | Keep order experiments isolated from leaf shape changes and judge them on GPU-hard intervals. | Reopen only if a different leaf shape changes GPU-hard compositor pressure without visual drift. |
-| A28 | ❌ Rejected | A single static or face-normal order can replace model routing. | Tested fixed side-first, side-reverse, top-reverse, face-normal-front/back, face-depth, face-block, and depth-band variants on the hard split set. `obj_house3` rejects side-first/reverse and depth; `desert2` rejects top/normal-front; `house` rejects normal-front; `AncientCrashSite` rejects normal sorting and bands; `Treasure` still needs per-leaf depth for the high bucket. | Reopen only with a new order derived from Chromium sorting behavior, not another static face permutation. | Current static/normal permutations all have hard counterexamples. |
-| A29 | ❌ Rejected | Depth bands with face locality bridge face order and projected-depth order. | 4- and 8-band variants reduce mounted nodes but regress `obj_house3`, `army`, `AncientCrashSite`, and `skyscraper`; `Treasure` still stays below global depth. | Reopen only if a different banding rule is tied to measured compositor overlap/sorting, not node count. | Fewer active nodes performed worse, so this is not the missing invariant. |
-| A30 | ✅ Accepted | Order-sensitive wins are cadence/scheduler threshold effects, not lower per-frame main-thread compositor work. | One-run traces on `scene_mechanic2` and `obj_house3` with same leaves/nodes show PAC, DrawProps, Draw, paint, raster, and script per inferred frame are nearly identical between fast and slow orders. The difference is the share of 1x-vsync vs 2x/3x-vsync frames. | Next work should inspect overlap/sorting/damage/GPU critical path, not style/layout/PAC totals. | Reopen only if low-intrusion traces on more models show per-frame compositor groups diverging materially. |
-| A31 | ❌ Rejected | Projected overlap/order inversions predict when depth order is required. | Added `bench/voxel-order-metrics.mjs` and ran the hard split set with two repeats per strategy. Overlap count, crossing rate, and depth-inversion rate are useful diagnostics, but the naive inversion predictor fails: zero-inversion depth order can be slow, and parsed order can be fast with many inversions. | Reopen only with a more specific Chromium/BSP metric than AABB overlap and average-depth inversion. | Current metric does not correlate with validated or exploratory p95/p99 by order. |
-| A32 | ❌ Rejected | Source/spatial locality plus coarse depth ordering may beat pure face and pure depth order. | Tested source-order blocks of 32, 64, 128, and 256 leaves, sorted by average projected depth front/back, on the hard split set with two repeats. | Reopen only if the block definition is derived from a new browser/compositor metric rather than fixed source chunks. | Fixed source chunks are model-specific: they transfer some wins but fail `obj_house3`, miss `army`/`skyscraper`, and do not beat the A31 Pareto frontier. |
-| A33 | ✅ Accepted | Projected screen-space grouping is the current direct-matrix order baseline. | Tested 4x4 and 8x8 projected screen tiles with depth-front/back and scanline-forward/reverse ordering on the hard split set. A34 validated `tile4-scanline-forward`, A35 rejected `tile4-depth-front`, and A96-A111 rejected nearby tile-count replacements. | Keep `tile4-scanline-forward` until a deterministic order improves GPU-hard intervals without p99 regressions. | Reopen only with a browser/compositor metric that explains a better universal order. |
-| A34 | ❌ Rejected | Tile4 spatial locality is useful, but row-major traversal may not be the best one-strategy order. | Tested single-strategy tile4 serpentine and Morton/Z-order traversals as new strategy IDs only. | Reopen only with a new traversal justified by a browser/compositor model. | Serpentine and Morton both lose `obj_house3` and remain below tile4 row-major average. |
-| A35 | ⚠️ Conditional | Order phase within a visible-face interval is a real lever, but the phase rule is unsolved. | A70-A95: fixed lookahead offsets, centered intervals, fractions, huge/local anchors, boundary screen-span anchors, tile-count sweeps, adaptive 3x3/5x5 tile density, interval-profiler comparison, exact interval order replay, large-blocker guards, and large-top pinning. Short windows found major wins, but validation rejected the best one-strategy candidates. A87/A93 show the same signature can win or lose depending on interval geometry, and A94/A95 show coarse per-face/per-span guards are insufficient. | Promote only if a browser/overlap-derived phase rule keeps the wins and removes the AncientCrashSite/`obj_house3` long-window losses without preset gates. | Reject if every deterministic phase rule collapses to model routing or blunt geometry guards. |
-| A112-A114 | ❌ Rejected | Scene-root transform decomposition can recover a compositor fast path. | Tested root `matrix3d(...)`, inner target-translation shell, host-level perspective, transform-function perspective, and removing scene `will-change`. The decomposition variants were flat or worse; the only `no-will-change` 3s signal disappeared in 8s confirmation. | Reopen only with a Chromium-source-backed reason that changes which transform node is dirtied, not another equivalent CSS transform spelling. | Current variants keep the same dirty 3D subtree cost and do not improve validated p95/p99. |
-| A115-A128 | ✅ Accepted | Synthetic order wins are threshold/cadence effects, not a stable lower-cost order primitive. | Extended `bench/compositor-topology-probe.mjs` with fixed-leaf order mode, depth patterns, per-order metrics, frame buckets, and no-trace runs. 5000 high-overlap leaves can flip between ~60 and 110+ p95 by DOM order, but repeats show the test is near an unstable scheduler threshold. At 6000/7000/8000 leaves, all orders converge to ~60/~40/~30 p95. Flat-Z controls are fast. CSS root animation still skips PAC under trace but does not solve no-trace heavy-load cadence. | Use synthetic order probes to identify thresholds and trace causes, not to justify another model router or global order rule. | Reopen only if a synthetic variant changes heavy-load p95 while preserving identical leaf count and visual-equivalent 3D topology. |
-| A129-A137 | ✅ Accepted | Interactive root mutation is the dominant synthetic dirty-subtree trigger; nearby CSS APIs do not bypass it. | Added synthetic controls for leaf CSS flags, transform spelling, root scale, rotation delta, static root, CSS variables, registered variables, and individual `rotate`. Static 7000-leaf scenes remain near the 120fps bucket. JS transform, registered var, and `rotate` property updates all hit PAC/layerize; active CSS keyframes skip PAC but remain draw-bound at heavier loads. | Treat interactive rotation as dirtying the full 3D property tree unless Chromium exposes a true compositor-driven scrub path. Use root scale/screen footprint as a secondary pressure metric. | Reopen only if a new browser API updates the transform node without PAC during JS/pointer-driven scrubbing. |
-| A138-A146 | ✅ Accepted | The browser fast shape is fewer dirty 3D wrappers with many 2D children, not many 3D leaves. | Extended depth-group synthetic sweeps across wrapper counts, wrapper CSS flags, boxed wrappers, JS/CSS roots, and child-count scaling. Software-lane threshold was very low (8-12 clean, 50+ collapsed); A218 shows GPU keeps the same shape clean to roughly 112 wrappers. Valid containment does not help. Child count is secondary once wrappers are low. | Use this as the target browser shape only when exact visual depth can be represented within the GPU-lane wrapper threshold. | Reject grouped renderers that require per-leaf residual Z, clipping, quantized depth, or wrapper counts above the validated backend threshold. |
-| A147 | ✅ Accepted | Exact depth-wrapper fast paths are only viable below the GPU wrapper threshold, which still misses the hard high-plane class. | `bench/voxel-static-metrics.mjs` showed important models with 47-191 visible planes; A218 raises the clean GPU threshold to about 112, but `Treasure` 132, `obj_house3` 142, `scene_mechanic2` 163, `scene_house` 182, and AncientCrashSite/`scene_park` 191 still exceed it. | Use exact depth wrappers only as a special-case ceiling for GPU-hard, <=112-plane assets. | Reopen if a high-active-leaf real model appears below the GPU threshold and is not already capped on direct matrix. |
-| A148-A149 | ❌ Rejected | Coarse depth wrappers plus exact residual leaf `translateZ(...)` can preserve visual depth and keep the grouped fast path. | Added synthetic `hybrid-z8-d136`, `hybrid-z16-d136`, and `hybrid-z8-d250` variants. `group-z8` stays near 111 p95 with PAC/layerize about 1.1ms/f and draw about 0.13ms/f. `hybrid-z8-d136` falls to about 24 p95 with PAC/layerize about 3.7ms/f and draw about 6.7ms/f, matching per-leaf 3D cost. | Reopen only if exact residual depth can be expressed without putting a 3D transform on each leaf. | A residual leaf Z transform poisons the grouped shape; the browser treats it like many 3D leaves again. |
-| A150 | ❌ Rejected | Quantizing real-model depth into a low wrapper count is a plausible visual approximation. | Added `bench/voxel-depth-quantization-error.mjs` and wrote `bench/results/a150-depth-quantization-error.md`. With 2/4/8/12/16 bucket centers per axis, hard models still have huge projected center displacement. At 16 buckets/axis, already 48 wrappers, p95 center error remains 69.7px on `AncientCrashSite`, 64.3px on `desert2`, 85.2px on `Treasure`, 79.2px on `obj_house3`, 72.4px on `scene_mechanic2`, and 73.2px on `scene_house`. | Reopen only for a non-visual diagnostic mode or an explicitly lossy renderer. | Coarse wrapper counts are visibly wrong, and visually closer bucket counts still do not cover the high-plane GPU-hard class exactly. |
-| A151 | ❌ Rejected | Replace per-leaf 3D depth with per-leaf 2D projected offsets driven by scene-level CSS variables. | Added synthetic projection variants. At 7000 leaves, static 2D leaves stay cheap, but `var-transform` and registered `var-transform` fall to about 24 p95 with about 25ms/f of `UpdateLayoutTree` and about 4ms/f of PAC/layerize. `var-left-top` is worse at about 20 p95. | Reopen only if a compositor-driven projection API avoids style recalc for dependent leaf transforms. | Inherited camera variables make every dependent leaf style dirty; this moves the bottleneck rather than removing it. |
-| A152 | ❌ Rejected | Many smaller spatially bounded depth wrappers can avoid the high-wrapper collapse. | Added tiled depth-wrapper variants. With 7000 children, `group-z16` stays around 107-110 p95, while `tiled-z16-t2` creates 64 smaller wrappers and drops to about 59 p95. `group-z32` and `tiled-z32-t2` both remain slow, with tiled usually worse. Trace draw-property cost stays low, so the loss is cadence/threshold rather than a big per-frame main-thread event. | Reopen only with a tiling form that reduces transformed wrapper count, not one that multiplies it. | Bounds/overlap reduction does not compensate for multiplying dirty transformed wrappers. |
-| A153 | ⚠️ Conditional | Projected overlap/footprint can dominate per-leaf 3D cadence even when DOM count and transform topology are unchanged. | Added `--depth-step` and `--perspective` to the synthetic probe. Under near-orthographic perspective, `leaf-z250` at depth-step 6 is about 17 p95 with draw about 6.6ms/f; depth-step 72 spreads projected leaves and rises to about 111 p95 with draw about 4.1ms/f. This is not a renderer trick because the visual footprint changes, but it explains why equal DOM/topology cases can land in different cadence buckets. | Use this to design overlap/footprint diagnostics and real-model interval analysis. | Reject only if normalized-screen-footprint probes show the effect disappears. |
-| A154 | ✅ Accepted | The depth-step win is primarily a projected-footprint win, not magic from larger Z values. | Added compensated depth variants that offset local Y by the root tilt so large-Z leaves project back into a compact footprint. At depth-step 72, `leaf-z250` is near 110+ p95 with screen fill about 0.01; `leaf-z250-comp` drops to about 60 p95 with screen fill about 0.55 and overlap about 0.40 pairs/leaf. The fast case has the same per-leaf Z topology but much lower projected density. | Treat screen density and overlap as first-class diagnostics. | Reopen only if another large-Z same-footprint test stays in the 100+ bucket. |
-| A155 | ⚠️ Conditional | Real-model interval drops are overlap/order-shape effects, not a single scalar like active leaves or fill. | Added `bench/voxel-interval-screen-metrics.mjs` and ran current renderer intervals for `ancient-crash-site`, `obj-house3`, and `scene-mechanic2`. `AncientCrashSite` is uniformly bad with about 5.2k active leaves and 6-9 overlap pairs/leaf. `obj_house3` has high-fill/high-overlap intervals that are still 100+ p95 and one similar interval at about 60 p95, so scalar density alone is insufficient. | Next tests should attribute overlap by face pair, depth direction, and tile-local source order. | Reject if a broader interval corpus shows a simple threshold cleanly predicts drops. |
-| A156 | ❌ Rejected | 2D spatial wrappers around exact per-leaf 3D leaves can give Chromium smaller subtrees without changing visuals. | Added synthetic `tile2d-z250-t2/t4/t8` variants. At depth-step 6, 7000 leaves stayed in the same slow class: baseline `leaf-z250` was around 10-17 p95 and tile2d variants topped out around 17 p95. At depth-step 12 they were flat at about 30 p95. | Reopen only if a real-model implementation shows a win not visible in the high-overlap synthetic class. | Spatial 2D wrappers do not remove per-leaf 3D draw-property pressure or projected overlap cost. |
-| A157-A159 | ❌ Rejected | Standalone dense-tile face ordering predicts a product win. | Added `bench/voxel-dom-order-probe.mjs` to render real voxel DOM with exact direct-matrix leaves and swap only tile-local ordering. The first standalone hard-set sweep looked promising, but A160-A161 product validation killed it: the apparent `obj_house3` win disappeared, fast intervals regressed, and the renderer patch was reverted. Under the GPU-lane reread, these medium-scene p95 moves are also capped/stress-lane evidence unless they improve p99 or a high-plane GPU-hard model. | Reopen only with a browser-source-backed tile-local metric that survives product validation on GPU-hard intervals. | The dense-tile face rule was a harness/window artifact, not a renderer direction. |
-| A160-A161 | ❌ Rejected | Product renderer dense-tile face ordering is a real candidate. | A160 patched `packages/polycss/src/render/voxelRenderer.ts` so the existing tile4 scanline order remained, but dense tiles (`sum projected bbox area / tile bbox area >= 4`) sorted by `FACE_ORDER`. A one-run window looked promising (`obj_house3` p95 59.9 -> 98.3), but A161 two-repeat validation killed it: `obj_house3` landed at 59.9/59.9 p95, `scene_mechanic2` at 59.2/59.5, and `AncientCrashSite` at 28.8/29.4. The patch also dragged previously fast `obj_house3` intervals down to ~60. Product renderer was reverted. | Reopen only with an interval-stable rule that improves `obj_house3` without moving its fast intervals into the 60 bucket. | Dense tile face order was a sample-window artifact, not a robust renderer win. |
-| A162 | ✅ Accepted | The residual cost is compositor-side, not DOM mutation, style, layout, or raster. | Added `bench/trace-frame-buckets.mjs` runs for current direct-matrix `obj_house3`, `scene_mechanic2`, and `AncientCrashSite`. Leaf counts stayed constant inside fast/slow buckets; style, layout, prepaint, and raster stayed tiny. The specific `SoftwareRenderer::DoDrawQuad` spike was a software-backend artifact later corrected by A211-A217, but GPU-hard traces still point at 3D property/draw-pass pressure rather than style/layout/raster. | Focus next tests on GPU-hard compositor shape: dirty 3D descendants, projected density, order, wrapper count, and per-pass visible quad work. | Reopen only if a low-intrusion GPU trace shows style/layout/raster taking over after a renderer change. |
-| A163-A164 | ❌ Rejected | Direct inline `background` color is a cheaper DrawQuad state than `currentColor`. | Added `--paints` to `bench/voxel-dom-order-probe.mjs`. Standalone `inline-background-shorthand` looked promising on `obj_house3` (`current-color` ~30-34 p95, shorthand ~56 p95), but the real renderer rejected it. Temporary product patch `el.style.background = color` dropped `obj_house3` to 30.2/32.5 p95 and `scene_mechanic2` to 30.0/30.1 p95; `AncientCrashSite` stayed around 17-20 p95. Product renderer was reverted and bench bundles rebuilt. | Reopen only if a trace proves a different paint declaration changes DrawQuad type without hurting product cadence. | The standalone paint signal was harness-specific; product `currentColor` stays. |
-| A165 | ❌ Rejected | Direct-matrix leaves do not need `transform-style: preserve-3d` because they have no children. | Extended `bench/voxel-dom-order-probe.mjs` with `--leaf-transform-styles`. On the current hostless direct-matrix shape, `flat` was catastrophic: `obj_house3` fell from ~40 p95 in the standalone window to ~11-12, `scene_mechanic2` to ~8-10, and `AncientCrashSite` to ~4. Product renderer was not patched. | Reopen only if a different DOM shape removes leaf 3D transforms entirely. | `preserve-3d` remains necessary for the current direct-matrix leaves. |
-| A166-A167 | ❌ Rejected | `backface-visibility: hidden` can cheaply discard already camera-culled direct voxel leaves. | Extended `bench/voxel-dom-order-probe.mjs` with `--leaf-backfaces`. Standalone was split: hidden helped `AncientCrashSite` and `scene_mechanic2`, but hurt `obj_house3`. Product validation rejected it as a default: hidden put `obj_house3` at 39.8/40.0 p95, `scene_mechanic2` at 38.0/30.0, and `AncientCrashSite` at 20.2/20.0 with bad p99 tails. Product CSS was reverted. | Reopen only for a visually validated non-default diagnostic or if a new culling rule proves hidden is safe for all intervals. | `visible` remains the default voxel leaf backface state. |
-| A168 | ❌ Rejected | Move brush size from `matrix3d` scale columns into the CSS box and keep the transform as a unit-orientation matrix. | Extended `bench/voxel-dom-order-probe.mjs` with `--transform-shapes=matrix-scale,css-size-unit-matrix`. The real CSS rect + unit matrix shape was flat on `obj_house3` (~40 p95 both), noisy/flat on `AncientCrashSite`, and worse on `scene_mechanic2` (baseline repeat reached 38.5 p95; unit-matrix repeats stayed ~30). Product renderer was not patched. | Reopen only if a different browser trace shows scaled local rects specifically causing DrawQuad cost. | Moving scale out of the matrix does not unlock a cheaper compositor path. |
-| A169 | 🟡 Flat | Leaf containment changes paint/property-tree isolation enough to affect DrawQuad cadence. | Extended `bench/voxel-dom-order-probe.mjs` with `--leaf-contains=none,paint,strict`. On `obj_house3`, all modes stayed at ~40 p95. `AncientCrashSite` stayed around 17-18 p95. `scene_mechanic2` stayed around 39 p95 with noisy p50. Product renderer was not patched. | Reopen only if a renderer shape makes style/layout or invalidation visible in trace. | Current direct-matrix leaves are draw-bound, not containment-bound. |
-| A170-A173 | ⚠️ Conditional | Reducing GPU-visible quad work may matter only for high-leaf GPU-hard models. | Added `bench/trace-event-args.mjs` and `bench/voxel-occlusion-potential.mjs`. Trace args show `NumberOfQuads` is basically mounted leaf count; Chromium is not automatically dropping occluded voxel quads. A coarse occlusion estimator found large potential hidden-leaf ratios, but the naive grid-cull p95 wins were software-lane/capped-medium evidence and A174-A210 later rejected sampled culling as a product path. | Reopen only with an exact or conservative interval-stable proof that removes material leaves on `AncientCrashSite`, `skyscraper`, or long-window `army` while preserving order and screenshots. | Do not count capped-medium wins or sampled-mask wins as evidence for this lever. |
-| A174-A188 | ❌ Rejected | A simple sampled screen-coverage cull can be made visual-safe with only higher resolution or a minimum projected size. | Added `--visual-diff`, fixed the static screenshot harness, and tested grid resolutions plus `--occlusion-min-cells`. Higher resolution did not fix visual failures. `min-cells=64` passed the hard-set visual diff but culled too little and was flat/worse in perf. `min-cells=48` also passed the hard set, but was similarly flat and regressed `scene_mechanic2` cadence. | Reopen only as a debugging baseline for a better culling proof. | Sampled coverage alone has a bad visual/perf tradeoff. |
-| A189-A199 | ⚠️ Conditional | Interior-neighbor guarded occlusion keeps silhouettes while preserving useful culling. | Added `--occlusion-interior-radius`. Radius 1 and 2 passed the hard-set fixed-angle visual diff and removed substantial leaves there. On the broader set, radius 1/2 still failed `treasure` and one `army` angle. Adding a sampled z-buffer and depth margin did not fix `treasure`, so the failure is not just average-depth sorting. | Continue only if a global conservative rule passes the broad visual set, or if the next implementation uses exact geometry rather than sampled masks. | Reject the current radius-only rule as a default because `treasure` fails visual checks. |
-| A200-A206 | ⚠️ Conditional | Visual-safe conservative occlusion is possible, but the observed FPS win is entangled with DOM order. | `interior-radius=1` plus `min-cells=20` passed 56 fixed-angle screenshots across `obj_house3`, `scene_mechanic2`, `AncientCrashSite`, `treasure`, `army`, `skyscraper`, and `desert2`. Perf without preserving source order showed some wins (`obj_house3` ~60 -> ~109, `desert2` ~110 -> ~112, `treasure` p50 improved), but also a `scene_mechanic2` regression. After adding `--occlusion-preserve-order`, most wins vanished: `obj_house3` became flat, `scene_mechanic2` stayed flat, `AncientCrashSite` stayed flat, while `desert2` still improved. | Next isolate order and culling separately. A shippable version needs either exact culling that helps while preserving the current order, or a separately validated order rule that does not regress `scene_mechanic2`/`treasure`. | Do not port the current sampled cull to product; the best-looking win is partly a front-to-back order artifact. |
-| A207 | ❌ Rejected | A single alternate tile-local DOM order can make the visual-safe sampled cull shippable. | Held the broad visual-safe cull fixed (`interior-radius=1`, `min-cells=20`, preserved source order through cull) and compared `tile4-source`, depth-front/back, face, top-first, and top-last on the hard set. Winners conflict: `obj_house3` needs depth-front/face/top-first (~108-111 p95), `scene_mechanic2` needs source/top-last (~108-110 p95), and `AncientCrashSite` stays around 30 p95 with only p99 churn. | Stop trying to rescue sampled cull by picking another universal order. If cull returns, it needs exact/conservative geometry or an order rule derived from compositor behavior and validated visually. | Reopen only if a new cull changes the candidate set rather than reordering the same sampled survivors. |
-| A208-A210 | ❌ Rejected | Interval-stable sampled culling can be product-real and still profitable. | Added `--occlusion-interval-samples` so a cull keeps any leaf needed at sampled angles across the whole visible-face interval, matching the renderer's no-per-frame-remount constraint. It passed the seven-model visual set, but removed too little at p50: `obj_house3` 1057 -> 1050 leaves, `scene_mechanic2` 2216 -> 2212, Ancient effectively unchanged, `skyscraper` 5766 -> 5694. A cached/long-warmup control reduced the cull-computation p99 artifact, but did not change the core leaf-count problem. | Do not pursue sampled culling as a renderer path unless it becomes exact, interval-stable, and removes materially more leaves while preserving order. | Reopen only with a different proof that can cull across a full visible interval rather than at one angle. |
-| A211-A217 | ✅ Accepted | The benchmark compositor backend changes the apparent bottleneck. | Default bundled Playwright Chromium on `obj_house3` emitted `SoftwareRenderer::DoDrawQuad` and measured about 60 p95; system Chrome and bundled Chromium with `--use-angle=metal --enable-gpu-rasterization` emitted zero `SoftwareRenderer::DoDrawQuad`, dropped `DirectRenderer::DrawRenderPass` from ~6-16ms to ~1.3ms in the fast bucket, and measured ~112-114 p95. A seven-model GPU sweep put `obj_house3`, `scene_mechanic2`, `treasure`, and `desert2` near 112 p95, while 5k+ leaf models (`AncientCrashSite`, `skyscraper`) remained around 58-59 p95 and `army` stayed window-sensitive. The bench harness now makes this GPU lane the default and exposes `--software-backend` for the old stress lane. | Report browser executable/args/backend for future runs. Treat software-renderer-only wins/losses as bench-environment findings until confirmed on the GPU path. The remaining true renderer target is still reducing dirty 3D descendant/draw-property pressure for 5k+ leaves. | Reopen only if the default bench browser starts emitting `SoftwareRenderer::DoDrawQuad` again or GPU-path traces show the same medium-scene 60fps ceiling. |
-| A218 | ✅ Accepted | GPU backend raises the grouped-depth-wrapper threshold, but not enough for the hard high-plane models. | Re-ran synthetic depth groups with ANGLE/Metal. With 7000 leaves under JS root rotation, exact grouped Z wrappers stayed near 112 p95 through `group-z112`, fell to ~60 p95 at `group-z128`, collapsed at `group-z136`, and became unusable by `group-z192`; per-leaf 3D depth stayed slow. Current visible exact-plane counts for hard models are still above the clean GPU threshold: `AncientCrashSite` 191, `skyscraper` 173, `army` 187, `obj_house3` 142, `scene_mechanic2` 163, `treasure` 132; only `desert2` at 102 is under it and is already fast on GPU. | Keep grouped-depth wrappers as a GPU-lane special-case ceiling for <=112 visible planes, not as the universal voxel renderer. | Reopen if a real high-leaf model has <=112 exact visible planes and is not already capped on direct matrix. |
-
-## Closed Rejections
-
-| ID | Status | Rejected hypothesis | Reason |
-| --- | --- | --- | --- |
-| R1 | ❌ Rejected | Naive scene/mesh/host boxes without visual-preserving transform compensation. | Some scene-box variants hit a fast compositor path, but screenshots were blank, cropped, or off-center; not acceptable as a renderer change. |
-| R2 | ❌ Rejected | Matrix atom split for voxel scenes. | Did not beat the dedicated voxel slice renderer. |
-| R3 | ❌ Rejected | Inner depth hosts or sibling `(axis, depth)` wrappers as a default renderer. | Extra transformed 3D hierarchy was much slower on real high-plane models. Synthetic probes reopen only a narrow GPU-lane exact-plane special case, not a default renderer. |
-| R4 | ❌ Rejected | Nested cartesian coordinate wrappers. | Incompatible with merged rectangles and expected wrapper explosion. |
-| R5 | ❌ Rejected | `matrix3d` inside brush leaves while keeping the three voxel hosts. | Host+brush matrix did not beat `left/top/width/height + translateZ`; the promising version removes the axis hosts entirely and uses a non-degenerate normal column. |
-| R6 | ❌ Rejected | Mount all six face directions. | Extra active DOM dominated any mutation savings. |
-| R7 | ❌ Rejected | Hide pooled leaves instead of removing unused leaves. | Neutral to worse. |
-| R8 | ❌ Rejected | Sort brushes by axis/depth/area/color as a default. | Regressed in spot checks. |
-| R9 | ❌ Rejected | Split large brushes into smaller rectangles. | More leaves and worse p95. |
-| R10 | ❌ Rejected | Source overpaint or no-overlap source planner as default. | Fewer leaves did not reliably win and overpaint risks visuals. |
-| R11 | ❌ Rejected | Brush `transform-style: flat`. | Catastrophic regression. |
-| R12 | ❌ Rejected | Brush `overflow: hidden`. | Catastrophic regression. |
-| R13 | ❌ Rejected | Brush `backface-visibility: hidden`. | Neutral to worse and visually risky. |
-| R14 | ❌ Rejected | Host `will-change: transform`. | Neutral to worse. |
-| R15 | ❌ Rejected | Remove scene-root `will-change`. | Neutral to worse. |
-| R16 | ❌ Rejected | Inline `background-color` instead of `currentColor`. | Neutral to slightly worse. |
-| R17 | ❌ Rejected | `translate3d(0,0,z)` or individual `translate` instead of `translateZ`. | Neutral to worse overall. |
-| R18 | 🟡 Flat | Leaf containment. | No meaningful win. |
-| R19 | ❌ Rejected | Opacity culling for hidden faces. | Keeps paint/composite work alive; contradicts all-faces result. |
-| R20 | ❌ Rejected | CSS paint worklet face generation. | Violates no-JS/render-loop direction and is unlikely to be reliable. |
-| R21 | ❌ Rejected | JS-scrubbed compositor animation as an interactive camera fix. | Paused WAAPI `currentTime` and JS-driven scroll-timeline `scrollLeft` probes both hit PAC once per frame, matching the normal JS transform mutation path. |
-| R22 | ❌ Rejected | Per-leaf square primitive normalization as the default voxel direct-matrix shape. | Clean-rebuild A63-A66 runs show exact square, capped square, axis/face splits, and size bands are flat or short-window cadence artifacts; the 8s confirmation kept `scene_mechanic2` at baseline. |
-| R23 | ❌ Rejected | Constant order lookahead or centered-interval order as the default. | A70-A76 found real wins, but every tested phase rule kept hard counterexamples: fixed `+30deg` regressed `obj_house3`, centered/fractional interval order left `obj_house3` p99 tails, and per-item huge-rectangle fallback did not fix it. |
-| R24 | ❌ Rejected | Boundary screen-span anchors or adaptive 3x3/5x5 tile density as the default order rule. | A80-A86 found strong 3s wins, including `scene_mechanic2` near the cap and Garden/Treasure improvements. The 8s validation rejected the rule: AncientCrashSite fell ~38 -> ~30 p95 and `obj_house3` fell ~98 -> ~60 p95. |
-| R25 | ❌ Rejected | Protecting top faces or reversing scanline traversal fixes the interval-order losses. | A88-A91 showed why the adaptive phase rule failed, then tested two derived fixes. Top-face anchoring killed Garden/Scene/Treasure wins; reverse scanline traversal was broadly worse and collapsed `obj_house3`. |
-| R26 | ❌ Rejected | Large-blocker guards or large-top pinning make centered interval order safe. | A94 pinned large top occluders while filling product tile4 slots from centered order; A95 used centered order only when a projected leaf spanned more than one coarse tile. A94 regressed `obj_house3` ~60 -> ~40 p95 and A95 kept the same `obj_house3` loss while providing no broad win. |
-| R27 | ❌ Rejected | Plain tile3 or tile6 current-screen order replaces tile4. | A97 tile3-current improves AncientCrashSite in a short window but regresses `obj_house3` ~60 -> ~40 p95. A101 tile6-current is flat/worse than tile5 in the matched 8s hard set. |
-| R28 | ❌ Rejected | Tile5 serpentine or reverse scanline traversal improves on tile5 forward. | A104 tile5-serpentine collapses `obj_house3` and Skyscraper and loses the Garden win. A105 tile5-reverse gives Desert2 a large short-window win but also collapses `obj_house3`; traversal direction is not the clean win. |
-| R29 | ❌ Rejected | Tile5 scanline-forward is a safer default than tile4. | A99/A102 looked clean on the hard set, but A108-A111 broad corpus validation found no broad win, a confirmed `scene_house3` p95 loss, and p99 tail regressions on `mailbox`, `scene_house`, and `scene_army`. |
-| R30 | ❌ Rejected | Re-spelling or splitting the scene transform chain fixes direct-matrix rotation cadence. | A112-A114 show root `matrix3d(...)`, inner target shell, host perspective, transform-function perspective, and scene `will-change: auto` are flat or worse after longer validation. |
-| R31 | ❌ Rejected | Depth-sort only projected high-overlap real-model tiles. | A119 translated the synthetic overlap/depth result into the real voxel renderer as a bench-only mode. It avoided `obj_house3` collapse but produced no useful win and regressed `scene_house3` by ~10 p95; `Garden`, `Treasure`, and `army` picked up p99 tail losses. |
-| R32 | ❌ Rejected | CSS custom properties, registered properties, or individual `rotate` avoid interactive root-transform PAC. | A135-A137 show all three still hit PAC/layerize like normal JS transform mutation. Unregistered transform vars also add large style cost in trace. |
-| R33 | ❌ Rejected | Paint containment on 0x0 depth wrappers is a valid speedup. | A142 looked fast with `contain: paint`/`strict`, but hit-testing showed children were clipped out. A143 boxed the wrappers so containment was visually valid and the win disappeared. |
-| R34 | ❌ Rejected | Exact residual per-leaf `translateZ(...)` under coarse wrappers. | A148-A149 show this collapses back to per-leaf 3D transform cost. Coarse grouping only wins when children stay 2D. |
-| R35 | ❌ Rejected | Depth quantization to force hard real models under the clean wrapper threshold. | A150 shows the visual error is far too large. Even 48 wrappers per view is still visibly displaced, and approximation is not acceptable for the default renderer. |
-| R36 | ❌ Rejected | CSS-variable 2D projection as the interactive renderer shape. | A151 shows dependent leaf transforms cause whole-subtree style recalc, around 25ms/f at 7000 leaves. |
-| R37 | ❌ Rejected | Spatially tiled depth wrappers as a way around the wrapper-count ceiling. | A152 shows more bounded wrappers are slower than fewer broad wrappers at the same child count. |
-| R38 | ❌ Rejected | Exact per-leaf 3D leaves inside 2D spatial wrappers. | A156 shows 2D tile wrappers are flat or only marginal in synthetic high-overlap cases; they do not change the core browser cost shape. |
-| R39 | ❌ Rejected | Full face order or full depth order as the replacement for tile4 source order. | A157-A161 show full face order rescues `obj_house3` but collapses `scene_mechanic2`; full depth variants are also model/interval-specific, and dense-tile face order did not survive product validation. |
-| R40 | ❌ Rejected | Dense-tile face order as the product default. | A160-A161 show the apparent win disappears under two-repeat interval validation and can regress fast intervals. |
-| R41 | ❌ Rejected | Inline `background`/`background-color` instead of `currentColor` for direct voxel leaves. | A163-A164 show a standalone paint-state win did not transfer to the product renderer and caused major p95 regressions on `obj_house3` and `scene_mechanic2`. |
-| R42 | ❌ Rejected | Leaf `transform-style: flat` on hostless direct-matrix voxel leaves. | A165 shows this is catastrophically slower even though leaves have no children. |
-| R43 | ❌ Rejected | `backface-visibility: hidden` for direct voxel leaves. | A166-A167 show a split standalone result and product regressions on `obj_house3` and `scene_mechanic2`; it is not a single default strategy. |
-| R44 | ❌ Rejected | CSS width/height plus unit-orientation matrix instead of scaled 1px matrix leaves. | A168 shows the visual-equivalent transform shape is flat or worse in the standalone real-model harness. |
-| R45 | 🟡 Flat | Leaf `contain: paint` or `contain: strict` on direct voxel leaves. | A169 shows containment does not move the hard set meaningfully. |
-| R46 | ❌ Rejected | Naive sampled screen-coverage occlusion as a default. | A174-A188 show the raw grid cull either fails screenshots or becomes too conservative to help. |
-| R47 | ❌ Rejected | Interior-neighbor sampled occlusion alone explains the win. | A200-A206 show the visual-safe cull mostly goes flat when source order is preserved; the large wins are mixed with front-to-back DOM order. |
-| R48 | ❌ Rejected | Pairing visual-safe sampled occlusion with one alternate tile-local order. | A207 shows the same cull needs opposite order phases for `obj_house3` and `scene_mechanic2`; no single tested order is safe across the hard set. |
-| R49 | ❌ Rejected | Product-real interval-stable sampled occlusion. | A208-A210 pass screenshots but remove almost no p50 DOM once the mounted set must be valid across the whole face interval; caching boundary computation does not change that. |
-
-## Next Concrete Order
-
-1. Do not rerun the whole A31/A32 table for every small idea. Run only new
-   strategy IDs; rerun the full hard split set only when the DOM shape,
-   culling, or measurement harness changes.
-2. Keep the committed hostless direct-matrix renderer as the baseline shape:
-   1px desktop / 8px mobile canonical leaves, exact `±1` normal column, and
-   tile4 scanline order.
-3. Treat 100+ FPS as a capped tie. Promote a variant only when it moves an
-   uncapped model in longer samples without introducing a p99 tail loss.
-4. For order-phase work, segment frames by visible-face interval before
-   testing another global rule. The same strategy can win one interval and
-   lose another, which short aggregate windows hide.
-5. Do not add another coarse per-face/per-span guard without a new trace-backed
-   reason. A93-A95 already reject signature-only routing, top-face protection,
-   large-blocker presence, and large-top pinning as sufficient predictors.
-6. Treat scene-shell transform changes as closed unless the new variant changes
-   dirty transform-node topology rather than CSS spelling.
-7. Use the synthetic harness for threshold finding with frame buckets, but do
-   not promote a synthetic order result unless it survives heavier-load
-   validation, not just a near-threshold 5000-leaf flip.
-8. For interactive rotation, stop testing transform spelling/API aliases unless
-   they can be proven to update the compositor transform node without PAC.
-9. Prioritize renderer ideas that reduce exact transformed 3D descendants on
-   the GPU-hard class. The old low-teens wrapper ceiling was software-lane; on
-   GPU, exact wrappers stay clean to about 112, but hard models still exceed
-   that range. Do not pursue residual per-leaf Z or depth quantization.
-10. Keep declarative auto-rotate work separate from pointer-driven rotation; it
-   may still be useful for demos, but it is not the interactive renderer fix.
-11. Treat projected overlap/footprint as a GPU-hard explanatory variable, not
-    a reason to chase capped medium scenes. The next useful tests should
-    measure or normalize projected overlap on `AncientCrashSite`, `skyscraper`,
-    and long-window `army`, not add more transform spellings.
-12. For real models, inspect interval-level overlap attribution before another
-    ordering change, but focus it on uncapped GPU-hard intervals. Earlier
-    `obj_house3`/`scene_mechanic2` order results are now mostly capped/tie
-    evidence unless they reveal p99 regressions.
-13. Do not promote a candidate from one partial rotation window. A160 looked
-    like a breakthrough and A161 showed it was phase/window-sensitive. Future
-    order candidates need at least two repeats across a full interval mix.
-14. Treat software `DoDrawQuad` cost as a stress-lane bottleneck, not the
-    default optimization target. On GPU, the hard cases still show dirty 3D
-    descendant, draw-property, and draw-pass pressure; new ideas should explain
-    how they reduce that pressure without depending on software renderer
-    behavior.
-15. Keep occlusion on the table only as an exact/geometric proof. A207 rejects
-    rescuing the sampled mask with one alternate tile-local order, and
-    A208-A210 show interval-stable sampled culling removes too little to pay
-    for itself under the renderer's no-per-frame-remount constraint.
-16. Future perf runs default to the GPU lane. Use `--software-backend` only
-    when intentionally stress-testing the old SoftwareRenderer path.
-17. Do not reopen exact depth wrappers as the default just because the GPU
-    threshold is higher. The unresolved models still exceed the clean wrapper
-    range; use wrappers only as a validated GPU-lane special case.
-18. Rerun old candidates only when they target the GPU-hard class. Software-
-    only wins on `obj_house3`, `scene_mechanic2`, `treasure`, or `desert2`
-    should not drive new renderer work unless they also improve GPU p99 or a
-    high-plane model.
diff --git a/bench/animated-human.html b/bench/animated-human.html
index aaf39011..c99c8289 100644
--- a/bench/animated-human.html
+++ b/bench/animated-human.html
@@ -17,7 +17,7 @@
       createPolyScene,
       optimizeAnimatedMeshPolygons,
       parseGltf,
-    } from "./polycss.js";
+    } from "./.generated/polycss.js";
     import {
       collectRenderStats,
       createPerfRecorder,
diff --git a/bench/build.mjs b/bench/build.mjs
index 0ada604c..587df57a 100644
--- a/bench/build.mjs
+++ b/bench/build.mjs
@@ -2,15 +2,19 @@
  * Bundle bench renderer paths and helper entries into self-contained browser ESM
  * files that the perf-*.html pages can `import` directly:
  *
- *   bench/polycss.js          ← imperative API (createPolyScene + controls
- *                                + loadMesh) used by perf-vanilla.html
- *   bench/polycss-elements.js ← side-effect bundle that registers the
+ *   bench/.generated/polycss.js
+ *                              ← imperative API (createPolyScene + controls
+ *                                + loadMesh) used by vanilla bench pages
+ *   bench/.generated/polycss-elements.js
+ *                              ← side-effect bundle that registers the
  *                                custom elements; used by perf-html.html
- *   bench/polycss-render-stats.js
+ *   bench/.generated/polycss-render-stats.js
  *                              ← shared render stats helper used by perf-shared.mjs
- *   bench/polycss-react.js    ← React entry (bench/entries/react.tsx)
+ *   bench/.generated/polycss-react.js
+ *                              ← React entry (bench/entries/react.tsx)
  *                                bundled with React + ReactDOM + @layoutit/polycss-react
- *   bench/polycss-vue.js      ← Vue entry (bench/entries/vue.ts) bundled
+ *   bench/.generated/polycss-vue.js
+ *                              ← Vue entry (bench/entries/vue.ts) bundled
  *                                with Vue 3 + @layoutit/polycss-vue
  *
  * Why not reuse the published dists? The packages keep workspace-peer
@@ -22,11 +26,13 @@
  * Run: `node bench/build.mjs`  (or `pnpm bench:build`).
  */
 import { build } from "esbuild";
+import { mkdir } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
+const bundleDir = resolve(__dirname, ".generated");
 
 const ALIASES = {
   "@layoutit/polycss-core":     resolve(repoRoot, "packages/core/src/index.ts"),
@@ -64,36 +70,32 @@ const targets = [
   {
     label: "vanilla (createPolyScene + controls + loadMesh)",
     entry: resolve(repoRoot, "packages/polycss/src/index.ts"),
-    out: resolve(__dirname, "polycss.js"),
+    out: resolve(bundleDir, "polycss.js"),
   },
   {
     label: "elements (side-effect register)",
     entry: resolve(repoRoot, "packages/polycss/src/elements/index.ts"),
-    out: resolve(__dirname, "polycss-elements.js"),
+    out: resolve(bundleDir, "polycss-elements.js"),
   },
   {
     label: "render stats helper",
     entry: resolve(__dirname, "entries/renderStats.ts"),
-    out: resolve(__dirname, "polycss-render-stats.js"),
+    out: resolve(bundleDir, "polycss-render-stats.js"),
   },
   {
     label: "react entry",
     entry: resolve(__dirname, "entries/react.tsx"),
-    out: resolve(__dirname, "polycss-react.js"),
+    out: resolve(bundleDir, "polycss-react.js"),
   },
   {
     label: "vue entry",
     entry: resolve(__dirname, "entries/vue.ts"),
-    out: resolve(__dirname, "polycss-vue.js"),
-  },
-  {
-    label: "normalize (preprocessModelPolygons + paint helper)",
-    entry: resolve(__dirname, "entries/normalize.ts"),
-    out: resolve(__dirname, "polycss-normalize.js"),
+    out: resolve(bundleDir, "polycss-vue.js"),
   },
 ];
 
 const t0 = performance.now();
+await mkdir(bundleDir, { recursive: true });
 for (const t of targets) {
   process.stdout.write(`[bench/build] bundling ${t.label} … `);
   const start = performance.now();
diff --git a/bench/compositor-topology-probe.mjs b/bench/compositor-topology-probe.mjs
deleted file mode 100644
index d5a22712..00000000
--- a/bench/compositor-topology-probe.mjs
+++ /dev/null
@@ -1,899 +0,0 @@
-#!/usr/bin/env node
-/**
- * Synthetic Chromium compositor probe for polycss trace hypotheses.
- *
- * This intentionally does not render a correct model. It isolates browser
- * behavior under a rotating preserve-3d root:
- *   - topology: equal leaf count, different leaf transform topology
- *   - distribution: equal matrix3d leaves, different projected distribution
- *   - order: equal matrix3d leaves, same positions, different DOM order
- *   - depth-groups: per-leaf translateZ versus depth-plane wrappers
- *   - projection: per-leaf depth folded into 2D projected offsets
- *
- * Usage:
- *   node bench/compositor-topology-probe.mjs
- *   node bench/compositor-topology-probe.mjs --mode=topology --leaves=5000
- *   node bench/compositor-topology-probe.mjs --mode=distribution --headed
- *   node bench/compositor-topology-probe.mjs --mode=order --leaves=2500 --spacing=3
- *   node bench/compositor-topology-probe.mjs --mode=depth-groups --leaves=5000
- *   node bench/compositor-topology-probe.mjs --mode=projection --leaves=7000
- *   node bench/compositor-topology-probe.mjs --mode=depth-groups --root=js
- */
-import { chromium } from "playwright";
-import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
-
-const args = new Map(
-  process.argv.slice(2).map((arg) => {
-    const [key, ...rest] = arg.replace(/^--/, "").split("=");
-    return [key, rest.length ? rest.join("=") : "true"];
-  }),
-);
-
-const MODE = args.get("mode") ?? "all";
-const LEAVES = Number(args.get("leaves") ?? 2500);
-const SAMPLE_MS = Number(args.get("sample-ms") ?? 2500);
-const WARMUP_MS = Number(args.get("warmup-ms") ?? 700);
-const HEADED = args.has("headed");
-const JSON_OUT = args.has("json");
-const EXECUTABLE = args.get("browser");
-const SOFTWARE_BACKEND = args.has("software-backend");
-const EXTRA_CHROMIUM_ARGS = (args.get("chromium-args") ?? "")
-  .split(/\s+/)
-  .map((value) => value.trim())
-  .filter(Boolean);
-const ROOT = args.get("root");
-const TRACE = !args.has("no-trace");
-const SPACING = Number(args.get("spacing") ?? 3);
-const LEAF_SIZE = Number(args.get("size") ?? 6);
-const DEPTHS = Math.max(1, Number(args.get("depths") ?? 17));
-const DEPTH_STEP = Number(args.get("depth-step") ?? 6);
-const DEPTH_PATTERN = args.get("depth-pattern") ?? "mixed";
-const LEAF_TRANSFORM_STYLE = args.get("leaf-transform-style") ?? "preserve-3d";
-const LEAF_BACKFACE = args.get("leaf-backface") ?? "visible";
-const LEAF_WILL_CHANGE = args.get("leaf-will-change") ?? "";
-const LEAF_CONTAIN = args.get("leaf-contain") ?? "";
-const SCENE_WILL_CHANGE = args.get("scene-will-change") ?? "transform";
-const ORDER_TRANSFORM = args.get("order-transform") ?? "matrix3d";
-const DEPTH_TRANSFORM_STYLE = args.get("depth-transform-style") ?? "preserve-3d";
-const DEPTH_WILL_CHANGE = args.get("depth-will-change") ?? "";
-const DEPTH_CONTAIN = args.get("depth-contain") ?? "";
-const DEPTH_BOX = args.has("depth-box");
-const ROOT_SCALE = Number(args.get("root-scale") ?? 0.7);
-const ROOT_ROT_X = Number(args.get("root-rot-x") ?? 65);
-const ROOT_ROT_STEP = Number(args.get("root-rot-step") ?? 0.5);
-const PERSPECTIVE = Number(args.get("perspective") ?? 8000);
-const VARIANT_FILTER = new Set(
-  (args.get("variants") ?? "")
-    .split(",")
-    .map((value) => value.trim())
-    .filter(Boolean),
-);
-
-const CHROMIUM_ARGS = [
-  "--disable-background-timer-throttling",
-  "--disable-renderer-backgrounding",
-  "--disable-backgrounding-occluded-windows",
-  ...chromiumArgsWithGpuDefault(EXTRA_CHROMIUM_ARGS, { softwareBackend: SOFTWARE_BACKEND }),
-];
-
-const TRACE_CATEGORIES = [
-  "devtools.timeline",
-  "disabled-by-default-devtools.timeline",
-  "blink",
-  "cc",
-  "gpu",
-  "renderer.scheduler",
-].join(",");
-
-function percentile(sorted, p) {
-  return sorted[
-    Math.min(sorted.length - 1, Math.max(0, Math.floor((sorted.length - 1) * p)))
-  ] ?? 0;
-}
-
-function summarizeFrameTimes(dts) {
-  const sorted = dts
-    .filter((value) => Number.isFinite(value) && value > 0 && value < 2000)
-    .sort((a, b) => a - b);
-  const p50 = percentile(sorted, 0.5);
-  const p95 = percentile(sorted, 0.95);
-  const p99 = percentile(sorted, 0.99);
-  return {
-    samples: sorted.length,
-    fps_p50: +(1000 / p50).toFixed(1),
-    fps_p95: +(1000 / p95).toFixed(1),
-    p99_ms: +p99.toFixed(1),
-    buckets: {
-      x1: sorted.filter((value) => value < 10).length,
-      x2: sorted.filter((value) => value >= 10 && value < 18).length,
-      x3: sorted.filter((value) => value >= 18 && value < 26).length,
-      x4: sorted.filter((value) => value >= 26 && value < 34).length,
-      slow: sorted.filter((value) => value >= 34).length,
-    },
-  };
-}
-
-function summarizeTraceEvents(events) {
-  const byName = new Map();
-  for (const event of events) {
-    if (event?.ph !== "X" || typeof event.dur !== "number") continue;
-    const entry = byName.get(event.name) ?? { count: 0, us: 0 };
-    entry.count += 1;
-    entry.us += event.dur;
-    byName.set(event.name, entry);
-  }
-
-  const get = (name) => byName.get(name) ?? { count: 0, us: 0 };
-  const frames = Math.max(1, get("FireAnimationFrame").count || 1);
-  const pick = (name) => {
-    const event = get(name);
-    return {
-      count: event.count,
-      total_ms: +(event.us / 1000).toFixed(1),
-      per_frame_ms: +(event.us / 1000 / frames).toFixed(3),
-    };
-  };
-
-  return {
-    pac: pick("PaintArtifactCompositor::Update"),
-    layerize: pick("Layerize"),
-    drawProps: pick("LayerTreeImpl::UpdateDrawProperties"),
-    visible: pick("draw_property_utils::ComputeDrawPropertiesOfVisibleLayers"),
-    draw: pick("MainFrame.Draw"),
-    paint: pick("Paint"),
-    style: pick("UpdateLayoutTree"),
-    raf: pick("FireAnimationFrame"),
-  };
-}
-
-async function startTrace(cdp) {
-  const events = [];
-  cdp.on("Tracing.dataCollected", (payload) => {
-    if (Array.isArray(payload.value)) events.push(...payload.value);
-  });
-  await cdp.send("Tracing.start", {
-    transferMode: "ReportEvents",
-    categories: TRACE_CATEGORIES,
-  });
-  return events;
-}
-
-async function stopTrace(cdp, events) {
-  await new Promise(async (resolve) => {
-    cdp.once("Tracing.tracingComplete", resolve);
-    await cdp.send("Tracing.end");
-  });
-  return summarizeTraceEvents(events);
-}
-
-function topologyStyle(variant, i, leaves) {
-  const cols = Math.max(1, Math.ceil(Math.sqrt(leaves)));
-  const x = (i % cols) * 8 - 200;
-  const y = Math.floor(i / cols) * 8 - 200;
-  const z = ((i % 17) - 8) * 6;
-  switch (variant) {
-    case "left-top":
-      return `left:${x}px;top:${y}px;width:6px;height:6px;`;
-    case "translate2d":
-      return `width:6px;height:6px;transform:translate(${x}px,${y}px);`;
-    case "translateZ0":
-      return `left:${x}px;top:${y}px;width:6px;height:6px;transform:translateZ(0);`;
-    case "translateZ":
-      return `left:${x}px;top:${y}px;width:6px;height:6px;transform:translateZ(${z}px);`;
-    case "matrix3d":
-      return `width:1px;height:1px;transform:matrix3d(6,0,0,0,0,6,0,0,0,0,1,0,${x},${y},${z},1);`;
-    default:
-      throw new Error(`Unknown topology variant "${variant}"`);
-  }
-}
-
-function distributionStyle(variant, i) {
-  const cols = 40;
-  let x;
-  let y;
-  if (variant === "cluster") {
-    x = (i % cols) * 8 - 160;
-    y = Math.floor(i / cols) * 8 - 120;
-  } else if (variant === "spread") {
-    x = (i % cols) * 24 - 480;
-    y = Math.floor(i / cols) * 24 - 360;
-  } else if (variant === "overlap") {
-    x = (i % cols) * 2 - 40;
-    y = Math.floor(i / cols) * 2 - 30;
-  } else {
-    throw new Error(`Unknown distribution variant "${variant}"`);
-  }
-  const z = ((i % 17) - 8) * 6;
-  return `width:1px;height:1px;transform:matrix3d(6,0,0,0,0,6,0,0,0,0,1,0,${x},${y},${z},1);`;
-}
-
-function hashIndex(i) {
-  let value = Math.imul(i + 0x9e3779b9, 0x85ebca6b);
-  value ^= value >>> 16;
-  value = Math.imul(value, 0xc2b2ae35);
-  value ^= value >>> 16;
-  return value >>> 0;
-}
-
-function makeOrderItems(leaves) {
-  const cols = Math.max(1, Math.ceil(Math.sqrt(leaves)));
-  const rows = Math.ceil(leaves / cols);
-  const items = [];
-  for (let i = 0; i < leaves; i++) {
-    const col = i % cols;
-    const row = Math.floor(i / cols);
-    const centeredCol = col - (cols - 1) / 2;
-    const centeredRow = row - (rows - 1) / 2;
-    const depthIndex = orderDepthIndex({ i, col, row, cols, rows });
-    const z = (depthIndex - (DEPTHS - 1) / 2) * 6;
-    items.push({
-      i,
-      col,
-      row,
-      x: centeredCol * SPACING,
-      y: centeredRow * SPACING,
-      z,
-      depthIndex,
-      hash: hashIndex(i),
-    });
-  }
-  return items;
-}
-
-function orderDepthIndex({ i, col, row, cols, rows }) {
-  if (DEPTHS <= 1) return 0;
-  switch (DEPTH_PATTERN) {
-    case "flat":
-      return 0;
-    case "column":
-      return Math.floor((col / Math.max(1, cols - 1)) * (DEPTHS - 1));
-    case "row":
-      return Math.floor((row / Math.max(1, rows - 1)) * (DEPTHS - 1));
-    case "checker":
-      return (col + row) % DEPTHS;
-    case "random":
-      return hashIndex(i) % DEPTHS;
-    case "mixed":
-      return (col * 7 + row * 11) % DEPTHS;
-    default:
-      throw new Error(`Unknown depth pattern "${DEPTH_PATTERN}"`);
-  }
-}
-
-function sortOrderItems(items, variant) {
-  const sorted = [...items];
-  const tileCols = 4;
-  const maxCol = Math.max(1, ...items.map((item) => item.col));
-  const maxRow = Math.max(1, ...items.map((item) => item.row));
-  const tileIndex = (item) => {
-    const tx = Math.min(tileCols - 1, Math.floor((item.col / (maxCol + 1)) * tileCols));
-    const ty = Math.min(tileCols - 1, Math.floor((item.row / (maxRow + 1)) * tileCols));
-    return ty * tileCols + tx;
-  };
-  switch (variant) {
-    case "spatial":
-      return sorted.sort((a, b) => a.i - b.i);
-    case "depth-front":
-      return sorted.sort((a, b) => b.z - a.z || a.i - b.i);
-    case "depth-back":
-      return sorted.sort((a, b) => a.z - b.z || a.i - b.i);
-    case "random":
-      return sorted.sort((a, b) => a.hash - b.hash);
-    case "tile4-spatial":
-      return sorted.sort((a, b) => tileIndex(a) - tileIndex(b) || a.row - b.row || a.col - b.col);
-    case "tile4-depth":
-      return sorted.sort((a, b) => tileIndex(a) - tileIndex(b) || b.z - a.z || a.i - b.i);
-    case "tile4-depth-back":
-      return sorted.sort((a, b) => tileIndex(a) - tileIndex(b) || a.z - b.z || a.i - b.i);
-    case "block64-depth":
-      return sorted.sort((a, b) => {
-        const blockA = Math.floor(a.i / 64);
-        const blockB = Math.floor(b.i / 64);
-        return blockA - blockB || b.z - a.z || a.i - b.i;
-      });
-    default:
-      throw new Error(`Unknown order variant "${variant}"`);
-  }
-}
-
-function orderStyle(item) {
-  switch (ORDER_TRANSFORM) {
-    case "matrix3d":
-      return `width:1px;height:1px;transform:matrix3d(${LEAF_SIZE},0,0,0,0,${LEAF_SIZE},0,0,0,0,1,0,${item.x},${item.y},${item.z},1);`;
-    case "translate3d-scale":
-      return `width:1px;height:1px;transform:translate3d(${item.x}px,${item.y}px,${item.z}px) scale(${LEAF_SIZE});`;
-    case "translate3d-scale3d":
-      return `width:1px;height:1px;transform:translate3d(${item.x}px,${item.y}px,${item.z}px) scale3d(${LEAF_SIZE},${LEAF_SIZE},1);`;
-    case "translate3d-size":
-      return `width:${LEAF_SIZE}px;height:${LEAF_SIZE}px;transform:translate3d(${item.x}px,${item.y}px,${item.z}px);`;
-    case "left-top-translateZ":
-      return `left:${item.x}px;top:${item.y}px;width:${LEAF_SIZE}px;height:${LEAF_SIZE}px;transform:translateZ(${item.z}px);`;
-    default:
-      throw new Error(`Unknown order transform "${ORDER_TRANSFORM}"`);
-  }
-}
-
-function orderMetrics(items) {
-  const bounds = items.reduce((acc, item) => ({
-    minX: Math.min(acc.minX, item.x),
-    minY: Math.min(acc.minY, item.y),
-    maxX: Math.max(acc.maxX, item.x + LEAF_SIZE),
-    maxY: Math.max(acc.maxY, item.y + LEAF_SIZE),
-  }), { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity });
-  const boundsArea = (bounds.maxX - bounds.minX) * (bounds.maxY - bounds.minY);
-  const localArea = items.length * LEAF_SIZE * LEAF_SIZE;
-  const estimatedPairOverlap = SPACING >= LEAF_SIZE
-    ? 0
-    : Math.max(0, LEAF_SIZE - SPACING) * LEAF_SIZE * 2 * items.length;
-  return {
-    spacing: SPACING,
-    leafSize: LEAF_SIZE,
-    depths: DEPTHS,
-    depthPattern: DEPTH_PATTERN,
-    orderTransform: ORDER_TRANSFORM,
-    localArea,
-    boundsArea: +boundsArea.toFixed(1),
-    fillRatio: boundsArea ? +(localArea / boundsArea).toFixed(3) : 0,
-    estimatedPairOverlap: +estimatedPairOverlap.toFixed(1),
-  };
-}
-
-function orderedMetrics(ordered) {
-  let sourceJump = 0;
-  let depthJump = 0;
-  let directionChanges = 0;
-  let depthRunCount = ordered.length ? 1 : 0;
-  let lastDepthDirection = 0;
-  const depthCounts = new Map();
-  for (const item of ordered) {
-    depthCounts.set(item.depthIndex, (depthCounts.get(item.depthIndex) ?? 0) + 1);
-  }
-  for (let i = 1; i < ordered.length; i += 1) {
-    const prev = ordered[i - 1];
-    const next = ordered[i];
-    sourceJump += Math.abs(prev.i - next.i);
-    const dz = next.z - prev.z;
-    depthJump += Math.abs(dz);
-    if (Math.abs(dz) > 1e-9) depthRunCount += 1;
-    const depthDirection = Math.sign(dz);
-    if (depthDirection !== 0) {
-      if (lastDepthDirection !== 0 && depthDirection !== lastDepthDirection) directionChanges += 1;
-      lastDepthDirection = depthDirection;
-    }
-  }
-  const denom = Math.max(1, ordered.length - 1);
-  return {
-    sourceJumpMean: +(sourceJump / denom).toFixed(2),
-    depthJumpMean: +(depthJump / denom).toFixed(2),
-    depthDirectionChanges: directionChanges,
-    depthRunCount,
-    depthBucketCount: depthCounts.size,
-  };
-}
-
-function makeOrderCells(variant, leaves) {
-  const items = makeOrderItems(leaves);
-  const ordered = sortOrderItems(items, variant);
-  return {
-    metrics: { ...orderMetrics(items), ...orderedMetrics(ordered) },
-    cells: ordered.map((item) => `<b style="${orderStyle(item)}"></b>`).join(""),
-  };
-}
-
-function parseDepthVariant(variant) {
-  const match = /^(leaf|group)-z(\d+)(-comp)?$/.exec(variant);
-  if (match) {
-    return {
-      kind: match[1],
-      depthCount: Math.max(1, Number(match[2])),
-      actualDepthCount: Math.max(1, Number(match[2])),
-      compensateDepth: Boolean(match[3]),
-    };
-  }
-  const hybridMatch = /^hybrid-z(\d+)-d(\d+)$/.exec(variant);
-  if (hybridMatch) {
-    return {
-      kind: "hybrid",
-      depthCount: Math.max(1, Number(hybridMatch[1])),
-      actualDepthCount: Math.max(1, Number(hybridMatch[2])),
-    };
-  }
-  const tiledMatch = /^tiled-z(\d+)-t(\d+)$/.exec(variant);
-  if (tiledMatch) {
-    return {
-      kind: "tiled",
-      depthCount: Math.max(1, Number(tiledMatch[1])),
-      actualDepthCount: Math.max(1, Number(tiledMatch[1])),
-      tileCount: Math.max(1, Number(tiledMatch[2])),
-    };
-  }
-  const tile2dMatch = /^tile2d-z(\d+)-t(\d+)$/.exec(variant);
-  if (tile2dMatch) {
-    return {
-      kind: "tile2d",
-      depthCount: Math.max(1, Number(tile2dMatch[1])),
-      actualDepthCount: Math.max(1, Number(tile2dMatch[1])),
-      tileCount: Math.max(1, Number(tile2dMatch[2])),
-    };
-  }
-  if (!match) throw new Error(`Unknown depth-groups variant "${variant}"`);
-  return {
-    kind: "group",
-    depthCount: 1,
-    actualDepthCount: 1,
-  };
-}
-
-function depthPosition(i, leaves) {
-  const cols = Math.max(1, Math.ceil(Math.sqrt(leaves)));
-  const rows = Math.max(1, Math.ceil(leaves / cols));
-  const col = i % cols;
-  const row = Math.floor(i / cols);
-  return {
-    col,
-    row,
-    cols,
-    rows,
-    x: col * 8 - 200,
-    y: row * 8 - 200,
-  };
-}
-
-function depthValue(depthIndex, depthCount) {
-  return (depthIndex - (depthCount - 1) / 2) * DEPTH_STEP;
-}
-
-function compensateDepthPosition(position, z) {
-  return {
-    ...position,
-    y: position.y + z * Math.tan((ROOT_ROT_X * Math.PI) / 180),
-  };
-}
-
-function makeDepthGroupCells(variant, leaves) {
-  const { kind, depthCount, actualDepthCount, tileCount = 1, compensateDepth = false } = parseDepthVariant(variant);
-  if (kind === "leaf") {
-    const cells = [];
-    for (let i = 0; i < leaves; i++) {
-      const depthIndex = i % depthCount;
-      const z = depthValue(depthIndex, depthCount);
-      const { x, y } = compensateDepth
-        ? compensateDepthPosition(depthPosition(i, leaves), z)
-        : depthPosition(i, leaves);
-      cells.push(
-        `<b style="left:${x}px;top:${y}px;width:6px;height:6px;transform:translateZ(${z}px);"></b>`,
-      );
-    }
-    return cells.join("");
-  }
-
-  const buckets = Array.from({ length: depthCount }, () => []);
-  const tiledBuckets = new Map();
-  const tile2dBuckets = new Map();
-  for (let i = 0; i < leaves; i++) {
-    const actualDepthIndex = i % actualDepthCount;
-    const depthIndex = kind === "hybrid"
-      ? Math.min(depthCount - 1, Math.floor((actualDepthIndex / actualDepthCount) * depthCount))
-      : i % depthCount;
-    const actualZ = depthValue(actualDepthIndex, actualDepthCount);
-    const position = compensateDepth
-      ? compensateDepthPosition(depthPosition(i, leaves), actualZ)
-      : depthPosition(i, leaves);
-    const { x, y, col, row, cols, rows } = position;
-    if (kind === "tiled") {
-      const tx = Math.min(tileCount - 1, Math.floor((col / cols) * tileCount));
-      const ty = Math.min(tileCount - 1, Math.floor((row / rows) * tileCount));
-      const key = `${depthIndex}:${tx}:${ty}`;
-      const bucket = tiledBuckets.get(key) ?? { depthIndex, children: [] };
-      bucket.children.push({ x, y, actualZ });
-      tiledBuckets.set(key, bucket);
-      continue;
-    }
-    if (kind === "tile2d") {
-      const tx = Math.min(tileCount - 1, Math.floor((col / cols) * tileCount));
-      const ty = Math.min(tileCount - 1, Math.floor((row / rows) * tileCount));
-      const key = `${tx}:${ty}`;
-      const bucket = tile2dBuckets.get(key) ?? { children: [] };
-      bucket.children.push({ x, y, actualZ });
-      tile2dBuckets.set(key, bucket);
-      continue;
-    }
-    buckets[depthIndex].push({ x, y, actualZ });
-  }
-
-  const renderBoxedDepth = (children, z, renderChild) => {
-    const minX = Math.min(...children.map(({ x }) => x));
-    const minY = Math.min(...children.map(({ y }) => y));
-    const maxX = Math.max(...children.map(({ x }) => x + 6));
-    const maxY = Math.max(...children.map(({ y }) => y + 6));
-    const width = Math.max(0, maxX - minX);
-    const height = Math.max(0, maxY - minY);
-    const childHtml = children
-      .map((child) => renderChild(child, minX, minY))
-      .join("");
-    return `<div class="depth" style="left:${minX}px;top:${minY}px;width:${width}px;height:${height}px;transform:translateZ(${z}px)">${childHtml}</div>`;
-  };
-
-  if (kind === "tiled") {
-    return [...tiledBuckets.values()]
-      .map(({ depthIndex, children }) =>
-        renderBoxedDepth(
-          children,
-          depthValue(depthIndex, depthCount),
-          ({ x, y }, offsetX, offsetY) => `<b style="left:${x - offsetX}px;top:${y - offsetY}px;width:6px;height:6px;"></b>`,
-        )
-      )
-      .join("");
-  }
-
-  if (kind === "tile2d") {
-    return [...tile2dBuckets.values()]
-      .map(({ children }) => {
-        const minX = Math.min(...children.map(({ x }) => x));
-        const minY = Math.min(...children.map(({ y }) => y));
-        const maxX = Math.max(...children.map(({ x }) => x + 6));
-        const maxY = Math.max(...children.map(({ y }) => y + 6));
-        const width = Math.max(0, maxX - minX);
-        const height = Math.max(0, maxY - minY);
-        const childHtml = children
-          .map(({ x, y, actualZ }) =>
-            `<b style="left:${x - minX}px;top:${y - minY}px;width:6px;height:6px;transform:translateZ(${actualZ}px);"></b>`)
-          .join("");
-        return `<div class="tile2d" style="left:${minX}px;top:${minY}px;width:${width}px;height:${height}px;">${childHtml}</div>`;
-      })
-      .join("");
-  }
-
-  return buckets
-    .map((children, depthIndex) => {
-      const z = kind === "hybrid"
-        ? depthValue(depthIndex + 0.5, depthCount)
-        : depthValue(depthIndex, depthCount);
-      const childStyle = ({ x, y, actualZ }, offsetX = 0, offsetY = 0) => {
-        const residual = kind === "hybrid" ? actualZ - z : 0;
-        const transform = Math.abs(residual) > 1e-9 ? `transform:translateZ(${residual}px);` : "";
-        return `<b style="left:${x - offsetX}px;top:${y - offsetY}px;width:6px;height:6px;${transform}"></b>`;
-      };
-      if (!DEPTH_BOX) {
-        return `<div class="depth" style="transform:translateZ(${z}px)">${
-          children.map((child) => childStyle(child)).join("")
-        }</div>`;
-      }
-      return renderBoxedDepth(children, z, childStyle);
-    })
-    .join("");
-}
-
-function makeProjectionCells(variant, leaves) {
-  const cols = Math.max(1, Math.ceil(Math.sqrt(leaves)));
-  const cells = [];
-  for (let i = 0; i < leaves; i++) {
-    const x = (i % cols) * 8 - 200;
-    const y = Math.floor(i / cols) * 8 - 200;
-    const z = ((i % 136) - 67.5) * 6;
-    const vars = `--x:${x}px;--y:${y}px;--z:${z}px;`;
-    switch (variant) {
-      case "static-left-top":
-        cells.push(`<b style="left:${x}px;top:${y}px;width:6px;height:6px;"></b>`);
-        break;
-      case "static-transform":
-        cells.push(`<b style="width:6px;height:6px;transform:translate(${x}px,${y}px);"></b>`);
-        break;
-      case "var-transform":
-      case "registered-var-transform":
-        cells.push(`<b style="${vars}width:6px;height:6px;transform:translate(calc(var(--x) + var(--z) * var(--kx)),calc(var(--y) + var(--z) * var(--ky)));"></b>`);
-        break;
-      case "var-left-top":
-      case "registered-var-left-top":
-        cells.push(`<b style="${vars}left:calc(var(--x) + var(--z) * var(--kx));top:calc(var(--y) + var(--z) * var(--ky));width:6px;height:6px;"></b>`);
-        break;
-      case "translate3d-reference":
-        cells.push(`<b style="width:6px;height:6px;transform:translate3d(${x}px,${y}px,${z}px);"></b>`);
-        break;
-      default:
-        throw new Error(`Unknown projection variant "${variant}"`);
-    }
-  }
-  return cells.join("");
-}
-
-function makeHtml({ mode, variant, leaves, root }) {
-  let cells = "";
-  let caseMetrics = null;
-  if (mode === "depth-groups") {
-    cells = makeDepthGroupCells(variant, leaves);
-  } else if (mode === "projection") {
-    cells = makeProjectionCells(variant, leaves);
-  } else if (mode === "order") {
-    const result = makeOrderCells(variant, leaves);
-    cells = result.cells;
-    caseMetrics = result.metrics;
-  } else {
-    const leafHtml = [];
-    for (let i = 0; i < leaves; i++) {
-      const style =
-        mode === "topology"
-          ? topologyStyle(variant, i, leaves)
-          : distributionStyle(variant, i);
-      leafHtml.push(`<b style="${style}"></b>`);
-    }
-    cells = leafHtml.join("");
-  }
-
-  const projectionMode = mode === "projection";
-  const rootMotion =
-    projectionMode
-      ? `--kx:0;--ky:0;transform:scale(${ROOT_SCALE});`
-      : root === "css"
-      ? "animation:spin 10s linear infinite;"
-      : root === "var" || root === "var-registered"
-        ? `--rot:0deg;transform:scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg) rotate(var(--rot));`
-      : root === "rotate-prop"
-        ? `rotate:0deg;transform:scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg);`
-      : `transform:scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg) rotate(0deg);`;
-  const sceneWillChange = SCENE_WILL_CHANGE === "auto" ? "auto" : SCENE_WILL_CHANGE;
-  const leafExtra = [
-    `transform-style:${LEAF_TRANSFORM_STYLE}`,
-    `backface-visibility:${LEAF_BACKFACE}`,
-    LEAF_WILL_CHANGE ? `will-change:${LEAF_WILL_CHANGE}` : "",
-    LEAF_CONTAIN ? `contain:${LEAF_CONTAIN}` : "",
-  ].filter(Boolean).join(";");
-  const depthExtra = [
-    `transform-style:${DEPTH_TRANSFORM_STYLE}`,
-    DEPTH_WILL_CHANGE ? `will-change:${DEPTH_WILL_CHANGE}` : "",
-    DEPTH_CONTAIN ? `contain:${DEPTH_CONTAIN}` : "",
-  ].filter(Boolean).join(";");
-  const script =
-    projectionMode
-      ? `const root=document.querySelector('.scene');const samples=[];let last=performance.now(),frame=0;function tick(now){samples.push(now-last);last=now;frame++;const a=frame*0.03;root.style.setProperty('--kx',(Math.sin(a)*0.9).toFixed(6));root.style.setProperty('--ky',(Math.cos(a)*0.6).toFixed(6));requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};`
-      : root === "css"
-      ? "const samples=[];let last=performance.now();function tick(now){samples.push(now-last);last=now;requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};"
-      : root === "static"
-        ? "const samples=[];let last=performance.now();function tick(now){samples.push(now-last);last=now;requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};"
-        : root === "var" || root === "var-registered"
-          ? `const root=document.querySelector('.scene');const samples=[];let last=performance.now(),frame=0;function tick(now){samples.push(now-last);last=now;frame++;root.style.setProperty('--rot',((frame*${ROOT_ROT_STEP})%360)+'deg');requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};`
-        : root === "rotate-prop"
-          ? `const root=document.querySelector('.scene');const samples=[];let last=performance.now(),frame=0;function tick(now){samples.push(now-last);last=now;frame++;root.style.rotate=((frame*${ROOT_ROT_STEP})%360)+'deg';requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};`
-        : `const root=document.querySelector('.scene');const samples=[];let last=performance.now(),frame=0;function tick(now){samples.push(now-last);last=now;frame++;root.style.transform='scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg) rotate('+((frame*${ROOT_ROT_STEP})%360)+'deg)';requestAnimationFrame(tick)}requestAnimationFrame(tick);window.__probe={samples};`;
-  const registeredProperty = root === "var-registered"
-    ? "@property --rot { syntax: '<angle>'; inherits: false; initial-value: 0deg; }"
-    : variant.startsWith("registered-var-")
-      ? "@property --kx { syntax: '<number>'; inherits: true; initial-value: 0; } @property --ky { syntax: '<number>'; inherits: true; initial-value: 0; }"
-    : "";
-
-  return `<!doctype html><meta charset="utf-8"><style>
-${registeredProperty}
-body{margin:0;background:#111;overflow:hidden}
-#host{position:relative;width:1280px;height:800px;perspective:${PERSPECTIVE}px;transform-style:preserve-3d}
-.scene{position:absolute;left:50%;top:50%;width:0;height:0;transform-style:preserve-3d;will-change:${sceneWillChange};${rootMotion}}
-.depth{position:absolute;left:0;top:0;width:0;height:0;transform-origin:0 0;${depthExtra}}
-.tile2d{position:absolute;left:0;top:0;transform-origin:0 0;transform-style:preserve-3d}
-b{position:absolute;display:block;background:#5eead4;transform-origin:0 0;${leafExtra};margin:0;padding:0}
-@keyframes spin{from{transform:scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg) rotate(0deg)}to{transform:scale(${ROOT_SCALE}) rotateX(${ROOT_ROT_X}deg) rotate(360deg)}}
-</style><div id="host"><div class="scene">${cells}</div></div><script>window.__caseMetrics=${JSON.stringify(caseMetrics)};${script}</script>`;
-}
-
-async function runCase(browser, config) {
-  const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
-  await page.setContent(makeHtml(config), { waitUntil: "load" });
-  const screenMetrics = await page.evaluate(() => {
-    const rects = [...document.querySelectorAll("b")].map((el) => {
-      const rect = el.getBoundingClientRect();
-      return {
-        left: rect.left,
-        top: rect.top,
-        right: rect.right,
-        bottom: rect.bottom,
-        width: rect.width,
-        height: rect.height,
-      };
-    }).filter((rect) => rect.width > 0 && rect.height > 0);
-    if (!rects.length) return null;
-    const bounds = rects.reduce((acc, rect) => ({
-      left: Math.min(acc.left, rect.left),
-      top: Math.min(acc.top, rect.top),
-      right: Math.max(acc.right, rect.right),
-      bottom: Math.max(acc.bottom, rect.bottom),
-    }), { left: Infinity, top: Infinity, right: -Infinity, bottom: -Infinity });
-    const screenArea = Math.max(1, (bounds.right - bounds.left) * (bounds.bottom - bounds.top));
-    const sumArea = rects.reduce((sum, rect) => sum + rect.width * rect.height, 0);
-    const sampleLimit = 8000;
-    const stride = Math.max(1, Math.floor(rects.length / sampleLimit));
-    const sampled = rects.filter((_, index) => index % stride === 0).slice(0, sampleLimit);
-    const sorted = sampled.map((rect, index) => ({ ...rect, index })).sort((a, b) => a.left - b.left);
-    const active = [];
-    let overlapPairs = 0;
-    let overlapArea = 0;
-    for (const current of sorted) {
-      for (let i = active.length - 1; i >= 0; i -= 1) {
-        if (active[i].right <= current.left) active.splice(i, 1);
-      }
-      for (const other of active) {
-        if (other.bottom <= current.top || other.top >= current.bottom) continue;
-        const x0 = Math.max(current.left, other.left);
-        const x1 = Math.min(current.right, other.right);
-        const y0 = Math.max(current.top, other.top);
-        const y1 = Math.min(current.bottom, other.bottom);
-        if (x1 <= x0 || y1 <= y0) continue;
-        overlapPairs += 1;
-        overlapArea += (x1 - x0) * (y1 - y0);
-      }
-      active.push(current);
-    }
-    return {
-      leaves: rects.length,
-      boundsWidth: +(bounds.right - bounds.left).toFixed(1),
-      boundsHeight: +(bounds.bottom - bounds.top).toFixed(1),
-      boundsArea: +screenArea.toFixed(1),
-      sumArea: +sumArea.toFixed(1),
-      fillRatio: +(sumArea / screenArea).toFixed(3),
-      sampled: sampled.length,
-      overlapPairs,
-      overlapPairsPerLeaf: +(overlapPairs / Math.max(1, sampled.length)).toFixed(3),
-      overlapArea: +overlapArea.toFixed(1),
-      overlapAreaPerLeaf: +(overlapArea / Math.max(1, sampled.length)).toFixed(3),
-    };
-  });
-  await page.waitForTimeout(WARMUP_MS);
-  const cdp = TRACE ? await page.context().newCDPSession(page) : null;
-  const events = cdp ? await startTrace(cdp) : null;
-  const start = await page.evaluate(() => window.__probe.samples.length);
-  await page.waitForTimeout(SAMPLE_MS);
-  const dts = await page.evaluate(
-    (from) => window.__probe.samples.slice(from),
-    start,
-  );
-  const caseMetrics = await page.evaluate(() => window.__caseMetrics ?? null);
-  const trace = cdp ? await stopTrace(cdp, events) : null;
-  await page.close();
-  return {
-    ...config,
-    chromiumArgs: CHROMIUM_ARGS,
-    softwareBackend: SOFTWARE_BACKEND,
-    caseMetrics: { ...(caseMetrics ?? {}), screen: screenMetrics },
-    ...summarizeFrameTimes(dts),
-    trace,
-  };
-}
-
-function printRows(rows) {
-  const header = [
-    "mode",
-    "root",
-    "variant",
-    "fps_p50",
-    "fps_p95",
-    "p99",
-    "PAC/frame",
-    "DrawProps/frame",
-    "Draw/frame",
-    "case",
-  ];
-  console.log(header.join("\t"));
-  for (const row of rows) {
-    console.log([
-      row.mode,
-      row.root,
-      row.variant,
-      row.fps_p50.toFixed(1),
-      row.fps_p95.toFixed(1),
-      row.p99_ms.toFixed(1),
-      row.trace ? row.trace.pac.per_frame_ms.toFixed(3) : "",
-      row.trace ? row.trace.drawProps.per_frame_ms.toFixed(3) : "",
-      row.trace ? row.trace.draw.per_frame_ms.toFixed(3) : "",
-      row.caseMetrics
-        ? [
-            Number.isFinite(row.caseMetrics.fillRatio) ? `fill=${row.caseMetrics.fillRatio}` : "",
-            Number.isFinite(row.caseMetrics.estimatedPairOverlap) ? `overlap=${row.caseMetrics.estimatedPairOverlap}` : "",
-            row.caseMetrics.screen ? `screenFill=${row.caseMetrics.screen.fillRatio}` : "",
-            row.caseMetrics.screen ? `screenOverlap=${row.caseMetrics.screen.overlapPairsPerLeaf}` : "",
-            row.caseMetrics.screen ? `screen=${row.caseMetrics.screen.boundsWidth}x${row.caseMetrics.screen.boundsHeight}` : "",
-          ].filter(Boolean).join(" ")
-        : "",
-    ].join("\t"));
-  }
-}
-
-const configs = [];
-if (MODE === "all" || MODE === "topology") {
-  for (const variant of ["left-top", "translate2d", "translateZ0", "translateZ", "matrix3d"]) {
-    configs.push({ mode: "topology", root: ROOT ?? "css", variant, leaves: LEAVES });
-  }
-}
-if (MODE === "all" || MODE === "distribution") {
-  const leaves = MODE === "all" ? Math.min(LEAVES, 1200) : LEAVES;
-  for (const variant of ["cluster", "spread", "overlap"]) {
-    configs.push({ mode: "distribution", root: ROOT ?? "js", variant, leaves });
-  }
-}
-if (MODE === "all" || MODE === "order") {
-  const leaves = MODE === "all" ? Math.min(LEAVES, 2500) : LEAVES;
-  for (const variant of ["spatial", "tile4-spatial", "tile4-depth", "tile4-depth-back", "block64-depth", "depth-front", "depth-back", "random"]) {
-    if (VARIANT_FILTER.size > 0 && !VARIANT_FILTER.has(variant)) continue;
-    configs.push({ mode: "order", root: ROOT ?? "js", variant, leaves });
-  }
-}
-if (MODE === "all" || MODE === "depth-groups") {
-  const depthVariants = [
-    "leaf-z17",
-    "leaf-z50",
-    "leaf-z250",
-    "leaf-z250-comp",
-    "group-z1",
-    "group-z2",
-    "group-z4",
-    "group-z8",
-    "group-z12",
-    "group-z16",
-    "group-z16-comp",
-    "group-z17",
-    "group-z20",
-    "group-z24",
-    "group-z28",
-    "group-z32",
-    "group-z32-comp",
-    "group-z34",
-    "group-z50",
-    "group-z68",
-    "group-z80",
-    "group-z96",
-    "group-z112",
-    "group-z128",
-    "group-z136",
-    "group-z160",
-    "group-z192",
-    "group-z250",
-    "hybrid-z8-d136",
-    "hybrid-z16-d136",
-    "hybrid-z8-d250",
-    "tiled-z16-t2",
-    "tiled-z32-t2",
-    "tiled-z50-t2",
-    "tiled-z68-t2",
-    "tiled-z32-t4",
-    "tiled-z50-t4",
-    "tiled-z68-t4",
-    "tiled-z136-t4",
-    "tile2d-z250-t2",
-    "tile2d-z250-t4",
-    "tile2d-z250-t8",
-  ];
-  for (const variant of depthVariants) {
-    if (VARIANT_FILTER.size > 0 && !VARIANT_FILTER.has(variant)) continue;
-    configs.push({ mode: "depth-groups", root: ROOT ?? "css", variant, leaves: LEAVES });
-  }
-}
-if (MODE === "all" || MODE === "projection") {
-  for (const variant of [
-    "static-left-top",
-    "static-transform",
-    "var-transform",
-    "registered-var-transform",
-    "var-left-top",
-    "registered-var-left-top",
-    "translate3d-reference",
-  ]) {
-    if (VARIANT_FILTER.size > 0 && !VARIANT_FILTER.has(variant)) continue;
-    configs.push({ mode: "projection", root: ROOT ?? "vars", variant, leaves: LEAVES });
-  }
-}
-if (configs.length === 0) {
-  throw new Error(`Unknown --mode=${MODE}; use all, topology, distribution, order, depth-groups, or projection`);
-}
-
-const launchOptions = { headless: !HEADED, args: CHROMIUM_ARGS };
-if (EXECUTABLE) launchOptions.executablePath = EXECUTABLE;
-const browser = await chromium.launch(launchOptions);
-try {
-  const rows = [];
-  for (const config of configs) {
-    rows.push(await runCase(browser, config));
-  }
-  if (JSON_OUT) {
-    console.log(JSON.stringify(rows, null, 2));
-  } else {
-    printRows(rows);
-  }
-} finally {
-  await browser.close();
-}
diff --git a/bench/coplanar-tolerance-report.mjs b/bench/coplanar-tolerance-report.mjs
deleted file mode 100644
index 7540e476..00000000
--- a/bench/coplanar-tolerance-report.mjs
+++ /dev/null
@@ -1,417 +0,0 @@
-#!/usr/bin/env node
-/**
- * Report how close adjacent same-material triangle pairs are to being coplanar.
- *
- * Usage:
- *   node bench/coplanar-tolerance-report.mjs website/public/gallery/glb/Dog.glb
- *   node bench/coplanar-tolerance-report.mjs website/public/gallery/obj/chicken.obj --mtl website/public/gallery/obj/chicken.mtl
- *   node bench/coplanar-tolerance-report.mjs website/public/gallery/vox/dog.vox --json /tmp/dog-coplanar.json
- *
- * The report measures the culled, pre-merge triangle surface by default. That is
- * the useful point for approximate simplification: strict merge has not hidden
- * the rejected split quads yet, but fully interior triangles are out of the way.
- */
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, extname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  cullInteriorPolygons,
-  mergePolygons,
-  parseGltf,
-  parseMtl,
-  parseObj,
-  parseVox,
-} from "../packages/core/dist/index.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, "..");
-
-const argv = process.argv.slice(2);
-const flag = (name) => argv.indexOf(`--${name}`);
-const hasFlag = (name) => flag(name) >= 0;
-const optStr = (name, dflt = "") => {
-  const i = flag(name);
-  return i >= 0 ? argv[i + 1] : dflt;
-};
-const optList = (name, dflt) => {
-  const raw = optStr(name);
-  return raw ? raw.split(",").map(Number).filter(Number.isFinite) : dflt;
-};
-
-const inputArg = argv.find((arg) => !arg.startsWith("--"));
-if (!inputArg || hasFlag("help")) {
-  console.log(`Usage: node bench/coplanar-tolerance-report.mjs <model> [--mtl file] [--raw] [--json file]
-
-Options:
-  --mtl <file>          Companion MTL for OBJ color matching.
-  --raw                 Analyze raw parsed polygons instead of interior-culled polygons.
-  --json <file>         Write the full report as JSON.
-  --top <n>             Print the n least-coplanar examples. Default: 8.
-  --angles <list>       Comma-separated angle thresholds in degrees.
-  --distances <list>    Comma-separated best-fit plane distance thresholds in scene units.
-`);
-  process.exit(inputArg ? 0 : 1);
-}
-
-const modelPath = resolve(repoRoot, inputArg);
-const mtlPath = optStr("mtl") ? resolve(repoRoot, optStr("mtl")) : "";
-const jsonPath = optStr("json") ? resolve(repoRoot, optStr("json")) : "";
-const topCount = Number(optStr("top", "8"));
-const angleThresholds = optList("angles", [0.5, 1, 2, 5, 10, 15, 20, 30]);
-const distanceThresholds = optList("distances", [0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1]);
-
-if (!existsSync(modelPath)) throw new Error(`Model not found: ${modelPath}`);
-if (mtlPath && !existsSync(mtlPath)) throw new Error(`MTL not found: ${mtlPath}`);
-
-const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-const cross = (a, b) => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0],
-];
-const length = (v) => Math.hypot(v[0], v[1], v[2]);
-const scale = (v, n) => [v[0] * n, v[1] * n, v[2] * n];
-const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-const normalize = (v) => {
-  const len = length(v);
-  return len > 1e-12 ? scale(v, 1 / len) : null;
-};
-const clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
-const pct = (n, total) => total > 0 ? `${((n / total) * 100).toFixed(1)}%` : "0.0%";
-const fmt = (n, digits = 4) => Number.isFinite(n) ? n.toFixed(digits) : "n/a";
-const vecKey = (v) => `${v[0]},${v[1]},${v[2]}`;
-const edgeKey = (a, b) => {
-  const ak = vecKey(a);
-  const bk = vecKey(b);
-  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
-};
-
-function parseModel(path) {
-  const ext = extname(path).toLowerCase();
-  if (ext === ".glb" || ext === ".gltf") {
-    const bytes = readFileSync(path);
-    return parseGltf(bytes, {
-      baseUrl: path,
-      resolveBuffer: (uri) => readFileSync(resolve(dirname(path), uri)),
-    });
-  }
-  if (ext === ".obj") {
-    let objOptions = undefined;
-    if (mtlPath) {
-      const { colors, textures } = parseMtl(readFileSync(mtlPath, "utf8"));
-      objOptions = {
-        materialColors: colors,
-        materialTextures: Object.fromEntries(
-          Object.entries(textures).map(([name, texture]) => [name, resolve(dirname(mtlPath), texture)]),
-        ),
-      };
-    }
-    return parseObj(readFileSync(path, "utf8"), objOptions);
-  }
-  if (ext === ".vox") {
-    const bytes = readFileSync(path);
-    return parseVox(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
-  }
-  throw new Error(`Unsupported model extension "${ext}". Use .glb, .gltf, .obj, or .vox.`);
-}
-
-function materialKey(polygon) {
-  const data = polygon.data
-    ? Object.keys(polygon.data).sort().map((key) => `${key}:${String(polygon.data[key])}`).join("|")
-    : "";
-  return [
-    polygon.color ?? "#cccccc",
-    polygon.texture ?? "",
-    polygon.uvs ? "uv" : "plain",
-    data,
-  ].join("|");
-}
-
-function planeOf(polygon) {
-  const vertices = polygon.vertices;
-  if (!vertices || vertices.length < 3) return null;
-  const origin = vertices[0];
-  let normalSum = [0, 0, 0];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    normalSum = add(normalSum, cross(sub(vertices[i], origin), sub(vertices[i + 1], origin)));
-  }
-  const normal = normalize(normalSum);
-  return normal ? { normal, d: dot(normal, origin) } : null;
-}
-
-function bboxOf(polygons) {
-  const min = [Infinity, Infinity, Infinity];
-  const max = [-Infinity, -Infinity, -Infinity];
-  for (const polygon of polygons) {
-    for (const vertex of polygon.vertices ?? []) {
-      for (let axis = 0; axis < 3; axis++) {
-        min[axis] = Math.min(min[axis], vertex[axis]);
-        max[axis] = Math.max(max[axis], vertex[axis]);
-      }
-    }
-  }
-  const size = sub(max, min);
-  return { min, max, size, diagonal: length(size), maxExtent: Math.max(...size) };
-}
-
-function jacobiSmallestEigenVector3(matrix) {
-  const a = matrix.map((row) => row.slice());
-  const v = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-
-  for (let iter = 0; iter < 24; iter++) {
-    let p = 0;
-    let q = 1;
-    let maxOff = Math.abs(a[0][1]);
-    for (const [i, j] of [[0, 2], [1, 2]]) {
-      const off = Math.abs(a[i][j]);
-      if (off > maxOff) {
-        maxOff = off;
-        p = i;
-        q = j;
-      }
-    }
-    if (maxOff < 1e-14) break;
-
-    const app = a[p][p];
-    const aqq = a[q][q];
-    const apq = a[p][q];
-    const theta = (aqq - app) / (2 * apq);
-    const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
-    const c = 1 / Math.sqrt(t * t + 1);
-    const s = t * c;
-
-    for (let k = 0; k < 3; k++) {
-      if (k === p || k === q) continue;
-      const akp = a[k][p];
-      const akq = a[k][q];
-      a[k][p] = akp * c - akq * s;
-      a[p][k] = a[k][p];
-      a[k][q] = akp * s + akq * c;
-      a[q][k] = a[k][q];
-    }
-    a[p][p] = app * c * c + aqq * s * s - 2 * apq * s * c;
-    a[q][q] = app * s * s + aqq * c * c + 2 * apq * s * c;
-    a[p][q] = 0;
-    a[q][p] = 0;
-
-    for (let k = 0; k < 3; k++) {
-      const vkp = v[k][p];
-      const vkq = v[k][q];
-      v[k][p] = vkp * c - vkq * s;
-      v[k][q] = vkp * s + vkq * c;
-    }
-  }
-
-  let smallest = 0;
-  if (a[1][1] < a[smallest][smallest]) smallest = 1;
-  if (a[2][2] < a[smallest][smallest]) smallest = 2;
-  return normalize([v[0][smallest], v[1][smallest], v[2][smallest]]) ?? [0, 0, 1];
-}
-
-function bestFitPlane(points) {
-  const centroid = scale(points.reduce((sum, point) => add(sum, point), [0, 0, 0]), 1 / points.length);
-  const covariance = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
-  for (const point of points) {
-    const d = sub(point, centroid);
-    for (let row = 0; row < 3; row++) {
-      for (let col = 0; col < 3; col++) covariance[row][col] += d[row] * d[col];
-    }
-  }
-  const normal = jacobiSmallestEigenVector3(covariance);
-  const distances = points.map((point) => Math.abs(dot(normal, sub(point, centroid))));
-  const maxDistance = Math.max(...distances);
-  const rmsDistance = Math.sqrt(distances.reduce((sum, d) => sum + d * d, 0) / distances.length);
-  return { normal, centroid, maxDistance, rmsDistance };
-}
-
-function uniqueVertices(a, b) {
-  const out = [];
-  for (const vertex of [...a.vertices, ...b.vertices]) {
-    if (!out.some((existing) => vecKey(existing) === vecKey(vertex))) out.push(vertex);
-  }
-  return out;
-}
-
-function quantile(sortedValues, q) {
-  if (sortedValues.length === 0) return null;
-  const i = (sortedValues.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sortedValues[lo];
-  return sortedValues[lo] + (sortedValues[hi] - sortedValues[lo]) * (i - lo);
-}
-
-function summarize(values) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  return {
-    min: sorted[0] ?? null,
-    p50: quantile(sorted, 0.5),
-    p75: quantile(sorted, 0.75),
-    p90: quantile(sorted, 0.9),
-    p95: quantile(sorted, 0.95),
-    p99: quantile(sorted, 0.99),
-    max: sorted[sorted.length - 1] ?? null,
-  };
-}
-
-function buildPairs(polygons) {
-  const edgeIndex = new Map();
-  for (let polygonIndex = 0; polygonIndex < polygons.length; polygonIndex++) {
-    const polygon = polygons[polygonIndex];
-    for (let edge = 0; edge < polygon.vertices.length; edge++) {
-      const key = edgeKey(polygon.vertices[edge], polygon.vertices[(edge + 1) % polygon.vertices.length]);
-      const owners = edgeIndex.get(key);
-      const owner = { polygonIndex, edge };
-      if (owners) owners.push(owner);
-      else edgeIndex.set(key, [owner]);
-    }
-  }
-
-  const pairs = [];
-  for (const owners of edgeIndex.values()) {
-    if (owners.length !== 2) continue;
-    const a = polygons[owners[0].polygonIndex];
-    const b = polygons[owners[1].polygonIndex];
-    if (!a || !b) continue;
-    if (a.vertices.length !== 3 || b.vertices.length !== 3) continue;
-    if (materialKey(a) !== materialKey(b)) continue;
-
-    const unique = uniqueVertices(a, b);
-    if (unique.length !== 4) continue;
-
-    const planeA = planeOf(a);
-    const planeB = planeOf(b);
-    if (!planeA || !planeB) continue;
-    const normalDot = clamp(dot(planeA.normal, planeB.normal), -1, 1);
-    const angleDeg = Math.acos(clamp(normalDot, -1, 1)) * 180 / Math.PI;
-    const oppositeDistances = [
-      ...b.vertices.map((vertex) => Math.abs(dot(planeA.normal, vertex) - planeA.d)),
-      ...a.vertices.map((vertex) => Math.abs(dot(planeB.normal, vertex) - planeB.d)),
-    ];
-    const fit = bestFitPlane(unique);
-    pairs.push({
-      a: owners[0].polygonIndex,
-      b: owners[1].polygonIndex,
-      color: a.color ?? "#cccccc",
-      texture: a.texture,
-      normalDot,
-      angleDeg,
-      planeDelta: Math.abs(planeA.d - planeB.d),
-      maxOppositePlaneDistance: Math.max(...oppositeDistances),
-      bestFitMaxDistance: fit.maxDistance,
-      bestFitRmsDistance: fit.rmsDistance,
-      vertices: unique,
-    });
-  }
-  return pairs;
-}
-
-function thresholdCounts(pairs) {
-  return angleThresholds.map((angle) => ({
-    angleDeg: angle,
-    distances: distanceThresholds.map((distance) => ({
-      distance,
-      count: pairs.filter((pair) => pair.angleDeg <= angle && pair.bestFitMaxDistance <= distance).length,
-    })),
-  }));
-}
-
-function printThresholdTable(pairs, thresholds) {
-  const header = ["angle\\dist", ...distanceThresholds.map((d) => String(d))];
-  const rows = thresholds.map((row) => [
-    `${row.angleDeg}deg`,
-    ...row.distances.map((cell) => `${cell.count} (${pct(cell.count, pairs.length)})`),
-  ]);
-  const widths = header.map((cell, index) => Math.max(
-    cell.length,
-    ...rows.map((row) => String(row[index]).length),
-  ));
-  console.log(header.map((cell, i) => String(cell).padStart(widths[i])).join("  "));
-  for (const row of rows) {
-    console.log(row.map((cell, i) => String(cell).padStart(widths[i])).join("  "));
-  }
-}
-
-const parsed = parseModel(modelPath);
-const analysisPolygons = hasFlag("raw") ? parsed.polygons : cullInteriorPolygons(parsed.polygons);
-const strictMerged = mergePolygons(analysisPolygons);
-const bbox = bboxOf(analysisPolygons);
-const pairs = buildPairs(analysisPolygons);
-const strictLikePairs = pairs.filter((pair) => pair.normalDot > 0.999 && pair.planeDelta < 0.05);
-const angleStats = summarize(pairs.map((pair) => pair.angleDeg));
-const fitMaxStats = summarize(pairs.map((pair) => pair.bestFitMaxDistance));
-const fitRmsStats = summarize(pairs.map((pair) => pair.bestFitRmsDistance));
-const oppositeStats = summarize(pairs.map((pair) => pair.maxOppositePlaneDistance));
-const thresholds = thresholdCounts(pairs);
-const worst = [...pairs]
-  .sort((a, b) => b.bestFitMaxDistance - a.bestFitMaxDistance || b.angleDeg - a.angleDeg)
-  .slice(0, Number.isFinite(topCount) ? Math.max(0, topCount) : 8)
-  .map((pair) => ({
-    a: pair.a,
-    b: pair.b,
-    color: pair.color,
-    angleDeg: pair.angleDeg,
-    bestFitMaxDistance: pair.bestFitMaxDistance,
-    bestFitRmsDistance: pair.bestFitRmsDistance,
-    maxOppositePlaneDistance: pair.maxOppositePlaneDistance,
-  }));
-
-const report = {
-  model: modelPath,
-  analyzedSurface: hasFlag("raw") ? "raw parsed polygons" : "interior-culled polygons",
-  counts: {
-    rawPolygons: parsed.polygons.length,
-    analyzedPolygons: analysisPolygons.length,
-    strictMergedPolygons: strictMerged.length,
-    sharedEdgeSameMaterialTrianglePairs: pairs.length,
-    strictCoplanarPairMatches: strictLikePairs.length,
-  },
-  bbox,
-  stats: {
-    angleDeg: angleStats,
-    bestFitMaxDistance: fitMaxStats,
-    bestFitMaxDistancePctOfMaxExtent: summarize(pairs.map((pair) => pair.bestFitMaxDistance / bbox.maxExtent * 100)),
-    bestFitRmsDistance: fitRmsStats,
-    maxOppositePlaneDistance: oppositeStats,
-  },
-  thresholds,
-  worst,
-};
-
-console.log(`Coplanar tolerance report: ${modelPath}`);
-console.log(`Surface: ${report.analyzedSurface}`);
-console.log("");
-console.log(`Raw polygons:             ${report.counts.rawPolygons}`);
-console.log(`Analyzed polygons:        ${report.counts.analyzedPolygons}`);
-console.log(`Strict merged polygons:   ${report.counts.strictMergedPolygons}`);
-console.log(`Same-material tri pairs:  ${pairs.length}`);
-console.log(`Strict-like pair matches: ${strictLikePairs.length} (${pct(strictLikePairs.length, pairs.length)})`);
-console.log(`BBox max extent:          ${fmt(bbox.maxExtent, 3)} scene units`);
-console.log("");
-console.log("Pair error distributions");
-console.log(`angle deg              min ${fmt(angleStats.min)}  p50 ${fmt(angleStats.p50)}  p90 ${fmt(angleStats.p90)}  p95 ${fmt(angleStats.p95)}  p99 ${fmt(angleStats.p99)}  max ${fmt(angleStats.max)}`);
-console.log(`best-fit max distance  min ${fmt(fitMaxStats.min)}  p50 ${fmt(fitMaxStats.p50)}  p90 ${fmt(fitMaxStats.p90)}  p95 ${fmt(fitMaxStats.p95)}  p99 ${fmt(fitMaxStats.p99)}  max ${fmt(fitMaxStats.max)}`);
-console.log(`best-fit rms distance  min ${fmt(fitRmsStats.min)}  p50 ${fmt(fitRmsStats.p50)}  p90 ${fmt(fitRmsStats.p90)}  p95 ${fmt(fitRmsStats.p95)}  p99 ${fmt(fitRmsStats.p99)}  max ${fmt(fitRmsStats.max)}`);
-console.log(`opposite plane dist    min ${fmt(oppositeStats.min)}  p50 ${fmt(oppositeStats.p50)}  p90 ${fmt(oppositeStats.p90)}  p95 ${fmt(oppositeStats.p95)}  p99 ${fmt(oppositeStats.p99)}  max ${fmt(oppositeStats.max)}`);
-console.log("");
-console.log("Pairs within angle + best-fit max-distance thresholds");
-printThresholdTable(pairs, thresholds);
-
-if (worst.length > 0) {
-  console.log("");
-  console.log(`Worst ${worst.length} pairs by best-fit max distance`);
-  for (const pair of worst) {
-    console.log(
-      `#${pair.a}/#${pair.b} ${pair.color}  angle=${fmt(pair.angleDeg, 2)}deg  ` +
-      `fitMax=${fmt(pair.bestFitMaxDistance)}  fitRms=${fmt(pair.bestFitRmsDistance)}  ` +
-      `oppPlane=${fmt(pair.maxOppositePlaneDistance)}`,
-    );
-  }
-}
-
-if (jsonPath) {
-  writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
-  console.log("");
-  console.log(`Wrote JSON report: ${jsonPath}`);
-}
diff --git a/bench/entries/normalize.ts b/bench/entries/normalize.ts
deleted file mode 100644
index ae75f0a7..00000000
--- a/bench/entries/normalize.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * Bundled entry that exposes the current mesh optimizer and a small
- * "paint everything one color" helper. Used by the crack-finder bench
- * page (`bench/perf-cracks.html`) without depending on website-only debug
- * files.
- */
-import { optimizeMeshPolygons, type Polygon, type Vec3 } from "@layoutit/polycss";
-
-export function preprocessModelPolygons(polygons: Polygon[], normalizeGeometry: boolean): Polygon[] {
-  return optimizeMeshPolygons(polygons, {
-    meshResolution: normalizeGeometry ? "lossy" : "lossless",
-  });
-}
-
-/**
- * Replace every polygon's color with the given hex string and strip the
- * texture/uvs so the renderer falls back to the solid color path. Used
- * for crack detection: paint everything red, set a black background,
- * any black pixel inside the silhouette is a crack.
- */
-export function paintPolygonsSolid(polygons: Polygon[], color: string): Polygon[] {
-  return polygons.map((p) => ({
-    ...p,
-    color,
-    texture: undefined,
-    uvs: undefined,
-    textureTriangles: undefined,
-  }));
-}
-
-/**
- * Convert each polygon into N thin quads, one per edge — a wireframe
- * rendered through the same `<i>` machinery as a solid mesh. Each edge
- * quad lies in its parent polygon's plane (so it doesn't z-fight with
- * the original surface), with the given mesh-space line width.
- *
- * Useful for crack inspection: adjacent polygons that fail to share
- * an edge cleanly will show TWO parallel wireframe lines slightly
- * offset from each other — a visible crack indicator that doesn't
- * depend on pixel-perfect fill matching.
- *
- * Cost: 1 input polygon → N output quads (3 for a triangle, 4 for a
- * quad, etc.). Roughly 3–4× the DOM count of the source mesh.
- */
-export function polygonsToWireframe(polygons: Polygon[], lineWidth: number, color: string): Polygon[] {
-  const out: Polygon[] = [];
-  for (const p of polygons) {
-    const v = p.vertices;
-    if (!v || v.length < 3) continue;
-    const n = computePolygonNormal(v);
-    if (!n) continue;
-    const half = lineWidth / 2;
-    for (let i = 0; i < v.length; i++) {
-      const a = v[i];
-      const b = v[(i + 1) % v.length];
-      // Edge direction (normalized).
-      const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
-      const len = Math.hypot(dx, dy, dz);
-      if (len < 1e-9) continue;
-      const ex = dx / len, ey = dy / len, ez = dz / len;
-      // In-plane perpendicular = polygonNormal × edgeDir.
-      const px = n[1] * ez - n[2] * ey;
-      const py = n[2] * ex - n[0] * ez;
-      const pz = n[0] * ey - n[1] * ex;
-      const plen = Math.hypot(px, py, pz) || 1;
-      const ox = (px / plen) * half;
-      const oy = (py / plen) * half;
-      const oz = (pz / plen) * half;
-      // CCW from outside (matches the source polygon winding via shared normal).
-      out.push({
-        vertices: [
-          [a[0] + ox, a[1] + oy, a[2] + oz],
-          [b[0] + ox, b[1] + oy, b[2] + oz],
-          [b[0] - ox, b[1] - oy, b[2] - oz],
-          [a[0] - ox, a[1] - oy, a[2] - oz],
-        ],
-        color,
-      });
-    }
-  }
-  return out;
-}
-
-function computePolygonNormal(vertices: Vec3[]): Vec3 | null {
-  let nx = 0, ny = 0, nz = 0;
-  const o = vertices[0];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    const a = vertices[i];
-    const b = vertices[i + 1];
-    const ax = a[0] - o[0], ay = a[1] - o[1], az = a[2] - o[2];
-    const bx = b[0] - o[0], by = b[1] - o[1], bz = b[2] - o[2];
-    nx += ay * bz - az * by;
-    ny += az * bx - ax * bz;
-    nz += ax * by - ay * bx;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len < 1e-12) return null;
-  return [nx / len, ny / len, nz / len];
-}
diff --git a/bench/entries/react.tsx b/bench/entries/react.tsx
index de28ff10..805465c3 100644
--- a/bench/entries/react.tsx
+++ b/bench/entries/react.tsx
@@ -1,5 +1,5 @@
 /**
- * Bench entry — React. Bundled by bench/build.mjs into bench/polycss-react.js
+ * Bench entry — React. Bundled by bench/build.mjs into bench/.generated/polycss-react.js
  * and loaded by bench/perf-react.html.
  *
  * Mounts a <PolyCamera><PolyScene><PolyOrbitControls + mesh> tree and drives
diff --git a/bench/entries/vue.ts b/bench/entries/vue.ts
index fca22a55..bbdc1e72 100644
--- a/bench/entries/vue.ts
+++ b/bench/entries/vue.ts
@@ -1,5 +1,5 @@
 /**
- * Bench entry — Vue 3. Bundled by bench/build.mjs into bench/polycss-vue.js
+ * Bench entry — Vue 3. Bundled by bench/build.mjs into bench/.generated/polycss-vue.js
  * and loaded by bench/perf-vue.html.
  *
  * Mounts a <PolyCamera><PolyScene><PolyOrbitControls + mesh> tree and drives
diff --git a/bench/insurgent-semis-bench.mjs b/bench/insurgent-semis-bench.mjs
deleted file mode 100644
index 90977cb3..00000000
--- a/bench/insurgent-semis-bench.mjs
+++ /dev/null
@@ -1,636 +0,0 @@
-/**
- * Compare the stock Insurgent glTF against variants that either remove the
- * tiny sphere-like connected components or replace them with cheap LOD
- * proxies.
- *
- * Usage:
- *   node bench/insurgent-semis-bench.mjs
- *   node bench/insurgent-semis-bench.mjs --warmup 1500 --sample 4000
- *   node bench/insurgent-semis-bench.mjs --scenario baked.static
- *   node bench/insurgent-semis-bench.mjs --variant lod-box
- *   node bench/insurgent-semis-bench.mjs --headed
- *
- * This uses the vanilla createPolyScene path. The page parses the glTF in
- * browser, so the embedded texture Blob URLs stay valid for rendering.
- */
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
-import { dirname, extname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { readFile } from "node:fs/promises";
-import { chromium } from "playwright";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, "..");
-const benchDir = resolve(repoRoot, "bench");
-const galleryDir = resolve(repoRoot, "website/public/gallery");
-const polycssBundle = resolve(benchDir, "polycss.js");
-
-const argv = process.argv.slice(2);
-const flag = (name) => argv.indexOf(`--${name}`);
-const optStr = (name, dflt = "") => {
-  const i = flag(name);
-  return i >= 0 ? argv[i + 1] : dflt;
-};
-const optNum = (name, dflt) => {
-  const v = optStr(name);
-  return v ? Number(v) : dflt;
-};
-const hasFlag = (name) => flag(name) >= 0;
-
-const WARMUP_MS = optNum("warmup", 1500);
-const SAMPLE_MS = optNum("sample", 4000);
-const HEADED = hasFlag("headed");
-const LABEL = optStr("label");
-const SCENARIO_FILTER = optStr("scenario");
-const VARIANT_FILTER = optStr("variant");
-
-const SCENARIOS = [
-  { key: "dynamic.static", mode: "dynamic", motion: "none" },
-  { key: "dynamic.light_rotate", mode: "dynamic", motion: "light" },
-  { key: "dynamic.camera_rotate", mode: "dynamic", motion: "rot" },
-  { key: "baked.static", mode: "baked", motion: "none" },
-  { key: "baked.camera_rotate", mode: "baked", motion: "rot" },
-].filter((s) => !SCENARIO_FILTER || s.key === SCENARIO_FILTER);
-
-const VARIANTS = ["normal", "no-semis", "lod-box", "lod-cross"]
-  .filter((variant) => !VARIANT_FILTER || variant === VARIANT_FILTER);
-
-if (SCENARIOS.length === 0) {
-  throw new Error(`Unknown scenario "${SCENARIO_FILTER}"`);
-}
-if (VARIANTS.length === 0) {
-  throw new Error(`Unknown variant "${VARIANT_FILTER}"`);
-}
-if (!existsSync(polycssBundle)) {
-  throw new Error("bench/polycss.js is missing. Run `node bench/build.mjs` first.");
-}
-
-const MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".gltf": "application/json; charset=utf-8",
-  ".glb": "model/gltf-binary",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-};
-
-function pageHtml() {
-  return String.raw`<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <title>polycss perf - insurgent semis</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    html, body { width: 100%; height: 100%; background: #0e1014; color: #e2e8f0; font-family: ui-sans-serif, system-ui, sans-serif; }
-    #host { width: 100vw; height: 100vh; position: relative; }
-  </style>
-</head>
-<body>
-  <div id="host"></div>
-  <script type="module">
-    import {
-      createPolyScene,
-      createPolyControls,
-      parseGltf,
-      cullInteriorPolygons,
-      mergePolygons,
-    } from "./polycss.js";
-
-    const params = new URLSearchParams(location.search);
-    const variant = params.get("variant") || "normal";
-    const mode = params.get("mode") === "baked" ? "baked" : "dynamic";
-    const motion = params.get("motion") || "none";
-    const az = Number(params.get("az") || 50);
-    const el = Number(params.get("el") || 45);
-
-    function dirFromAzEl(azDeg, elDeg) {
-      const azRad = (azDeg * Math.PI) / 180;
-      const elRad = (elDeg * Math.PI) / 180;
-      const cosEl = Math.cos(elRad);
-      return [cosEl * Math.sin(azRad), cosEl * Math.cos(azRad), Math.sin(elRad)];
-    }
-
-    function solve4(A, b) {
-      A = A.map((row) => row.slice());
-      b = b.slice();
-      for (let i = 0; i < 4; i++) {
-        let pivot = i;
-        for (let r = i + 1; r < 4; r++) {
-          if (Math.abs(A[r][i]) > Math.abs(A[pivot][i])) pivot = r;
-        }
-        if (Math.abs(A[pivot][i]) < 1e-12) return null;
-        [A[i], A[pivot]] = [A[pivot], A[i]];
-        [b[i], b[pivot]] = [b[pivot], b[i]];
-        const div = A[i][i];
-        for (let c = i; c < 4; c++) A[i][c] /= div;
-        b[i] /= div;
-        for (let r = 0; r < 4; r++) {
-          if (r === i) continue;
-          const factor = A[r][i];
-          for (let c = i; c < 4; c++) A[r][c] -= factor * A[i][c];
-          b[r] -= factor * b[i];
-        }
-      }
-      return b;
-    }
-
-    function fitSphere(points) {
-      const A = Array.from({ length: 4 }, () => [0, 0, 0, 0]);
-      const b = [0, 0, 0, 0];
-      for (const [x, y, z] of points) {
-        const row = [x, y, z, 1];
-        const rhs = -(x * x + y * y + z * z);
-        for (let i = 0; i < 4; i++) {
-          for (let j = 0; j < 4; j++) A[i][j] += row[i] * row[j];
-          b[i] += row[i] * rhs;
-        }
-      }
-      const sol = solve4(A, b);
-      if (!sol) return null;
-      const [a, bb, c, d] = sol;
-      const center = [-a / 2, -bb / 2, -c / 2];
-      const radius2 = center[0] ** 2 + center[1] ** 2 + center[2] ** 2 - d;
-      if (!(radius2 > 0)) return null;
-      const radius = Math.sqrt(radius2);
-      const min = [Infinity, Infinity, Infinity];
-      const max = [-Infinity, -Infinity, -Infinity];
-      const devs = [];
-      const bins = new Set();
-      for (const p of points) {
-        for (let i = 0; i < 3; i++) {
-          min[i] = Math.min(min[i], p[i]);
-          max[i] = Math.max(max[i], p[i]);
-        }
-        const vx = p[0] - center[0];
-        const vy = p[1] - center[1];
-        const vz = p[2] - center[2];
-        const len = Math.hypot(vx, vy, vz) || 1;
-        devs.push(Math.abs(len - radius) / radius);
-        const theta = Math.atan2(vy / len, vx / len);
-        const phi = Math.asin(Math.max(-1, Math.min(1, vz / len)));
-        bins.add(String(Math.floor((theta + Math.PI) / (2 * Math.PI) * 16)) + "," + String(Math.floor((phi + Math.PI / 2) / Math.PI * 8)));
-      }
-      devs.sort((x, y) => x - y);
-      const p95 = devs[Math.floor(0.95 * (devs.length - 1))] ?? Infinity;
-      const rms = Math.sqrt(devs.reduce((sum, x) => sum + x * x, 0) / devs.length);
-      const extents = [max[0] - min[0], max[1] - min[1], max[2] - min[2]].sort((x, y) => x - y);
-      const extentRatio = extents[2] > 0 ? extents[0] / extents[2] : 0;
-      const boxCenter = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
-      const centerOffset = Math.hypot(center[0] - boxCenter[0], center[1] - boxCenter[1], center[2] - boxCenter[2]) / radius;
-      return { radius, p95, rms, extentRatio, centerOffset, bins: bins.size };
-    }
-
-    function componentInfo(polygons) {
-      const keyToPoly = new Map();
-      const keyFor = ([x, y, z]) => Math.round(x * 1000) + "," + Math.round(y * 1000) + "," + Math.round(z * 1000);
-      polygons.forEach((polygon, index) => {
-        for (const vertex of polygon.vertices ?? []) {
-          const key = keyFor(vertex);
-          let list = keyToPoly.get(key);
-          if (!list) keyToPoly.set(key, list = []);
-          list.push(index);
-        }
-      });
-
-      const seen = new Uint8Array(polygons.length);
-      const components = [];
-      for (let i = 0; i < polygons.length; i++) {
-        if (seen[i]) continue;
-        const stack = [i];
-        seen[i] = 1;
-        const polygonIndices = [];
-        const pointKeys = new Set();
-        const points = [];
-        while (stack.length) {
-          const current = stack.pop();
-          polygonIndices.push(current);
-          for (const vertex of polygons[current].vertices ?? []) {
-            const key = keyFor(vertex);
-            if (!pointKeys.has(key)) {
-              pointKeys.add(key);
-              points.push(vertex);
-            }
-            for (const next of keyToPoly.get(key) ?? []) {
-              if (!seen[next]) {
-                seen[next] = 1;
-                stack.push(next);
-              }
-            }
-          }
-        }
-        components.push({ polygonIndices, points });
-      }
-      return components;
-    }
-
-    function boundsForPoints(points) {
-      const min = [Infinity, Infinity, Infinity];
-      const max = [-Infinity, -Infinity, -Infinity];
-      for (const point of points) {
-        for (let i = 0; i < 3; i++) {
-          min[i] = Math.min(min[i], point[i]);
-          max[i] = Math.max(max[i], point[i]);
-        }
-      }
-      return { min, max };
-    }
-
-    function colorForComponent(component, polygons) {
-      const counts = new Map();
-      for (const index of component.polygonIndices) {
-        const color = polygons[index].color ?? "#888888";
-        counts.set(color, (counts.get(color) ?? 0) + 1);
-      }
-      let best = "#888888";
-      let bestCount = -1;
-      for (const [color, count] of counts) {
-        if (count > bestCount) {
-          best = color;
-          bestCount = count;
-        }
-      }
-      return best;
-    }
-
-    function boxProxyForComponent(component, polygons) {
-      const { min, max } = boundsForPoints(component.points);
-      const color = colorForComponent(component, polygons);
-      const [x0, y0, z0] = min;
-      const [x1, y1, z1] = max;
-      return [
-        { vertices: [[x0, y0, z0], [x1, y0, z0], [x1, y1, z0], [x0, y1, z0]], color },
-        { vertices: [[x0, y0, z1], [x0, y1, z1], [x1, y1, z1], [x1, y0, z1]], color },
-        { vertices: [[x0, y0, z0], [x0, y0, z1], [x1, y0, z1], [x1, y0, z0]], color },
-        { vertices: [[x1, y0, z0], [x1, y0, z1], [x1, y1, z1], [x1, y1, z0]], color },
-        { vertices: [[x1, y1, z0], [x1, y1, z1], [x0, y1, z1], [x0, y1, z0]], color },
-        { vertices: [[x0, y1, z0], [x0, y1, z1], [x0, y0, z1], [x0, y0, z0]], color },
-      ];
-    }
-
-    function crossProxyForComponent(component, polygons) {
-      const { min, max } = boundsForPoints(component.points);
-      const color = colorForComponent(component, polygons);
-      const [x0, y0, z0] = min;
-      const [x1, y1, z1] = max;
-      const cx = (x0 + x1) / 2;
-      const cy = (y0 + y1) / 2;
-      const cz = (z0 + z1) / 2;
-      return [
-        { vertices: [[x0, y0, cz], [x1, y0, cz], [x1, y1, cz], [x0, y1, cz]], color },
-        { vertices: [[x0, cy, z0], [x1, cy, z0], [x1, cy, z1], [x0, cy, z1]], color },
-        { vertices: [[cx, y0, z0], [cx, y1, z0], [cx, y1, z1], [cx, y0, z1]], color },
-      ];
-    }
-
-    function findInsurgentSemis(polygons) {
-      const components = componentInfo(polygons);
-      const candidates = [];
-      for (const component of components) {
-        if (component.polygonIndices.length < 32 || component.points.length < 20) continue;
-        const fit = fitSphere(component.points);
-        if (!fit) continue;
-        const semi =
-          fit.p95 <= 0.055 &&
-          fit.rms <= 0.04 &&
-          fit.extentRatio >= 0.45 &&
-          fit.centerOffset <= 0.55;
-        if (!semi) continue;
-        candidates.push({
-          component,
-          polygons: component.polygonIndices.length,
-          vertices: component.points.length,
-          radius: fit.radius,
-          p95: fit.p95,
-          rms: fit.rms,
-          extentRatio: fit.extentRatio,
-          centerOffset: fit.centerOffset,
-          bins: fit.bins,
-        });
-      }
-      return candidates;
-    }
-
-    function summarizeSemis(candidates) {
-      return candidates.map(({ component, ...meta }) => meta);
-    }
-
-    function removeInsurgentSemis(polygons) {
-      const candidates = findInsurgentSemis(polygons);
-      const remove = new Set();
-      for (const candidate of candidates) {
-        for (const index of candidate.component.polygonIndices) remove.add(index);
-      }
-      return {
-        polygons: polygons.filter((_, index) => !remove.has(index)),
-        removedComponents: summarizeSemis(candidates),
-        removedPolygons: remove.size,
-        proxyPolygons: 0,
-      };
-    }
-
-    function proxyInsurgentSemis(polygons, proxyKind) {
-      const candidates = findInsurgentSemis(polygons);
-      const remove = new Set();
-      const proxies = [];
-      for (const candidate of candidates) {
-        for (const index of candidate.component.polygonIndices) remove.add(index);
-        proxies.push(
-          ...(proxyKind === "cross"
-            ? crossProxyForComponent(candidate.component, polygons)
-            : boxProxyForComponent(candidate.component, polygons)),
-        );
-      }
-      return {
-        polygons: [
-          ...polygons.filter((_, index) => !remove.has(index)),
-          ...proxies,
-        ],
-        removedComponents: summarizeSemis(candidates),
-        removedPolygons: remove.size,
-        proxyPolygons: proxies.length,
-      };
-    }
-
-    function optimizeInsurgentSemis(polygons, variant) {
-      if (variant === "no-semis") return removeInsurgentSemis(polygons);
-      if (variant === "lod-box") return proxyInsurgentSemis(polygons, "box");
-      if (variant === "lod-cross") return proxyInsurgentSemis(polygons, "cross");
-      const detected = removeInsurgentSemis(polygons);
-      return {
-        polygons,
-        removedComponents: detected.removedComponents,
-        removedPolygons: detected.removedPolygons,
-        proxyPolygons: 0,
-      };
-    }
-
-    function postprocess(polygons) {
-      const surface = cullInteriorPolygons(polygons);
-      const merged = mergePolygons(surface);
-      return merged.length < polygons.length ? merged : polygons;
-    }
-
-    function quantile(sorted, q) {
-      if (sorted.length === 0) return 0;
-      const i = (sorted.length - 1) * q;
-      const lo = Math.floor(i);
-      const hi = Math.ceil(i);
-      if (lo === hi) return sorted[lo];
-      return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-    }
-
-    async function main() {
-      const gltfUrl = new URL("/gallery/glb/insurgent.gltf", location.href).href;
-      const buf = await fetch(gltfUrl).then((res) => {
-        if (!res.ok) throw new Error("fetch insurgent.gltf -> " + res.status);
-        return res.arrayBuffer();
-      });
-      const parsed = parseGltf(buf, { baseUrl: gltfUrl, targetSize: 60 });
-      const rawPolygons = parsed.polygons;
-      const optimized = optimizeInsurgentSemis(rawPolygons, variant);
-      const selectedRaw = optimized.polygons;
-      const finalPolygons = postprocess(selectedRaw);
-
-      const host = document.getElementById("host");
-      let azimuth = az;
-      const scene = createPolyScene(host, {
-        rotX: 65,
-        rotY: 45,
-        zoom: 0.4,
-        directionalLight: { direction: dirFromAzEl(azimuth, el), color: "#ffffff", intensity: 1 },
-        ambientLight: { color: "#ffffff", intensity: 0.4 },
-        textureLighting: mode,
-        autoCenter: true,
-      });
-      createPolyControls(scene, { drag: true, wheel: true, animate: false });
-      scene.add({ ...parsed, polygons: finalPolygons });
-
-      window.__perf__ = {
-        ready: true,
-        variant,
-        mode,
-        motion,
-        polyCount: finalPolygons.length,
-        rawPolyCount: rawPolygons.length,
-        selectedRawPolyCount: selectedRaw.length,
-        removedRawPolygons: optimized.removedPolygons,
-        removedComponents: optimized.removedComponents,
-        proxyPolygons: optimized.proxyPolygons,
-        samples: [],
-      };
-
-      let lastTs = performance.now();
-      let frameCount = 0;
-      function tick(now) {
-        const dt = now - lastTs;
-        lastTs = now;
-        window.__perf__.samples.push({ t: now, dt });
-        if (window.__perf__.samples.length > 2400) {
-          window.__perf__.samples.splice(0, window.__perf__.samples.length - 2400);
-        }
-        frameCount += 1;
-        if (motion === "light") {
-          azimuth = (azimuth + 0.5) % 360;
-          scene.setOptions({
-            directionalLight: { direction: dirFromAzEl(azimuth, el), color: "#ffffff", intensity: 1 },
-          });
-        } else if (motion === "rot") {
-          scene.setOptions({ rotY: ((45 + frameCount * 0.5) + 360) % 360 });
-        }
-        requestAnimationFrame(tick);
-      }
-      requestAnimationFrame(tick);
-    }
-
-    main().catch((err) => {
-      console.error(err);
-      window.__perf__ = { ready: false, error: String(err?.message ?? err), samples: [] };
-    });
-  </script>
-</body>
-</html>`;
-}
-
-function startServer() {
-  return new Promise((resolveStart, rejectStart) => {
-    const server = createServer(async (req, res) => {
-      try {
-        const url = new URL(req.url, "http://localhost");
-        const pathname = url.pathname.replace(/\/+/g, "/");
-        if (pathname.includes("..")) {
-          res.writeHead(403);
-          res.end("forbidden");
-          return;
-        }
-        if (pathname === "/" || pathname === "/insurgent-semis.html") {
-          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
-          res.end(pageHtml());
-          return;
-        }
-        let abs;
-        if (pathname.startsWith("/gallery/")) {
-          abs = resolve(galleryDir, pathname.slice("/gallery/".length));
-        } else {
-          abs = resolve(benchDir, pathname.slice(1));
-        }
-        const data = await readFile(abs);
-        res.writeHead(200, {
-          "Content-Type": MIME[extname(abs).toLowerCase()] || "application/octet-stream",
-          "Cache-Control": "no-store",
-        });
-        res.end(data);
-      } catch (err) {
-        res.writeHead(404);
-        res.end(String(err?.message ?? err));
-      }
-    });
-    server.on("error", rejectStart);
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolveStart({ server, port: typeof addr === "object" ? addr.port : 0 });
-    });
-  });
-}
-
-function stopServer(server) {
-  return new Promise((resolveStop) => server.close(() => resolveStop()));
-}
-
-async function runCase(port, scenario, variant) {
-  const browser = await chromium.launch({ headless: !HEADED });
-  try {
-    const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
-    const page = await ctx.newPage();
-    const url = `http://127.0.0.1:${port}/insurgent-semis.html?variant=${variant}&mode=${scenario.mode}&motion=${scenario.motion}`;
-    await page.goto(url, { waitUntil: "load" });
-    await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 60000 });
-    const meta = await page.evaluate(() => {
-      const removed = window.__perf__.removedComponents ?? [];
-      const groups = new Map();
-      for (const item of removed) {
-        const key = `${item.polygons}|${item.vertices}|${item.radius.toFixed(3)}`;
-        const group = groups.get(key) ?? {
-          count: 0,
-          polygons: item.polygons,
-          vertices: item.vertices,
-          radius: +item.radius.toFixed(3),
-        };
-        group.count += 1;
-        groups.set(key, group);
-      }
-      return {
-        polyCount: window.__perf__.polyCount,
-        rawPolyCount: window.__perf__.rawPolyCount,
-        selectedRawPolyCount: window.__perf__.selectedRawPolyCount,
-        removedRawPolygons: window.__perf__.removedRawPolygons,
-        removedComponentCount: removed.length,
-        removedComponentGroups: [...groups.values()],
-        proxyPolygons: window.__perf__.proxyPolygons,
-      };
-    });
-    await page.waitForTimeout(WARMUP_MS);
-    const startIdx = await page.evaluate(() => window.__perf__.samples.length);
-    await page.waitForTimeout(SAMPLE_MS);
-    const result = await page.evaluate((from) => {
-      const samples = window.__perf__.samples.slice(from);
-      const raw = samples.map((s) => s.dt).filter((dt) => dt > 0);
-      const dts = raw.filter((dt) => dt < 2000).sort((a, b) => a - b);
-      const quantile = (sorted, q) => {
-        if (sorted.length === 0) return 0;
-        const i = (sorted.length - 1) * q;
-        const lo = Math.floor(i);
-        const hi = Math.ceil(i);
-        if (lo === hi) return sorted[lo];
-        return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-      };
-      const p50 = quantile(dts, 0.5);
-      const p95 = quantile(dts, 0.95);
-      const p99 = quantile(dts, 0.99);
-      return {
-        fps_p50: p50 > 0 ? 1000 / p50 : 0,
-        fps_p95: p95 > 0 ? 1000 / p95 : 0,
-        frame_time_p50_ms: p50,
-        frame_time_p95_ms: p95,
-        frame_time_p99_ms: p99,
-        sample_count: dts.length,
-        sample_count_raw: raw.length,
-      };
-    }, startIdx);
-    await ctx.close();
-    return { ...meta, ...result };
-  } finally {
-    await browser.close();
-  }
-}
-
-function roundResult(result) {
-  return {
-    ...result,
-    fps_p50: +result.fps_p50.toFixed(2),
-    fps_p95: +result.fps_p95.toFixed(2),
-    frame_time_p50_ms: +result.frame_time_p50_ms.toFixed(2),
-    frame_time_p95_ms: +result.frame_time_p95_ms.toFixed(2),
-    frame_time_p99_ms: +result.frame_time_p99_ms.toFixed(2),
-  };
-}
-
-const { server, port } = await startServer();
-console.log(`[insurgent-semis] server :${port}`);
-console.log(`[insurgent-semis] warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms`);
-
-try {
-  const results = {};
-  for (const scenario of SCENARIOS) {
-    const scenarioResults = {};
-    for (const variant of VARIANTS) {
-      process.stdout.write(`  ${scenario.key.padEnd(24)} ${variant.padEnd(9)} ... `);
-      const measured = await runCase(port, scenario, variant);
-      process.stdout.write(`${measured.fps_p50.toFixed(1)}fps\n`);
-      scenarioResults[variant] = roundResult(measured);
-    }
-
-    const normal = scenarioResults.normal;
-    const deltas = {};
-    if (normal) {
-      for (const [variant, measured] of Object.entries(scenarioResults)) {
-        if (variant === "normal") continue;
-        deltas[variant] = {
-          removedRawPolygons: measured.removedRawPolygons,
-          removedComponents: measured.removedComponentCount,
-          proxyPolygons: measured.proxyPolygons,
-          finalPolygonDelta: normal.polyCount - measured.polyCount,
-          fpsP50Delta: +(measured.fps_p50 - normal.fps_p50).toFixed(2),
-          fpsP50Ratio: normal.fps_p50 > 0 ? +(measured.fps_p50 / normal.fps_p50).toFixed(3) : 0,
-          frameP95DeltaMs: +(measured.frame_time_p95_ms - normal.frame_time_p95_ms).toFixed(2),
-        };
-      }
-    }
-    results[scenario.key] = { ...scenarioResults, deltas };
-  }
-
-  const output = {
-    mesh: "insurgent",
-    renderer: "vanilla",
-    variants: VARIANTS,
-    warmup_ms: WARMUP_MS,
-    sample_ms: SAMPLE_MS,
-    results,
-  };
-
-  if (LABEL) {
-    const dir = resolve(repoRoot, "bench/results");
-    mkdirSync(dir, { recursive: true });
-    const file = resolve(dir, `${LABEL}.json`);
-    writeFileSync(file, JSON.stringify(output, null, 2) + "\n");
-    console.log(`[insurgent-semis] wrote ${file}`);
-  }
-
-  console.log(JSON.stringify(output, null, 2));
-} finally {
-  await stopServer(server);
-}
diff --git a/bench/lossy-corpus-bench.mjs b/bench/lossy-corpus-bench.mjs
new file mode 100644
index 00000000..1ed032b8
--- /dev/null
+++ b/bench/lossy-corpus-bench.mjs
@@ -0,0 +1,998 @@
+#!/usr/bin/env node
+/**
+ * Deep corpus report for meshResolution="lossy".
+ *
+ * This is a count/quality bench, not a browser FPS bench. It scans gallery
+ * GLB/GLTF/OBJ assets, compares lossless/current lossy/forced lossy candidate
+ * families, and records crack-budget diagnostics for the forced candidates.
+ *
+ * Usage:
+ *   node bench/lossy-corpus-bench.mjs
+ *   node bench/lossy-corpus-bench.mjs --models adventurer,snail
+ *   node bench/lossy-corpus-bench.mjs --json bench/results/lossy-corpus.json
+ *   node bench/lossy-corpus-bench.mjs --from-json bench/results/lossy-corpus.json --opportunities
+ *   node bench/lossy-corpus-bench.mjs --from-json after.json --compare before.json
+ *   node bench/lossy-corpus-bench.mjs --models animated-shark --sweep
+ *   node bench/lossy-corpus-bench.mjs --root /tmp/polycss-model-corpus --json /tmp/corpus.json
+ */
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { performance } from "node:perf_hooks";
+import {
+  bakeSolidTextureSamples,
+  optimizeAnimatedMeshPolygons,
+  optimizeMeshPolygons,
+  parseGltf,
+  parseMtl,
+  parseObj,
+} from "../packages/core/dist/index.js";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const galleryRoot = resolve(repoRoot, "website/public/gallery");
+const glbRoot = join(galleryRoot, "glb");
+const objRoot = join(galleryRoot, "obj");
+const requireFromWebsite = createRequire(resolve(repoRoot, "website/package.json"));
+
+const argv = process.argv.slice(2);
+const flag = (name) => argv.indexOf(`--${name}`);
+const hasFlag = (name) => flag(name) >= 0;
+const optStr = (name, dflt = "") => {
+  const index = flag(name);
+  return index >= 0 ? argv[index + 1] : dflt;
+};
+
+if (hasFlag("help")) {
+  console.log(`Usage: node bench/lossy-corpus-bench.mjs [--models filter] [--json file] [--sweep]
+       node bench/lossy-corpus-bench.mjs --from-json file [--opportunities] [--compare baseline]
+
+Options:
+  --models <list>       Comma-separated case-insensitive substrings to include.
+  --models-file <file>  Newline-separated model paths or substrings to include.
+  --root <dir>          Scan GLB/GLTF/OBJ files under a temporary corpus root.
+  --json <file>         Write full summary + rows as JSON.
+  --from-json <file>    Read an existing corpus JSON instead of scanning models.
+  --compare <file>      Compare this run/JSON against a prior corpus JSON.
+  --opportunities       Print ranked lossy opportunity and timing tables.
+  --quick               Only compute raw/lossless/current stats and current timings.
+  --sweep               Run an expanded lossy candidate sweep. Use with --models first.
+  --limit <n>           Number of rows to print for opportunity/compare tables.
+  --file-offset <n>     Skip the first n selected files before scanning.
+  --file-limit <n>      Scan at most n selected files.
+  --timeout-ms <n>      Kill and record a model row if it exceeds n ms.
+  --progress <n>        Print progress to stderr every n scanned files.
+`);
+  process.exit(0);
+}
+
+const PRINT_LIMIT = Number(optStr("limit", "12")) || 12;
+const FILE_OFFSET = Math.max(0, Number(optStr("file-offset", "0")) || 0);
+const FILE_LIMIT = Math.max(0, Number(optStr("file-limit", "0")) || 0);
+const PROGRESS_EVERY = Math.max(0, Number(optStr("progress", "0")) || 0);
+const MODEL_TIMEOUT_MS = Math.max(0, Number(optStr("timeout-ms", optStr("timeout", "0"))) || 0);
+const QUICK_MODE = hasFlag("quick");
+const INCLUDE_SWEEP = hasFlag("sweep");
+const sourceRoot = optStr("root") ? resolve(repoRoot, optStr("root")) : galleryRoot;
+
+const FORCED_OPTIONS = [
+  ["pair-tight", { maxAngleDeg: 15, maxPlaneDisplacement: 0.35, maxBoundaryDisplacement: 0.02, isolatedPairs: true }],
+  ["pair-default", { maxAngleDeg: 15, maxPlaneDisplacement: 0.35, maxBoundaryDisplacement: 0.0725, isolatedPairs: true }],
+  ["pair-wide", { maxAngleDeg: 45, maxPlaneDisplacement: 1, maxBoundaryDisplacement: 0.0725, isolatedPairs: true }],
+  ["group-default", { maxAngleDeg: 15, maxPlaneDisplacement: 0.35, maxBoundaryDisplacement: 0.0725, isolatedPairs: false }],
+  ["group-wide", { maxAngleDeg: 45, maxPlaneDisplacement: 1, maxBoundaryDisplacement: 0.0725, isolatedPairs: false }],
+];
+
+const SWEEP_BUDGETS = [
+  { maxAngleDeg: 8, maxPlaneDisplacement: 0.12, maxBoundaryDisplacement: 0.015 },
+  { maxAngleDeg: 12, maxPlaneDisplacement: 0.25, maxBoundaryDisplacement: 0.02 },
+  { maxAngleDeg: 15, maxPlaneDisplacement: 0.35, maxBoundaryDisplacement: 0.04 },
+  { maxAngleDeg: 20, maxPlaneDisplacement: 0.5, maxBoundaryDisplacement: 0.04 },
+  { maxAngleDeg: 25, maxPlaneDisplacement: 0.65, maxBoundaryDisplacement: 0.055 },
+  { maxAngleDeg: 35, maxPlaneDisplacement: 0.85, maxBoundaryDisplacement: 0.0725 },
+  { maxAngleDeg: 45, maxPlaneDisplacement: 1, maxBoundaryDisplacement: 0.0725 },
+];
+
+function sweepOptions(losslessStats) {
+  const out = [];
+  for (const budget of SWEEP_BUDGETS) {
+    out.push([
+      `pair-a${budget.maxAngleDeg}-p${budget.maxPlaneDisplacement}-b${budget.maxBoundaryDisplacement}`,
+      { ...budget, isolatedPairs: true },
+    ]);
+    if (shouldMeasureGroupCandidates(losslessStats)) {
+      out.push([
+        `group-a${budget.maxAngleDeg}-p${budget.maxPlaneDisplacement}-b${budget.maxBoundaryDisplacement}`,
+        { ...budget, isolatedPairs: false },
+      ]);
+    }
+  }
+  return out;
+}
+
+function candidateKey(options) {
+  return [
+    options.maxAngleDeg,
+    options.maxPlaneDisplacement,
+    options.maxBoundaryDisplacement,
+    options.isolatedPairs,
+  ].join("|");
+}
+
+function walk(dir, exts) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(path, exts));
+    else if (exts.has(extname(entry.name).toLowerCase())) out.push(path);
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+
+function selectedFiles() {
+  const exts = new Set([".glb", ".gltf", ".obj"]);
+  const files = optStr("root")
+    ? walk(sourceRoot, exts)
+    : [
+        ...walk(glbRoot, new Set([".glb", ".gltf"])),
+        ...walk(objRoot, new Set([".obj"])),
+      ];
+  const needles = selectedModelNeedles();
+  if (needles.length === 0) return sliceSelectedFiles(files);
+  const filtered = files.filter((file) => {
+    const label = relative(sourceRoot, file).toLowerCase();
+    return needles.some((needle) => label.includes(needle));
+  });
+  return sliceSelectedFiles(filtered);
+}
+
+function selectedModelNeedles() {
+  const needles = [];
+  const filter = optStr("models").trim();
+  if (filter) {
+    needles.push(...filter.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean));
+  }
+  const modelsFile = optStr("models-file").trim();
+  if (modelsFile) {
+    const file = resolve(repoRoot, modelsFile);
+    const lines = readFileSync(file, "utf8")
+      .split(/\r?\n/)
+      .map((line) => line.replace(/#.*$/, "").trim().toLowerCase())
+      .filter(Boolean);
+    needles.push(...lines);
+  }
+  return needles;
+}
+
+function sliceSelectedFiles(files) {
+  const start = Math.min(FILE_OFFSET, files.length);
+  const end = FILE_LIMIT > 0 ? Math.min(files.length, start + FILE_LIMIT) : files.length;
+  return files.slice(start, end);
+}
+
+function readBytes(path) {
+  const bytes = readFileSync(path);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+let textureSamplingReady = false;
+let textureSamplingUnavailable = false;
+
+function installTextureSamplingEnv() {
+  if (textureSamplingReady) return true;
+  if (textureSamplingUnavailable) return false;
+
+  let sharp;
+  try {
+    sharp = requireFromWebsite("sharp");
+  } catch {
+    textureSamplingUnavailable = true;
+    return false;
+  }
+
+  class BenchImage {
+    onload = null;
+    onerror = null;
+    decoding = "async";
+    width = 0;
+    height = 0;
+    naturalWidth = 0;
+    naturalHeight = 0;
+    data = null;
+    #decodePromise = null;
+    #src = "";
+
+    set src(value) {
+      this.#src = value;
+      this.#decodePromise = (async () => {
+        const input = await readImageBytes(value);
+        const { data, info } = await sharp(input).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+        this.width = this.naturalWidth = info.width;
+        this.height = this.naturalHeight = info.height;
+        this.data = data;
+        this.onload?.();
+      })().catch((error) => {
+        this.onerror?.();
+        throw error;
+      });
+    }
+
+    get src() {
+      return this.#src;
+    }
+
+    decode() {
+      return this.#decodePromise ?? Promise.resolve();
+    }
+  }
+
+  class BenchCanvas {
+    width = 0;
+    height = 0;
+    image = null;
+
+    getContext() {
+      return {
+        drawImage: (image) => {
+          this.image = image;
+        },
+        getImageData: () => ({
+          data: this.image?.data ?? new Uint8ClampedArray(this.width * this.height * 4),
+        }),
+      };
+    }
+  }
+
+  globalThis.Image = BenchImage;
+  globalThis.document = {
+    createElement: (tagName) => tagName === "canvas" ? new BenchCanvas() : {},
+  };
+  textureSamplingReady = true;
+  return true;
+}
+
+async function readImageBytes(url) {
+  if (/^(blob:|data:|https?:)/.test(url)) {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`image fetch failed: ${response.status}`);
+    return Buffer.from(await response.arrayBuffer());
+  }
+  return readFileSync(url.startsWith("file://") ? fileURLToPath(url) : url);
+}
+
+async function applyGalleryTexturePrepass(result) {
+  if (!installTextureSamplingEnv()) return result;
+  return bakeSolidTextureSamples(result);
+}
+
+function inferObjTextureOverrides(modelPath) {
+  const overrides = {};
+  if (modelPath.includes("/quaternius/ultimate-spaceships/")) {
+    const dir = dirname(modelPath);
+    const texture = readdirSync(dir).find((name) =>
+      /\.(png|jpe?g)$/i.test(name) && !/normal|rough|metal|ao/i.test(name)
+    );
+    if (texture) overrides.Texture = join(dir, texture);
+  }
+  return overrides;
+}
+
+async function parseModel(modelPath) {
+  const ext = extname(modelPath).toLowerCase();
+  if (ext === ".glb" || ext === ".gltf") {
+    return applyGalleryTexturePrepass(parseGltf(readBytes(modelPath), {
+      baseUrl: pathToFileURL(modelPath).href,
+      resolveBuffer: (uri) => readFileSync(resolve(dirname(modelPath), uri)),
+    }));
+  }
+
+  if (ext === ".obj") {
+    const text = readFileSync(modelPath, "utf8");
+    const mtlPath = modelPath.replace(/\.obj$/i, ".mtl");
+    const materialColors = {};
+    const materialTextures = inferObjTextureOverrides(modelPath);
+    if (existsSync(mtlPath)) {
+      const mtl = parseMtl(readFileSync(mtlPath, "utf8"));
+      Object.assign(materialColors, mtl.colors);
+      for (const [name, texture] of Object.entries(mtl.textures)) {
+        materialTextures[name] = resolve(dirname(mtlPath), texture);
+      }
+    }
+    return applyGalleryTexturePrepass(parseObj(text, {
+      targetSize: /coliseum\.obj$/.test(modelPath) ? 80 : 60,
+      defaultColor: "#8b95a1",
+      materialColors,
+      materialTextures,
+    }));
+  }
+
+  throw new Error(`Unsupported model: ${modelPath}`);
+}
+
+function polygonRenderCost(polygons) {
+  let cost = 0;
+  for (const polygon of polygons) {
+    const vertexCount = polygon.vertices.length;
+    const irregularPenalty = vertexCount <= 4 ? 0 : Math.min(4, vertexCount - 4) * 0.12;
+    const texturePenalty = polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length ? 0.15 : 0;
+    cost += 1 + irregularPenalty + texturePenalty;
+  }
+  return cost;
+}
+
+function polygonStats(polygons) {
+  let triangles = 0;
+  let quads = 0;
+  let textured = 0;
+  let maxVertices = 0;
+  for (const polygon of polygons) {
+    if (polygon.vertices.length === 3) triangles += 1;
+    else if (polygon.vertices.length === 4) quads += 1;
+    if (polygon.texture || polygon.material?.texture || polygon.uvs || polygon.textureTriangles?.length) textured += 1;
+    maxVertices = Math.max(maxVertices, polygon.vertices.length);
+  }
+  return {
+    count: polygons.length,
+    cost: Number(polygonRenderCost(polygons).toFixed(2)),
+    triangles,
+    quads,
+    textured,
+    maxVertices,
+  };
+}
+
+function vertexKey(vertex) {
+  return `${vertex[0]},${vertex[1]},${vertex[2]}`;
+}
+
+function edgeKey(a, b) {
+  const ak = vertexKey(a);
+  const bk = vertexKey(b);
+  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
+}
+
+function distanceVec(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
+
+function collectEdgeStats(polygons) {
+  const edges = new Map();
+  for (const polygon of polygons) {
+    for (let i = 0; i < polygon.vertices.length; i++) {
+      const a = polygon.vertices[i];
+      const b = polygon.vertices[(i + 1) % polygon.vertices.length];
+      const key = edgeKey(a, b);
+      const current = edges.get(key);
+      if (current) current.count += 1;
+      else edges.set(key, { count: 1, a, b });
+    }
+  }
+
+  const boundaryKeys = new Set();
+  const internalKeys = new Set();
+  const boundarySegments = [];
+  const internalSegments = [];
+  let boundaryLength = 0;
+  for (const [key, edge] of edges) {
+    const segment = { a: edge.a, b: edge.b };
+    if (edge.count === 1) {
+      boundaryKeys.add(key);
+      boundarySegments.push(segment);
+      boundaryLength += distanceVec(segment.a, segment.b);
+    } else {
+      internalKeys.add(key);
+      internalSegments.push(segment);
+    }
+  }
+  return { boundaryKeys, internalKeys, boundarySegments, internalSegments, boundaryLength };
+}
+
+function modelDiagonal(polygons) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (const polygon of polygons) {
+    for (const [x, y, z] of polygon.vertices) {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      minZ = Math.min(minZ, z);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      maxZ = Math.max(maxZ, z);
+    }
+  }
+  return Number.isFinite(minX) ? Math.hypot(maxX - minX, maxY - minY, maxZ - minZ) : 0;
+}
+
+function segmentCell(segment, cellSize) {
+  return [
+    Math.floor(((segment.a[0] + segment.b[0]) / 2) / cellSize),
+    Math.floor(((segment.a[1] + segment.b[1]) / 2) / cellSize),
+    Math.floor(((segment.a[2] + segment.b[2]) / 2) / cellSize),
+  ];
+}
+
+function cellKey(x, y, z) {
+  return `${x},${y},${z}`;
+}
+
+function buildSegmentIndex(segments, tolerance) {
+  const cellSize = Math.max(tolerance * 2, 1e-6);
+  const cells = new Map();
+  for (const segment of segments) {
+    const [cx, cy, cz] = segmentCell(segment, cellSize);
+    const key = cellKey(cx, cy, cz);
+    const bucket = cells.get(key);
+    if (bucket) bucket.push(segment);
+    else cells.set(key, [segment]);
+  }
+  return { cellSize, cells };
+}
+
+function segmentEndpointGap(a, b) {
+  return Math.min(
+    Math.max(distanceVec(a.a, b.a), distanceVec(a.b, b.b)),
+    Math.max(distanceVec(a.a, b.b), distanceVec(a.b, b.a)),
+  );
+}
+
+function indexedInternalEdgeGap(segment, index, tolerance) {
+  const [cx, cy, cz] = segmentCell(segment, index.cellSize);
+  let best = null;
+  for (let dx = -1; dx <= 1; dx++) {
+    for (let dy = -1; dy <= 1; dy++) {
+      for (let dz = -1; dz <= 1; dz++) {
+        const bucket = index.cells.get(cellKey(cx + dx, cy + dy, cz + dz));
+        if (!bucket) continue;
+        for (const candidate of bucket) {
+          const gap = segmentEndpointGap(segment, candidate);
+          if (gap <= tolerance) best = best === null ? gap : Math.min(best, gap);
+        }
+      }
+    }
+  }
+  return best;
+}
+
+function crackTolerances(polygons, maxBoundaryDisplacement = 0.0725) {
+  const diagonal = modelDiagonal(polygons);
+  const baseTolerance = diagonal > 0 ? Math.min(0.08, Math.max(0.001, diagonal * 0.001)) : 0;
+  const tolerance = Math.max(baseTolerance, maxBoundaryDisplacement * 1.05);
+  const searchTolerance = Math.max(tolerance, baseTolerance * 2.6, maxBoundaryDisplacement * 2.6);
+  return { baseTolerance, tolerance, searchTolerance };
+}
+
+function crackMetrics(sourcePolygons, candidatePolygons, maxBoundaryDisplacement = 0.0725) {
+  const sourceEdges = collectEdgeStats(sourcePolygons);
+  const candidateEdges = collectEdgeStats(candidatePolygons);
+  const { baseTolerance, tolerance, searchTolerance } = crackTolerances(sourcePolygons, maxBoundaryDisplacement);
+  const index = buildSegmentIndex(sourceEdges.internalSegments, searchTolerance);
+  const metrics = {
+    maxGap: 0,
+    internalBoundaryLength: 0,
+    excessBoundaryLength: Math.max(0, candidateEdges.boundaryLength - sourceEdges.boundaryLength),
+    baseTolerance,
+    tolerance,
+    searchTolerance,
+    nearInternal: 0,
+    over04: 0,
+    over08: 0,
+    over12: 0,
+  };
+
+  for (const edge of candidateEdges.boundarySegments) {
+    const key = edgeKey(edge.a, edge.b);
+    if (sourceEdges.boundaryKeys.has(key)) continue;
+    if (sourceEdges.internalKeys.has(key)) {
+      metrics.nearInternal += 1;
+      metrics.internalBoundaryLength += distanceVec(edge.a, edge.b);
+      continue;
+    }
+    const gap = indexedInternalEdgeGap(edge, index, searchTolerance);
+    if (gap === null) continue;
+    metrics.nearInternal += 1;
+    metrics.maxGap = Math.max(metrics.maxGap, gap);
+    metrics.internalBoundaryLength += distanceVec(edge.a, edge.b);
+    if (gap > 0.04) metrics.over04 += 1;
+    if (gap > 0.08) metrics.over08 += 1;
+    if (gap > 0.12) metrics.over12 += 1;
+  }
+  return metrics;
+}
+
+function crackLimits(sourcePolygons, reference, maxBoundaryDisplacement = 0.0725) {
+  const { tolerance } = crackTolerances(sourcePolygons, maxBoundaryDisplacement);
+  const gapSlack = Math.max(tolerance * 0.1, 1e-6);
+  const referenceGapLimit = reference.maxGap + gapSlack;
+  const maxGap = tolerance <= 0.08
+    ? Math.max(referenceGapLimit, Math.min(tolerance * 0.75, 0.04))
+    : referenceGapLimit;
+  const lengthSlack = Math.max(tolerance * 2, reference.internalBoundaryLength * 0.15);
+  const excessSlack = Math.max(tolerance * 2, reference.excessBoundaryLength * 0.15);
+  return {
+    maxGap,
+    internalBoundaryLength: reference.internalBoundaryLength + lengthSlack,
+    excessBoundaryLength: reference.excessBoundaryLength + excessSlack,
+  };
+}
+
+function compactCrack(metrics, limits) {
+  const pass =
+    metrics.maxGap <= limits.maxGap &&
+    metrics.internalBoundaryLength <= limits.internalBoundaryLength &&
+    metrics.excessBoundaryLength <= limits.excessBoundaryLength;
+  const failureReasons = [];
+  if (metrics.maxGap > limits.maxGap) failureReasons.push("gap");
+  if (metrics.internalBoundaryLength > limits.internalBoundaryLength) failureReasons.push("internal");
+  if (metrics.excessBoundaryLength > limits.excessBoundaryLength) failureReasons.push("excess");
+  return {
+    pass,
+    failureReasons,
+    maxGap: Number(metrics.maxGap.toFixed(6)),
+    maxGapLimit: Number(limits.maxGap.toFixed(6)),
+    internalBoundaryLength: Number(metrics.internalBoundaryLength.toFixed(2)),
+    internalBoundaryLimit: Number(limits.internalBoundaryLength.toFixed(2)),
+    excessBoundaryLength: Number(metrics.excessBoundaryLength.toFixed(2)),
+    excessBoundaryLimit: Number(limits.excessBoundaryLength.toFixed(2)),
+    over04: metrics.over04,
+    over08: metrics.over08,
+    over12: metrics.over12,
+    nearInternal: metrics.nearInternal,
+  };
+}
+
+function pctDrop(after, before) {
+  return before > 0 ? ((before - after) / before) * 100 : 0;
+}
+
+function timed(fn) {
+  const started = performance.now();
+  const value = fn();
+  return {
+    value,
+    ms: Number((performance.now() - started).toFixed(1)),
+  };
+}
+
+function shouldMeasureGroupCandidates(losslessStats) {
+  return losslessStats.count <= 800;
+}
+
+function summarizeCandidate(name, raw, losslessStats, referenceCracks, approximateMerge) {
+  const run = timed(() => optimizeMeshPolygons(raw, { meshResolution: "lossy", approximateMerge }));
+  const polygons = run.value;
+  const stats = polygonStats(polygons);
+  const metrics = crackMetrics(raw, polygons, approximateMerge.maxBoundaryDisplacement);
+  const limits = crackLimits(raw, referenceCracks, approximateMerge.maxBoundaryDisplacement);
+  return {
+    name,
+    count: stats.count,
+    cost: stats.cost,
+    ms: run.ms,
+    dropPct: Number(pctDrop(stats.cost, losslessStats.cost).toFixed(1)),
+    crack: compactCrack(metrics, limits),
+  };
+}
+
+async function summarizeModel(modelPath) {
+  const label = relative(sourceRoot, modelPath);
+  const started = performance.now();
+  const parseStarted = performance.now();
+  const parsed = await parseModel(modelPath);
+  const parseMs = Number((performance.now() - parseStarted).toFixed(1));
+  const raw = parsed.polygons;
+  const losslessRun = timed(() => optimizeMeshPolygons(raw, { meshResolution: "lossless" }));
+  const currentRun = timed(() => optimizeMeshPolygons(raw, { meshResolution: "lossy" }));
+  const lossless = losslessRun.value;
+  const current = currentRun.value;
+  const rawStats = polygonStats(raw);
+  const losslessStats = polygonStats(lossless);
+  const currentStats = polygonStats(current);
+  if (QUICK_MODE) {
+    const currentDropPct = pctDrop(currentStats.cost, losslessStats.cost);
+    return {
+      model: label,
+      ext: extname(modelPath).slice(1).toLowerCase(),
+      raw: rawStats,
+      lossless: losslessStats,
+      noApprox: null,
+      current: currentStats,
+      currentDropPct: Number(currentDropPct.toFixed(1)),
+      forced: [],
+      sweep: null,
+      bestForced: null,
+      bestPassingForced: null,
+      classification: currentStats.cost < losslessStats.cost
+        ? "auto-gain"
+        : "no-observed-geometry-potential",
+      animated: null,
+      timings: {
+        parseMs,
+        losslessMs: losslessRun.ms,
+        noApproxMs: 0,
+        currentMs: currentRun.ms,
+        forcedMs: 0,
+        sweepMs: 0,
+        animatedMs: 0,
+        totalMs: Number((performance.now() - started).toFixed(1)),
+      },
+    };
+  }
+
+  const noApproxRun = timed(() => optimizeMeshPolygons(raw, { meshResolution: "lossy", approximateMerge: false }));
+  const noApprox = noApproxRun.value;
+  const noApproxStats = polygonStats(noApprox);
+  const referenceCracks = crackMetrics(raw, noApprox);
+
+  const forced = [];
+  let forcedMs = 0;
+  for (const [name, approximateMerge] of FORCED_OPTIONS) {
+    if (name.startsWith("group") && !shouldMeasureGroupCandidates(losslessStats)) continue;
+    const candidate = summarizeCandidate(name, raw, losslessStats, referenceCracks, approximateMerge);
+    forcedMs += candidate.ms;
+    forced.push(candidate);
+  }
+  forced.sort((a, b) => a.cost - b.cost || a.count - b.count);
+
+  let sweep = null;
+  let sweepMs = 0;
+  if (INCLUDE_SWEEP) {
+    const seen = new Set(FORCED_OPTIONS.map(([, options]) => candidateKey(options)));
+    sweep = [];
+    for (const [name, approximateMerge] of sweepOptions(losslessStats)) {
+      const key = candidateKey(approximateMerge);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const candidate = summarizeCandidate(name, raw, losslessStats, referenceCracks, approximateMerge);
+      sweepMs += candidate.ms;
+      sweep.push(candidate);
+    }
+    sweep.sort((a, b) => a.cost - b.cost || a.count - b.count || a.ms - b.ms);
+  }
+
+  let animated = null;
+  let animatedMs = 0;
+  if (parsed.animation?.clips?.length) {
+    const run = timed(() => optimizeAnimatedMeshPolygons(parsed, { meshResolution: "lossy" }));
+    animatedMs = run.ms;
+    const optimized = run.value;
+    const stats = polygonStats(optimized.polygons);
+    animated = {
+      clips: parsed.animation.clips.length,
+      count: stats.count,
+      dropPct: Number(pctDrop(stats.cost, rawStats.cost).toFixed(1)),
+    };
+  }
+
+  const bestForced = forced[0] ?? null;
+  const bestPassingForced = forced.find((candidate) => candidate.crack.pass) ?? null;
+  const currentDropPct = pctDrop(currentStats.cost, losslessStats.cost);
+  const classification =
+    currentStats.cost >= losslessStats.cost && bestForced && bestForced.cost < losslessStats.cost
+      ? "blocked-no-auto-gain"
+      : bestForced && currentStats.cost < losslessStats.cost && bestForced.cost < currentStats.cost - Math.max(1, currentStats.cost * 0.05)
+        ? "auto-gain-but-forced-potential"
+        : currentStats.cost < losslessStats.cost
+          ? "auto-gain"
+          : "no-observed-geometry-potential";
+
+  return {
+    model: label,
+    ext: extname(modelPath).slice(1).toLowerCase(),
+    raw: rawStats,
+    lossless: losslessStats,
+    noApprox: noApproxStats,
+    current: currentStats,
+    currentDropPct: Number(currentDropPct.toFixed(1)),
+    forced,
+    sweep,
+    bestForced,
+    bestPassingForced,
+    classification,
+    animated,
+    timings: {
+      parseMs,
+      losslessMs: losslessRun.ms,
+      noApproxMs: noApproxRun.ms,
+      currentMs: currentRun.ms,
+      forcedMs: Number(forcedMs.toFixed(1)),
+      sweepMs: Number(sweepMs.toFixed(1)),
+      animatedMs,
+      totalMs: Number((performance.now() - started).toFixed(1)),
+    },
+  };
+}
+
+async function summarizeSingleModelAndExit() {
+  const singleModelPath = optStr("single-model");
+  if (!singleModelPath) return false;
+  const row = await summarizeModel(resolve(repoRoot, singleModelPath));
+  process.stdout.write(`${JSON.stringify(row)}\n`);
+  return true;
+}
+
+function summarizeModelInWorker(modelPath) {
+  if (MODEL_TIMEOUT_MS <= 0) return null;
+  const args = [
+    fileURLToPath(import.meta.url),
+    "--single-model",
+    modelPath,
+  ];
+  if (optStr("root")) args.push("--root", sourceRoot);
+  if (QUICK_MODE) args.push("--quick");
+  if (INCLUDE_SWEEP) args.push("--sweep");
+
+  const result = spawnSync(process.execPath, args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: MODEL_TIMEOUT_MS,
+  });
+
+  if (result.error) {
+    if (result.error.code === "ETIMEDOUT") {
+      throw new Error(`timeout after ${MODEL_TIMEOUT_MS}ms`);
+    }
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const message = (result.stderr || result.stdout || `worker exited with status ${result.status}`).trim();
+    throw new Error(message);
+  }
+  return JSON.parse(result.stdout);
+}
+
+function summarizeRows(rows, errors, elapsedMs) {
+  const byClass = {};
+  for (const row of rows) byClass[row.classification] = (byClass[row.classification] ?? 0) + 1;
+  const total = (field) => rows.reduce((sum, row) => sum + row[field].count, 0);
+  return {
+    scanned: rows.length,
+    errors: errors.length,
+    elapsedMs: Number(elapsedMs.toFixed(1)),
+    byClass,
+    aggregate: {
+      raw: total("raw"),
+      lossless: total("lossless"),
+      current: total("current"),
+      bestForced: rows.reduce((sum, row) => sum + (row.bestForced?.count ?? row.current.count), 0),
+    },
+    blocked: rows
+      .filter((row) => row.classification === "blocked-no-auto-gain")
+      .sort((a, b) => (b.bestForced?.dropPct ?? 0) - (a.bestForced?.dropPct ?? 0))
+      .map((row) => ({
+        model: row.model,
+        lossless: row.lossless.count,
+        current: row.current.count,
+        bestForced: row.bestForced?.count,
+        forcedDropPct: row.bestForced?.dropPct,
+        crack: row.bestForced?.crack,
+      })),
+    forcedPotentialTop: rows
+      .filter((row) => row.classification === "auto-gain-but-forced-potential")
+      .sort((a, b) =>
+        ((b.bestForced?.dropPct ?? 0) - b.currentDropPct) -
+        ((a.bestForced?.dropPct ?? 0) - a.currentDropPct)
+      )
+      .slice(0, 20)
+      .map((row) => ({
+        model: row.model,
+        lossless: row.lossless.count,
+        current: row.current.count,
+        currentDropPct: row.currentDropPct,
+        bestForced: row.bestForced?.count,
+        forcedDropPct: row.bestForced?.dropPct,
+        crack: row.bestForced?.crack,
+      })),
+  };
+}
+
+function readCorpusJson(path) {
+  return JSON.parse(readFileSync(resolve(repoRoot, path), "utf8"));
+}
+
+function totalCost(rows, field) {
+  return Number(rows.reduce((sum, row) => sum + row[field].cost, 0).toFixed(2));
+}
+
+function totalTiming(rows, field) {
+  return Number(rows.reduce((sum, row) => sum + (row.timings?.[field] ?? 0), 0).toFixed(1));
+}
+
+function bestCandidate(row, field) {
+  const candidates = row[field] ?? [];
+  return candidates.length > 0 ? candidates[0] : null;
+}
+
+function printCorpusSummary(output) {
+  const { summary } = output;
+  console.log("lossy corpus benchmark");
+  console.log(`models=${summary.scanned} errors=${summary.errors} elapsedMs=${summary.elapsedMs}`);
+  console.log(`classes=${JSON.stringify(summary.byClass)}`);
+  console.log(`aggregate raw=${summary.aggregate.raw} lossless=${summary.aggregate.lossless} current=${summary.aggregate.current} forced=${summary.aggregate.bestForced}`);
+  if (output.rows?.length) {
+    console.log(`costs lossless=${totalCost(output.rows, "lossless")} current=${totalCost(output.rows, "current")}`);
+    if (output.rows.some((row) => row.timings)) {
+      console.log(`timings currentMs=${totalTiming(output.rows, "currentMs")} forcedMs=${totalTiming(output.rows, "forcedMs")} sweepMs=${totalTiming(output.rows, "sweepMs")}`);
+    }
+  }
+  const blocked = summary.blocked ?? [];
+  if (blocked.length === 0) return;
+  console.log("");
+  console.log("blocked no-auto-gain candidates");
+  for (const row of blocked) {
+    console.log(`${row.model}: lossless=${row.lossless} current=${row.current} forced=${row.bestForced} maxGap=${row.crack?.maxGap}/${row.crack?.maxGapLimit}`);
+  }
+}
+
+function opportunityRows(output, candidateField) {
+  return output.rows
+    .map((row) => {
+      const candidate = bestCandidate(row, candidateField);
+      const delta = candidate ? row.current.cost - candidate.cost : 0;
+      return { row, candidate, delta };
+    })
+    .filter((item) => item.candidate && item.delta > 1)
+    .sort((a, b) => b.delta - a.delta);
+}
+
+function failureReasonCounts(output) {
+  const counts = new Map();
+  for (const row of output.rows) {
+    for (const candidate of [...(row.forced ?? []), ...(row.sweep ?? [])]) {
+      if (candidate.crack.pass) continue;
+      const key = candidate.crack.failureReasons.join("+") || "unknown";
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]);
+}
+
+function printOpportunityReport(output, limit = PRINT_LIMIT) {
+  console.log("");
+  console.log("opportunity report");
+  const forced = opportunityRows(output, "forced");
+  const sweep = opportunityRows(output, "sweep");
+  const printRows = (title, rows) => {
+    if (rows.length === 0) return;
+    console.log("");
+    console.log(title);
+    for (const item of rows.slice(0, limit)) {
+      const { row, candidate, delta } = item;
+      console.log(`${row.model}: current=${row.current.cost} candidate=${candidate.cost} delta=${Number(delta.toFixed(2))} ${candidate.name} pass=${candidate.crack.pass} fail=${candidate.crack.failureReasons.join("+") || "-"}`);
+    }
+  };
+  printRows("forced potential", forced);
+  printRows("sweep potential", sweep);
+
+  const timingRows = [...output.rows]
+    .filter((row) => row.timings)
+    .sort((a, b) => (b.timings.currentMs ?? 0) - (a.timings.currentMs ?? 0));
+  if (timingRows.length > 0) {
+    console.log("");
+    console.log("slow current optimizer rows");
+    for (const row of timingRows.slice(0, limit)) {
+      console.log(`${row.model}: currentMs=${row.timings.currentMs} current=${row.current.count} lossless=${row.lossless.count}`);
+    }
+  }
+
+  const reasons = failureReasonCounts(output);
+  if (reasons.length > 0) {
+    console.log("");
+    console.log(`failed candidate reasons ${JSON.stringify(Object.fromEntries(reasons))}`);
+  }
+}
+
+function printCompareReport(current, baseline, limit = PRINT_LIMIT) {
+  const baselineRows = new Map(baseline.rows.map((row) => [row.model, row]));
+  const deltas = [];
+  for (const row of current.rows) {
+    const before = baselineRows.get(row.model);
+    if (!before) continue;
+    deltas.push({
+      model: row.model,
+      currentCostDelta: Number((row.current.cost - before.current.cost).toFixed(2)),
+      currentCountDelta: row.current.count - before.current.count,
+      currentMsDelta: row.timings?.currentMs !== undefined && before.timings?.currentMs !== undefined
+        ? Number((row.timings.currentMs - before.timings.currentMs).toFixed(1))
+        : null,
+      beforeClass: before.classification,
+      afterClass: row.classification,
+      beforeCost: before.current.cost,
+      afterCost: row.current.cost,
+    });
+  }
+  const totalCostDelta = Number(deltas.reduce((sum, row) => sum + row.currentCostDelta, 0).toFixed(2));
+  const totalCountDelta = deltas.reduce((sum, row) => sum + row.currentCountDelta, 0);
+  const timingDeltas = deltas.filter((row) => row.currentMsDelta !== null);
+  const totalMsDelta = Number(timingDeltas.reduce((sum, row) => sum + row.currentMsDelta, 0).toFixed(1));
+  console.log("");
+  console.log("compare report");
+  console.log(`matched=${deltas.length} currentCostDelta=${totalCostDelta} currentCountDelta=${totalCountDelta} currentMsDelta=${timingDeltas.length > 0 ? totalMsDelta : "n/a"}`);
+
+  const improved = [...deltas].filter((row) => row.currentCostDelta < 0).sort((a, b) => a.currentCostDelta - b.currentCostDelta);
+  const regressed = [...deltas].filter((row) => row.currentCostDelta > 0).sort((a, b) => b.currentCostDelta - a.currentCostDelta);
+  const slower = [...timingDeltas].filter((row) => row.currentMsDelta > 0).sort((a, b) => b.currentMsDelta - a.currentMsDelta);
+  const classChanges = deltas.filter((row) => row.beforeClass !== row.afterClass);
+  const printRows = (title, rows, format) => {
+    if (rows.length === 0) return;
+    console.log("");
+    console.log(title);
+    for (const row of rows.slice(0, limit)) console.log(format(row));
+  };
+  printRows("largest improvements", improved, (row) =>
+    `${row.model}: ${row.beforeCost}->${row.afterCost} delta=${row.currentCostDelta}`
+  );
+  printRows("largest regressions", regressed, (row) =>
+    `${row.model}: ${row.beforeCost}->${row.afterCost} delta=+${row.currentCostDelta}`
+  );
+  printRows("largest currentMs increases", slower, (row) =>
+    `${row.model}: currentMsDelta=+${row.currentMsDelta} costDelta=${row.currentCostDelta}`
+  );
+  printRows("classification changes", classChanges, (row) =>
+    `${row.model}: ${row.beforeClass}->${row.afterClass} costDelta=${row.currentCostDelta}`
+  );
+}
+
+async function runCorpus() {
+  const started = performance.now();
+  const rows = [];
+  const errors = [];
+  const files = selectedFiles();
+  let scanned = 0;
+  for (const file of files) {
+    scanned += 1;
+    try {
+      rows.push(summarizeModelInWorker(file) ?? await summarizeModel(file));
+    } catch (error) {
+      errors.push({
+        model: relative(sourceRoot, file),
+        error: error instanceof Error ? error.message : String(error),
+        ...(error instanceof Error && /^timeout after \d+ms$/.test(error.message)
+          ? { timeoutMs: MODEL_TIMEOUT_MS }
+          : {}),
+      });
+    }
+    if (PROGRESS_EVERY > 0 && (scanned % PROGRESS_EVERY === 0 || scanned === files.length)) {
+      const elapsedMs = Number((performance.now() - started).toFixed(1));
+      console.error(`lossy-corpus progress ${scanned}/${files.length} rows=${rows.length} errors=${errors.length} elapsedMs=${elapsedMs}`);
+    }
+  }
+
+  return {
+    summary: summarizeRows(rows, errors, performance.now() - started),
+    rows,
+    errors,
+    options: {
+      sweep: INCLUDE_SWEEP,
+      quick: QUICK_MODE,
+      models: optStr("models").trim() || null,
+      root: optStr("root") ? sourceRoot : null,
+      fileOffset: FILE_OFFSET,
+      fileLimit: FILE_LIMIT || null,
+      timeoutMs: MODEL_TIMEOUT_MS || null,
+    },
+  };
+}
+
+const fromJson = optStr("from-json");
+if (await summarizeSingleModelAndExit()) process.exit(0);
+const output = fromJson ? readCorpusJson(fromJson) : await runCorpus();
+
+printCorpusSummary(output);
+if (hasFlag("opportunities")) printOpportunityReport(output);
+
+const comparePath = optStr("compare");
+if (comparePath) printCompareReport(output, readCorpusJson(comparePath));
+
+const jsonPath = optStr("json");
+if (jsonPath && !fromJson) {
+  const outputPath = resolve(repoRoot, jsonPath);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, `${JSON.stringify(output, null, 2)}\n`);
+  console.log(`wrote ${jsonPath}`);
+}
diff --git a/bench/nonvoxel-drag-trace.mjs b/bench/nonvoxel-drag-trace.mjs
index 82e87668..912c6989 100644
--- a/bench/nonvoxel-drag-trace.mjs
+++ b/bench/nonvoxel-drag-trace.mjs
@@ -20,6 +20,7 @@ import { dirname, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium } from "playwright";
 import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
+import { getNonVoxelVariantParams, knownNonVoxelVariantIds } from "./nonvoxel-variants.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
@@ -88,27 +89,9 @@ if (!Number.isFinite(DEGREES) || DEGREES === 0) {
   throw new Error("--degrees must be a non-zero number");
 }
 
-const VARIANT_PARAMS = {
-  baseline: {},
-  "css-keyframes": { rotationDriver: "css-keyframes" },
-  "order-depth": { domOrder: "initial-depth" },
-  "order-tile4": { domOrder: "tile4-screen" },
-  "order-area": { domOrder: "area-desc" },
-  "no-border-shape": { disableStrategies: "i" },
-  "no-stable-tri": { disableStrategies: "u" },
-  "force-atlas": { disableStrategies: "b,i,u" },
-  "no-will-change": { sceneTransformMode: "no-will-change" },
-  "leaf-buckets-64": { leafBucketSize: "64" },
-  "leaf-buckets-128": { leafBucketSize: "128" },
-  "leaf-buckets-256": { leafBucketSize: "256" },
-  "scene-matrix3d": { sceneTransformMode: "matrix3d" },
-  "scene-split-target": { sceneTransformMode: "split-target" },
-  "scene-host-perspective": { sceneTransformMode: "host-perspective" },
-  "scene-transform-perspective": { sceneTransformMode: "transform-perspective" },
-};
-
-if (!VARIANT_PARAMS[VARIANT]) {
-  throw new Error(`Unknown --variant "${VARIANT}". Known: ${Object.keys(VARIANT_PARAMS).join(", ")}`);
+const VARIANT_PARAMS = getNonVoxelVariantParams(VARIANT);
+if (!VARIANT_PARAMS) {
+  throw new Error(`Unknown --variant "${VARIANT}". Known: ${knownNonVoxelVariantIds().join(", ")}`);
 }
 
 const MIME = {
@@ -242,7 +225,7 @@ function urlFor(port) {
     mode: MODE,
     motion: "drag",
     ...(FRAME_DETAILS ? { frameWork: "1" } : {}),
-    ...VARIANT_PARAMS[VARIANT],
+    ...VARIANT_PARAMS,
   });
   return `http://127.0.0.1:${port}/nonvoxel-vanilla.html?${params.toString()}`;
 }
diff --git a/bench/nonvoxel-frame-buckets.mjs b/bench/nonvoxel-frame-buckets.mjs
deleted file mode 100644
index 622ed513..00000000
--- a/bench/nonvoxel-frame-buckets.mjs
+++ /dev/null
@@ -1,626 +0,0 @@
-#!/usr/bin/env node
-/**
- * Trace/rAF bucket profiler for non-voxel rotation experiments.
- *
- * This is intentionally separate from trace-frame-buckets.mjs because that
- * script samples voxel direct-renderer DOM. Here we sample the real polycss
- * leaf tag mix (`b/i/s/u/q`) so slow frame buckets can be compared against the
- * strategy mix emitted by normal GLB/OBJ rendering.
- *
- * Usage:
- *   node bench/nonvoxel-frame-buckets.mjs --mesh glb:Elephant.glb --variant order-tile4
- *   node bench/nonvoxel-frame-buckets.mjs --mesh glb:Elephant.glb --variant order-tile4 --no-trace
- *   node bench/nonvoxel-frame-buckets.mjs --mesh glb:Elephant.glb --variant order-tile4 --dom-samples
- *   node bench/nonvoxel-frame-buckets.mjs --mesh teapot --variant force-atlas --label nv-teapot-atlas
- */
-import { createServer } from "node:http";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { chromium } from "playwright";
-import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, "..");
-const benchDir = resolve(repoRoot, "bench");
-const galleryDir = resolve(repoRoot, "website/public/gallery");
-
-const argv = process.argv.slice(2);
-const flag = (name) => argv.indexOf(`--${name}`);
-const optStr = (name, dflt = "") => {
-  const i = flag(name);
-  if (i >= 0) return argv[i + 1] ?? dflt;
-  const prefixed = argv.find((arg) => arg.startsWith(`--${name}=`));
-  return prefixed ? prefixed.slice(name.length + 3) : dflt;
-};
-const optNum = (name, dflt) => {
-  const raw = optStr(name);
-  if (raw.trim() === "") return dflt;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : dflt;
-};
-const optAll = (name) => {
-  const values = [];
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === `--${name}` && argv[i + 1]) {
-      values.push(argv[i + 1]);
-      i += 1;
-    } else if (arg.startsWith(`--${name}=`)) {
-      values.push(arg.slice(name.length + 3));
-    }
-  }
-  return values;
-};
-const hasFlag = (name) => flag(name) >= 0 || argv.includes(`--${name}=true`);
-
-const MESH = optStr("mesh", "glb:Elephant.glb");
-const MODE = optStr("mode", "baked");
-const MOTION = optStr("motion", "rot");
-const VARIANT = optStr("variant", "baseline");
-const WARMUP_MS = optNum("warmup", 2000);
-const SAMPLE_MS = optNum("sample", 5000);
-const RUNS = Math.max(1, optNum("runs", 1));
-const LABEL = optStr("label");
-const HEADED = hasFlag("headed");
-const JSON_ONLY = hasFlag("json");
-const TRACE = !hasFlag("no-trace");
-const DOM_SAMPLES = hasFlag("dom-samples");
-const BROWSER_EXECUTABLE = optStr("browser-executable");
-const SOFTWARE_BACKEND = hasFlag("software-backend");
-const CHROMIUM_ARGS = chromiumArgsWithGpuDefault([
-  ...optAll("chromium-arg"),
-  ...optAll("chromium-args").flatMap((value) => value.split(/\s+/).filter(Boolean)),
-], { softwareBackend: SOFTWARE_BACKEND });
-
-const VARIANT_PARAMS = {
-  baseline: {},
-  "css-keyframes": { rotationDriver: "css-keyframes" },
-  "order-depth": { domOrder: "initial-depth" },
-  "order-tile4": { domOrder: "tile4-screen" },
-  "order-area": { domOrder: "area-desc" },
-  "no-border-shape": { disableStrategies: "i" },
-  "no-stable-tri": { disableStrategies: "u" },
-  "force-atlas": { disableStrategies: "b,i,u" },
-  "no-will-change": { sceneTransformMode: "no-will-change" },
-  "leaf-buckets-64": { leafBucketSize: "64" },
-  "leaf-buckets-128": { leafBucketSize: "128" },
-  "leaf-buckets-256": { leafBucketSize: "256" },
-  "scene-matrix3d": { sceneTransformMode: "matrix3d" },
-  "scene-split-target": { sceneTransformMode: "split-target" },
-  "scene-host-perspective": { sceneTransformMode: "host-perspective" },
-  "scene-transform-perspective": { sceneTransformMode: "transform-perspective" },
-};
-
-const MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".obj": "text/plain; charset=utf-8",
-  ".mtl": "text/plain; charset=utf-8",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gltf": "application/json; charset=utf-8",
-  ".glb": "model/gltf-binary",
-  ".vox": "application/octet-stream",
-};
-
-const TRACE_CATEGORIES = [
-  "devtools.timeline",
-  "disabled-by-default-devtools.timeline",
-  "blink",
-  "blink.user_timing",
-  "cc",
-  "gpu",
-  "viz",
-  "renderer.scheduler",
-].join(",");
-
-const EVENT_GROUPS = {
-  style: ["UpdateLayoutTree", "RecalculateStyles"],
-  layout: ["Layout"],
-  prePaint: ["PrePaint"],
-  paint: ["Paint"],
-  raster: ["RasterTask", "ImageDecodeTask", "Decode Image"],
-  script: ["FunctionCall", "EvaluateScript", "EventDispatch", "TimerFire", "FireAnimationFrame"],
-  compositorMain: [
-    "ProxyMain::BeginMainFrame",
-    "WebFrameWidgetImpl::UpdateLifecycle",
-    "PaintArtifactCompositor::Update",
-    "Layerize",
-    "Commit",
-    "ProxyImpl::ReadyToCommit",
-  ],
-  compositorImpl: [
-    "LayerTreeImpl::UpdateDrawProperties",
-    "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
-    "draw_property_utils::ComputeDrawPropertiesOfVisibleLayers",
-    "LayerTreeHostImpl::PrepareToDraw",
-    "MainFrame.Draw",
-    "SubmitCompositorFrame",
-  ],
-};
-
-const KEY_EVENTS = [
-  "FireAnimationFrame",
-  "FunctionCall",
-  "UpdateLayoutTree",
-  "PrePaint",
-  "PaintArtifactCompositor::Update",
-  "Layerize",
-  "LayerTreeImpl::UpdateDrawProperties",
-  "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
-  "draw_property_utils::ComputeDrawPropertiesOfVisibleLayers",
-  "LayerTreeHostImpl::PrepareToDraw",
-  "MainFrame.Draw",
-  "SubmitCompositorFrame",
-  "RasterTask",
-];
-
-function startServer() {
-  return new Promise((resolveStart, rejectStart) => {
-    const server = createServer(async (req, res) => {
-      try {
-        const u = new URL(req.url, "http://localhost");
-        const safe = u.pathname.replace(/\/+/g, "/");
-        if (safe.includes("..")) {
-          res.writeHead(403);
-          res.end();
-          return;
-        }
-        const abs = safe.startsWith("/gallery/")
-          ? resolve(galleryDir, safe.slice("/gallery/".length))
-          : resolve(benchDir, safe === "/" ? "nonvoxel-vanilla.html" : safe.slice(1));
-        const data = await readFile(abs);
-        res.writeHead(200, {
-          "Content-Type": MIME[extname(abs).toLowerCase()] || "application/octet-stream",
-          "Cache-Control": "no-store",
-        });
-        res.end(data);
-      } catch (error) {
-        res.writeHead(404);
-        res.end(String(error?.message ?? error));
-      }
-    });
-    server.on("error", rejectStart);
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolveStart({ server, port: typeof addr === "object" ? addr.port : 0 });
-    });
-  });
-}
-
-function stopServer(server) {
-  return new Promise((resolveStop) => server.close(resolveStop));
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 2) {
-  return Number.isFinite(value) ? Number(value).toFixed(digits) : "";
-}
-
-function bucketName(dt, baseFrameMs) {
-  const ratio = Math.max(1, Math.round(dt / baseFrameMs));
-  return ratio >= 4 ? "x4_plus" : `x${ratio}`;
-}
-
-function estimateBaseFrameMs(dts) {
-  const p10 = quantile(dts, 0.1) ?? 16.667;
-  return p10 < 12 ? 8.333 : 16.667;
-}
-
-function summarizeFrameTimes(frames) {
-  const dts = frames.map((frame) => frame.dt);
-  const p50 = median(dts) ?? 0;
-  const p95 = quantile(dts, 0.95) ?? 0;
-  const p99 = quantile(dts, 0.99) ?? 0;
-  return {
-    count: frames.length,
-    fps_p50: p50 > 0 ? +(1000 / p50).toFixed(2) : 0,
-    fps_p95: p95 > 0 ? +(1000 / p95).toFixed(2) : 0,
-    frame_time_p50_ms: +p50.toFixed(3),
-    frame_time_p95_ms: +p95.toFixed(3),
-    frame_time_p99_ms: +p99.toFixed(3),
-  };
-}
-
-function findTraceMark(events, name) {
-  return events.find((event) => event?.name === name && Number.isFinite(event?.args?.data?.startTime)) ??
-    events.find((event) => event?.name === "TimeStamp" && event?.args?.data?.message === name);
-}
-
-function makeFrames(samples, startPerfNow, endPerfNow) {
-  const frames = samples
-    .filter((sample) => Number.isFinite(sample?.dt) && sample.dt > 0 && sample.dt < 2000)
-    .filter((sample) => sample.t - sample.dt >= startPerfNow && sample.t <= endPerfNow)
-    .map((sample, index) => ({
-      index,
-      start: sample.t - sample.dt,
-      end: sample.t,
-      dt: sample.dt,
-    }));
-  const baseFrameMs = estimateBaseFrameMs(frames.map((frame) => frame.dt));
-  for (const frame of frames) frame.bucket = bucketName(frame.dt, baseFrameMs);
-  return { frames, baseFrameMs };
-}
-
-function attachDomSamples(frames, domSamples) {
-  if (!Array.isArray(domSamples) || domSamples.length === 0) return;
-  let sampleIndex = 0;
-  for (const frame of frames) {
-    while (sampleIndex + 1 < domSamples.length && domSamples[sampleIndex + 1].t <= frame.end) {
-      sampleIndex += 1;
-    }
-    const sample = domSamples[sampleIndex];
-    if (sample && sample.t >= frame.start - 1 && sample.t <= frame.end + 1) {
-      frame.tags = sample.tags;
-      frame.leafCount = sample.leafCount;
-      frame.bucketCount = sample.bucketCount;
-      frame.inlineStyleChars = sample.inlineStyleChars;
-    }
-  }
-}
-
-function frameIndexAt(frames, perfNow) {
-  let lo = 0;
-  let hi = frames.length - 1;
-  while (lo <= hi) {
-    const mid = (lo + hi) >> 1;
-    const frame = frames[mid];
-    if (perfNow < frame.start) hi = mid - 1;
-    else if (perfNow > frame.end) lo = mid + 1;
-    else return mid;
-  }
-  return -1;
-}
-
-function emptyBucket(bucket) {
-  return {
-    bucket,
-    frameCount: 0,
-    frame_time_p50_ms: null,
-    frame_time_p95_ms: null,
-    leafCount_p50: null,
-    bucketCount_p50: null,
-    tags_p50: { b: null, i: null, s: null, u: null, q: null },
-    inlineStyleChars_p50: null,
-    groups_ms_per_frame: {},
-    events_ms_per_frame: {},
-    topEvents: [],
-  };
-}
-
-function addDuration(map, name, durationMs) {
-  const entry = map.get(name) ?? { count: 0, duration_ms: 0 };
-  entry.count += 1;
-  entry.duration_ms += durationMs;
-  map.set(name, entry);
-}
-
-function summarizeBuckets(events, frames, tracePerfOffsetMs, renderStats) {
-  const fallbackTags = renderStats?.dom?.tags ?? null;
-  const fallbackLeafCount = renderStats?.dom?.leafCount ?? null;
-  const fallbackBucketCount = renderStats?.dom?.buckets ?? null;
-  const fallbackInlineStyleChars = renderStats?.dom?.inlineStyleChars ?? null;
-  const buckets = new Map();
-  for (const frame of frames) {
-    const bucket = buckets.get(frame.bucket) ?? {
-      ...emptyBucket(frame.bucket),
-      frameDts: [],
-      leafCounts: [],
-      bucketCounts: [],
-      inlineStyleChars: [],
-      tagCounts: { b: [], i: [], s: [], u: [], q: [] },
-      eventTotals: new Map(),
-      groupTotals: new Map(),
-    };
-    bucket.frameCount += 1;
-    bucket.frameDts.push(frame.dt);
-    if (Number.isFinite(frame.leafCount)) bucket.leafCounts.push(frame.leafCount);
-    if (Number.isFinite(frame.bucketCount)) bucket.bucketCounts.push(frame.bucketCount);
-    if (Number.isFinite(frame.inlineStyleChars)) bucket.inlineStyleChars.push(frame.inlineStyleChars);
-    for (const tag of ["b", "i", "s", "u", "q"]) {
-      if (Number.isFinite(frame.tags?.[tag])) bucket.tagCounts[tag].push(frame.tags[tag]);
-    }
-    buckets.set(frame.bucket, bucket);
-  }
-
-  const groupByEvent = new Map();
-  for (const [group, names] of Object.entries(EVENT_GROUPS)) {
-    for (const name of names) groupByEvent.set(name, group);
-  }
-
-  for (const event of events) {
-    if (event?.ph !== "X" || typeof event.dur !== "number" || !Number.isFinite(event.ts)) continue;
-    const durationMs = event.dur / 1000;
-    const midpointPerfNow = ((event.ts + event.dur / 2) / 1000) - tracePerfOffsetMs;
-    const index = frameIndexAt(frames, midpointPerfNow);
-    if (index < 0) continue;
-    const bucket = buckets.get(frames[index].bucket);
-    if (!bucket) continue;
-    addDuration(bucket.eventTotals, event.name, durationMs);
-    const group = groupByEvent.get(event.name);
-    if (group) addDuration(bucket.groupTotals, group, durationMs);
-  }
-
-  return ["x1", "x2", "x3", "x4_plus"].map((name) => {
-    const bucket = buckets.get(name);
-    if (!bucket) return emptyBucket(name);
-    const frameCount = bucket.frameCount || 1;
-    const events_ms_per_frame = {};
-    for (const event of KEY_EVENTS) {
-      events_ms_per_frame[event] = +((bucket.eventTotals.get(event)?.duration_ms ?? 0) / frameCount).toFixed(4);
-    }
-    const groups_ms_per_frame = {};
-    for (const group of Object.keys(EVENT_GROUPS)) {
-      groups_ms_per_frame[group] = +((bucket.groupTotals.get(group)?.duration_ms ?? 0) / frameCount).toFixed(4);
-    }
-    const tags_p50 = {};
-    for (const tag of ["b", "i", "s", "u", "q"]) {
-      tags_p50[tag] = bucket.tagCounts[tag].length ? +(median(bucket.tagCounts[tag]) ?? 0).toFixed(0) : null;
-    }
-    const topEvents = [...bucket.eventTotals.entries()]
-      .map(([event, total]) => ({
-        event,
-        count: total.count,
-        ms_per_frame: +(total.duration_ms / frameCount).toFixed(4),
-      }))
-      .sort((a, b) => b.ms_per_frame - a.ms_per_frame)
-      .slice(0, 12);
-    const out = {
-      bucket: name,
-      frameCount: bucket.frameCount,
-      frame_time_p50_ms: +(median(bucket.frameDts) ?? 0).toFixed(3),
-      frame_time_p95_ms: +(quantile(bucket.frameDts, 0.95) ?? 0).toFixed(3),
-      leafCount_p50: bucket.leafCounts.length ? +(median(bucket.leafCounts) ?? 0).toFixed(0) : fallbackLeafCount,
-      bucketCount_p50: bucket.bucketCounts.length ? +(median(bucket.bucketCounts) ?? 0).toFixed(0) : fallbackBucketCount,
-      tags_p50,
-      inlineStyleChars_p50: bucket.inlineStyleChars.length ? +(median(bucket.inlineStyleChars) ?? 0).toFixed(0) : fallbackInlineStyleChars,
-      groups_ms_per_frame,
-      events_ms_per_frame,
-      topEvents,
-    };
-    if (fallbackTags && Object.values(tags_p50).every((value) => value === null)) {
-      out.tags_p50 = fallbackTags;
-    }
-    return out;
-  });
-}
-
-async function startTrace(cdp) {
-  const events = [];
-  cdp.on("Tracing.dataCollected", (payload) => {
-    if (Array.isArray(payload.value)) events.push(...payload.value);
-  });
-  await cdp.send("Performance.enable");
-  await cdp.send("Tracing.start", {
-    transferMode: "ReportEvents",
-    categories: TRACE_CATEGORIES,
-  });
-  return events;
-}
-
-async function stopTrace(cdp) {
-  await new Promise(async (resolveStop) => {
-    cdp.once("Tracing.tracingComplete", resolveStop);
-    await cdp.send("Tracing.end");
-  });
-}
-
-function pageUrl(port) {
-  const params = new URLSearchParams({
-    mesh: MESH,
-    mode: MODE,
-    motion: MOTION,
-    ...VARIANT_PARAMS[VARIANT],
-  });
-  if (!VARIANT_PARAMS[VARIANT]) {
-    throw new Error(`Unknown --variant "${VARIANT}". Known: ${Object.keys(VARIANT_PARAMS).join(", ")}`);
-  }
-  return `http://127.0.0.1:${port}/nonvoxel-vanilla.html?${params.toString()}`;
-}
-
-async function runOnce(port, repeat) {
-  const launchOptions = { headless: !HEADED, args: CHROMIUM_ARGS };
-  if (BROWSER_EXECUTABLE) launchOptions.executablePath = BROWSER_EXECUTABLE;
-  const browser = await chromium.launch(launchOptions);
-  try {
-    const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
-    const page = await ctx.newPage();
-    const cdp = TRACE ? await ctx.newCDPSession(page) : null;
-    await page.goto(pageUrl(port), { waitUntil: "load" });
-    await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 30000 });
-    await page.waitForTimeout(WARMUP_MS);
-
-    const events = TRACE ? await startTrace(cdp) : [];
-    const startIdx = await page.evaluate(() => window.__perf__.samples.length);
-    const startPerfNow = await page.evaluate(({ traceEnabled, domSamples }) => {
-      if (domSamples) {
-        window.__polycssDomSamples = [];
-        window.__polycssDomSampling = true;
-        const sampleDom = (now) => {
-          const sceneRoot = document.querySelector(".polycss-scene");
-          const tags = { b: 0, i: 0, s: 0, u: 0, q: 0 };
-          let inlineStyleChars = 0;
-          if (sceneRoot) {
-            for (const tag of Object.keys(tags)) tags[tag] = sceneRoot.querySelectorAll(tag).length;
-            for (const el of sceneRoot.querySelectorAll("b,i,s,u,q")) {
-              inlineStyleChars += el.getAttribute("style")?.length ?? 0;
-            }
-          }
-          window.__polycssDomSamples.push({
-            t: now,
-            tags,
-            leafCount: tags.b + tags.i + tags.s + tags.u,
-            shadowCount: tags.q,
-            bucketCount: sceneRoot?.querySelectorAll(".polycss-bucket").length ?? 0,
-            inlineStyleChars,
-          });
-          if (window.__polycssDomSampling) requestAnimationFrame(sampleDom);
-        };
-        requestAnimationFrame(sampleDom);
-      } else {
-        window.__polycssDomSamples = [];
-        window.__polycssDomSampling = false;
-      }
-      if (traceEnabled) {
-        performance.mark("__polycss_nonvoxel_bucket_start__");
-        console.timeStamp("__polycss_nonvoxel_bucket_start__");
-      }
-      return performance.now();
-    }, { traceEnabled: TRACE, domSamples: DOM_SAMPLES });
-    await page.waitForTimeout(SAMPLE_MS);
-    const endPerfNow = await page.evaluate((traceEnabled) => {
-      if (traceEnabled) {
-        performance.mark("__polycss_nonvoxel_bucket_end__");
-        console.timeStamp("__polycss_nonvoxel_bucket_end__");
-      }
-      window.__polycssDomSampling = false;
-      return performance.now();
-    }, TRACE);
-    if (TRACE) await stopTrace(cdp);
-
-    const pageResult = await page.evaluate((from) => ({
-      samples: window.__perf__.samples.slice(from),
-      polyCount: window.__perf__.polyCount,
-      renderStats: window.__perf__.renderStats ?? null,
-      domSamples: window.__polycssDomSamples ?? [],
-    }), startIdx);
-    await ctx.close();
-
-    let tracePerfOffsetMs = 0;
-    let alignedStartPerfNow = startPerfNow;
-    let alignedEndPerfNow = endPerfNow;
-    if (TRACE) {
-      const startMark = findTraceMark(events, "__polycss_nonvoxel_bucket_start__");
-      const endMark = findTraceMark(events, "__polycss_nonvoxel_bucket_end__");
-      if (!startMark?.args?.data?.startTime || !endMark?.args?.data?.startTime) {
-        throw new Error("Trace markers were not captured; cannot align trace to rAF samples.");
-      }
-      tracePerfOffsetMs = (startMark.ts / 1000) - startMark.args.data.startTime;
-      alignedStartPerfNow = startMark.args.data.startTime;
-      alignedEndPerfNow = endMark.args.data.startTime;
-    }
-    const { frames, baseFrameMs } = makeFrames(pageResult.samples, alignedStartPerfNow, alignedEndPerfNow);
-    if (DOM_SAMPLES) attachDomSamples(frames, pageResult.domSamples);
-    const frameStats = summarizeFrameTimes(frames);
-    const buckets = summarizeBuckets(events, frames, tracePerfOffsetMs, pageResult.renderStats);
-
-    return {
-      repeat,
-      mesh: MESH,
-      variant: VARIANT,
-      mode: MODE,
-      motion: MOTION,
-      trace: TRACE,
-      domSamples: DOM_SAMPLES,
-      warmup_ms: WARMUP_MS,
-      sample_ms: SAMPLE_MS,
-      baseFrameMs: +baseFrameMs.toFixed(3),
-      ...frameStats,
-      polyCount: pageResult.polyCount,
-      renderStats: pageResult.renderStats,
-      buckets,
-    };
-  } finally {
-    await browser.close();
-  }
-}
-
-function tagText(tags) {
-  if (!tags) return "";
-  return `b/i/s/u/q=${tags.b ?? ""}/${tags.i ?? ""}/${tags.s ?? ""}/${tags.u ?? ""}/${tags.q ?? ""}`;
-}
-
-function printRun(run) {
-  const bucketText = run.buckets
-    .filter((bucket) => bucket.frameCount > 0)
-    .map((bucket) => `${bucket.bucket}:${bucket.frameCount}`)
-    .join(" ");
-  console.log(
-    `[nv-buckets] ${run.mesh} ${run.variant} r${run.repeat} p50=${fmt(run.fps_p50, 1)} p95=${fmt(run.fps_p95, 1)} p99=${fmt(run.frame_time_p99_ms, 1)}ms base=${fmt(run.baseFrameMs, 3)}ms ${bucketText}`,
-  );
-  console.log("| Bucket | Frames | Leaves | Tags p50 | dt p50 | dt p95 | style | prePaint | PAC | layerize | drawProps | visible | prepareDraw | draw | raster | script |");
-  console.log("| --- | ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-  for (const bucket of run.buckets) {
-    if (bucket.frameCount === 0) continue;
-    const e = bucket.events_ms_per_frame;
-    const g = bucket.groups_ms_per_frame;
-    console.log([
-      `| ${bucket.bucket}`,
-      bucket.frameCount,
-      bucket.leafCount_p50 ?? "",
-      tagText(bucket.tags_p50),
-      fmt(bucket.frame_time_p50_ms),
-      fmt(bucket.frame_time_p95_ms),
-      fmt(g.style, 4),
-      fmt(g.prePaint, 4),
-      fmt(e["PaintArtifactCompositor::Update"], 4),
-      fmt(e.Layerize, 4),
-      fmt(e["LayerTreeImpl::UpdateDrawProperties"], 4),
-      fmt(e["draw_property_utils::ComputeDrawPropertiesOfVisibleLayers"], 4),
-      fmt(e["LayerTreeHostImpl::PrepareToDraw"], 4),
-      fmt(e["MainFrame.Draw"], 4),
-      fmt(g.raster, 4),
-      `${fmt(g.script, 4)} |`,
-    ].join(" | "));
-  }
-}
-
-const { server, port } = await startServer();
-try {
-  if (!JSON_ONLY) {
-    console.log(`[nv-buckets] server :${port}`);
-    console.log(`[nv-buckets] mesh=${MESH} variant=${VARIANT} mode=${MODE} motion=${MOTION} trace=${TRACE ? "on" : "off"} domSamples=${DOM_SAMPLES ? "on" : "off"} runs=${RUNS} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms`);
-    if (SOFTWARE_BACKEND) console.log("[nv-buckets] software backend=on");
-    if (CHROMIUM_ARGS.length > 0) console.log(`[nv-buckets] chromium args=${CHROMIUM_ARGS.join(" ")}`);
-  }
-  const runs = [];
-  for (let repeat = 1; repeat <= RUNS; repeat += 1) {
-    const run = await runOnce(port, repeat);
-    runs.push(run);
-    if (!JSON_ONLY) printRun(run);
-  }
-  const out = {
-    kind: "nonvoxel-frame-buckets",
-    mesh: MESH,
-    variant: VARIANT,
-    mode: MODE,
-    motion: MOTION,
-    trace: TRACE,
-    domSamples: DOM_SAMPLES,
-    browserExecutable: BROWSER_EXECUTABLE || null,
-    chromiumArgs: CHROMIUM_ARGS,
-    softwareBackend: SOFTWARE_BACKEND,
-    warmup_ms: WARMUP_MS,
-    sample_ms: SAMPLE_MS,
-    runs,
-  };
-  if (LABEL) {
-    const dir = resolve(repoRoot, "bench/results");
-    mkdirSync(dir, { recursive: true });
-    const file = resolve(dir, `${LABEL}.json`);
-    writeFileSync(file, JSON.stringify(out, null, 2) + "\n");
-    if (!JSON_ONLY) console.log(`[nv-buckets] wrote ${file}`);
-  }
-  if (JSON_ONLY) console.log(JSON.stringify(out, null, 2));
-} finally {
-  await stopServer(server);
-}
diff --git a/bench/nonvoxel-rotation-bench.mjs b/bench/nonvoxel-rotation-bench.mjs
index cca0b75f..0c57c0fd 100644
--- a/bench/nonvoxel-rotation-bench.mjs
+++ b/bench/nonvoxel-rotation-bench.mjs
@@ -21,6 +21,7 @@ import { dirname, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium } from "playwright";
 import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
+import { NONVOXEL_VARIANTS } from "./nonvoxel-variants.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
@@ -126,104 +127,7 @@ const MODEL_CORPUS = [
   },
 ];
 
-const VARIANTS = [
-  {
-    id: "baseline",
-    label: "Baseline",
-    params: {},
-    hypothesis: "Current vanilla JS scene-root rotation.",
-  },
-  {
-    id: "css-keyframes",
-    label: "CSS Keyframes",
-    params: { rotationDriver: "css-keyframes" },
-    hypothesis: "Active declarative transform animation may skip PAC during auto-rotate.",
-  },
-  {
-    id: "order-depth",
-    label: "Initial Depth Order",
-    params: { domOrder: "initial-depth" },
-    hypothesis: "One-time depth locality may reduce compositor sort pressure.",
-  },
-  {
-    id: "order-tile4",
-    label: "Tile4 Screen Order",
-    params: { domOrder: "tile4-screen" },
-    hypothesis: "Voxel tile-order lesson may transfer to static non-voxel polygon order.",
-  },
-  {
-    id: "order-area",
-    label: "Area Desc Order",
-    params: { domOrder: "area-desc" },
-    hypothesis: "Large projected primitives grouped earlier may improve overlap cadence.",
-  },
-  {
-    id: "no-border-shape",
-    label: "No Border Shape",
-    params: { disableStrategies: "i" },
-    hypothesis: "Force irregular solids to atlas slices instead of border-shape leaves.",
-  },
-  {
-    id: "no-stable-tri",
-    label: "No Stable Triangles",
-    params: { disableStrategies: "u" },
-    hypothesis: "Avoid CSS border-triangle compositing for solid triangles.",
-  },
-  {
-    id: "force-atlas",
-    label: "Force Atlas",
-    params: { disableStrategies: "b,i,u" },
-    hypothesis: "Fewer CSS shape strategies may beat extra atlas memory for rotation.",
-  },
-  {
-    id: "no-will-change",
-    label: "No Scene Will-Change",
-    params: { sceneTransformMode: "no-will-change" },
-    hypothesis: "Confirm voxel result that root will-change is not the missing path.",
-  },
-  {
-    id: "leaf-buckets-64",
-    label: "Leaf Buckets 64",
-    params: { leafBucketSize: "64" },
-    hypothesis: "Wrap baked leaves into fixed-size preserve-3D subtrees without changing leaf order.",
-  },
-  {
-    id: "leaf-buckets-128",
-    label: "Leaf Buckets 128",
-    params: { leafBucketSize: "128" },
-    hypothesis: "Test a coarser fixed-size baked subtree shape.",
-  },
-  {
-    id: "leaf-buckets-256",
-    label: "Leaf Buckets 256",
-    params: { leafBucketSize: "256" },
-    hypothesis: "Test a low-wrapper baked subtree shape.",
-  },
-  {
-    id: "scene-matrix3d",
-    label: "Scene Matrix3d",
-    params: { sceneTransformMode: "matrix3d" },
-    hypothesis: "Use explicit matrix3d() on the scene root instead of transform functions.",
-  },
-  {
-    id: "scene-split-target",
-    label: "Split Target",
-    params: { sceneTransformMode: "split-target" },
-    hypothesis: "Split translate3d target compensation onto an inner shell.",
-  },
-  {
-    id: "scene-host-perspective",
-    label: "Host Perspective",
-    params: { sceneTransformMode: "host-perspective" },
-    hypothesis: "Move perspective off the scene root and onto the host.",
-  },
-  {
-    id: "scene-transform-perspective",
-    label: "Transform Perspective",
-    params: { sceneTransformMode: "transform-perspective" },
-    hypothesis: "Encode perspective in transform instead of the perspective property.",
-  },
-];
+const VARIANTS = NONVOXEL_VARIANTS;
 
 const RUN_ORDER_ALIASES = new Map([
   ["grouped", "grouped"],
diff --git a/bench/nonvoxel-vanilla.html b/bench/nonvoxel-vanilla.html
index bd886fae..27cc0fd8 100644
--- a/bench/nonvoxel-vanilla.html
+++ b/bench/nonvoxel-vanilla.html
@@ -9,7 +9,7 @@
   <div id="host"></div>
 
   <script type="module">
-    import { createPolyCamera, createPolyScene, createPolyOrbitControls, loadMesh } from "./polycss.js";
+    import { createPolyCamera, createPolyScene, createPolyOrbitControls, loadMesh } from "./.generated/polycss.js";
     import { getSynthMesh } from "./synth-mesh.mjs";
     import {
       parseUrlParams, dirFromAzEl, createPerfRecorder,
diff --git a/bench/nonvoxel-variants.mjs b/bench/nonvoxel-variants.mjs
new file mode 100644
index 00000000..a1764683
--- /dev/null
+++ b/bench/nonvoxel-variants.mjs
@@ -0,0 +1,110 @@
+export const NONVOXEL_VARIANTS = [
+  {
+    id: "baseline",
+    label: "Baseline",
+    params: {},
+    hypothesis: "Current vanilla JS scene-root rotation.",
+  },
+  {
+    id: "css-keyframes",
+    label: "CSS Keyframes",
+    params: { rotationDriver: "css-keyframes" },
+    hypothesis: "Active declarative transform animation may skip PAC during auto-rotate.",
+  },
+  {
+    id: "order-depth",
+    label: "Initial Depth Order",
+    params: { domOrder: "initial-depth" },
+    hypothesis: "One-time depth locality may reduce compositor sort pressure.",
+  },
+  {
+    id: "order-tile4",
+    label: "Tile4 Screen Order",
+    params: { domOrder: "tile4-screen" },
+    hypothesis: "Voxel tile-order lesson may transfer to static non-voxel polygon order.",
+  },
+  {
+    id: "order-area",
+    label: "Area Desc Order",
+    params: { domOrder: "area-desc" },
+    hypothesis: "Large projected primitives grouped earlier may improve overlap cadence.",
+  },
+  {
+    id: "no-border-shape",
+    label: "No Border Shape",
+    params: { disableStrategies: "i" },
+    hypothesis: "Force irregular solids to atlas slices instead of border-shape leaves.",
+  },
+  {
+    id: "no-stable-tri",
+    label: "No Stable Triangles",
+    params: { disableStrategies: "u" },
+    hypothesis: "Avoid CSS border-triangle compositing for solid triangles.",
+  },
+  {
+    id: "force-atlas",
+    label: "Force Atlas",
+    params: { disableStrategies: "b,i,u" },
+    hypothesis: "Fewer CSS shape strategies may beat extra atlas memory for rotation.",
+  },
+  {
+    id: "no-will-change",
+    label: "No Scene Will-Change",
+    params: { sceneTransformMode: "no-will-change" },
+    hypothesis: "Confirm voxel result that root will-change is not the missing path.",
+  },
+  {
+    id: "leaf-buckets-64",
+    label: "Leaf Buckets 64",
+    params: { leafBucketSize: "64" },
+    hypothesis: "Wrap baked leaves into fixed-size preserve-3D subtrees without changing leaf order.",
+  },
+  {
+    id: "leaf-buckets-128",
+    label: "Leaf Buckets 128",
+    params: { leafBucketSize: "128" },
+    hypothesis: "Test a coarser fixed-size baked subtree shape.",
+  },
+  {
+    id: "leaf-buckets-256",
+    label: "Leaf Buckets 256",
+    params: { leafBucketSize: "256" },
+    hypothesis: "Test a low-wrapper baked subtree shape.",
+  },
+  {
+    id: "scene-matrix3d",
+    label: "Scene Matrix3d",
+    params: { sceneTransformMode: "matrix3d" },
+    hypothesis: "Use explicit matrix3d() on the scene root instead of transform functions.",
+  },
+  {
+    id: "scene-split-target",
+    label: "Split Target",
+    params: { sceneTransformMode: "split-target" },
+    hypothesis: "Split translate3d target compensation onto an inner shell.",
+  },
+  {
+    id: "scene-host-perspective",
+    label: "Host Perspective",
+    params: { sceneTransformMode: "host-perspective" },
+    hypothesis: "Move perspective off the scene root and onto the host.",
+  },
+  {
+    id: "scene-transform-perspective",
+    label: "Transform Perspective",
+    params: { sceneTransformMode: "transform-perspective" },
+    hypothesis: "Encode perspective in transform instead of the perspective property.",
+  },
+];
+
+export function knownNonVoxelVariantIds() {
+  return NONVOXEL_VARIANTS.map((variant) => variant.id);
+}
+
+export function getNonVoxelVariant(id) {
+  return NONVOXEL_VARIANTS.find((variant) => variant.id === id);
+}
+
+export function getNonVoxelVariantParams(id) {
+  return getNonVoxelVariant(id)?.params;
+}
diff --git a/bench/nonvoxel-visual-compare.mjs b/bench/nonvoxel-visual-compare.mjs
index b8cf14b0..821ebc1c 100644
--- a/bench/nonvoxel-visual-compare.mjs
+++ b/bench/nonvoxel-visual-compare.mjs
@@ -12,6 +12,7 @@ import { readFile } from "node:fs/promises";
 import { dirname, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium } from "playwright";
+import { getNonVoxelVariantParams, knownNonVoxelVariantIds } from "./nonvoxel-variants.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
@@ -74,18 +75,6 @@ const MODELS = [
   { id: "policecar", mesh: "glb:Policecar.glb", params: { zoom: "0.35", targetSize: "60" } },
 ];
 
-const VARIANT_PARAMS = {
-  baseline: {},
-  "scene-matrix3d": { sceneTransformMode: "matrix3d" },
-  "scene-split-target": { sceneTransformMode: "split-target" },
-  "scene-host-perspective": { sceneTransformMode: "host-perspective" },
-  "scene-transform-perspective": { sceneTransformMode: "transform-perspective" },
-  "no-will-change": { sceneTransformMode: "no-will-change" },
-  "leaf-buckets-64": { leafBucketSize: "64" },
-  "leaf-buckets-128": { leafBucketSize: "128" },
-  "leaf-buckets-256": { leafBucketSize: "256" },
-};
-
 const MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -126,8 +115,8 @@ function selectedModels() {
 function selectedVariants() {
   const requested = splitList(optStr("variants", "scene-split-target,scene-transform-perspective"));
   return requested.map((id) => {
-    const params = VARIANT_PARAMS[id];
-    if (!params) throw new Error(`Unknown variant "${id}". Known: ${Object.keys(VARIANT_PARAMS).join(", ")}`);
+    const params = getNonVoxelVariantParams(id);
+    if (!params) throw new Error(`Unknown variant "${id}". Known: ${knownNonVoxelVariantIds().join(", ")}`);
     if (id === "baseline") throw new Error("Baseline is implicit; do not include it in --variants.");
     return { id, params };
   });
diff --git a/bench/README.md b/bench/notes/BENCH.md
similarity index 84%
rename from bench/README.md
rename to bench/notes/BENCH.md
index 1512046e..7c8f6375 100644
--- a/bench/README.md
+++ b/bench/notes/BENCH.md
@@ -18,13 +18,16 @@ pnpm bench:serve            # static server on :4400 with an index page
 pnpm bench:perf             # build bundles + run all 4 renderers × 5 scenarios
 pnpm bench:animated-human   # build bundles + run the animated human run bench
 pnpm bench:nonvoxel-drag-trace  # build bundles + trace a Playwright drag orbit on teapot
+pnpm bench:trace            # build bundles + run the trace analysis bucket profiler
 pnpm bench:lossy            # compare lossless / previous lossy / auto lossy counts
+pnpm bench:lossy:corpus     # scan gallery GLB/OBJ lossy counts + crack diagnostics
+pnpm bench:voxel-report     # summarize voxel cadence results
 pnpm bench:visual           # screenshot diff against bench/baselines/*.png
 pnpm bench:visual --record  # capture new baselines (after intentional renderer changes)
 pnpm bench:build            # just rebuild the bench bundles (rarely needed alone)
 node bench/nonvoxel-rotation-bench.mjs  # non-voxel vanilla rotation probe
 node bench/nonvoxel-drag-trace.mjs --label teapot-drag  # pointer-drag trace, no auto-rotate
-node bench/nonvoxel-frame-buckets.mjs --no-trace  # non-voxel rAF cadence buckets
+node bench/trace-analysis.mjs --page nonvoxel --no-trace  # non-voxel rAF cadence buckets
 node bench/nonvoxel-visual-compare.mjs  # non-voxel variant visual parity
 ```
 
@@ -38,10 +41,14 @@ node bench/animated-human-bench.mjs --compare-stable-dom --trace
 node bench/animated-human-bench.mjs --mesh poly-pizza/animated-robot.glb --clip run --animation-driver progressive-style-cache
 node bench/lossy-optimizer-bench.mjs --json bench/results/lossy-optimizer.json
 node bench/lossy-optimizer-bench.mjs --models ducky,shark,bicycle
+node bench/lossy-corpus-bench.mjs --root /tmp/polycss-model-corpus --json /tmp/polycss-temp-corpus.json
+node bench/lossy-corpus-bench.mjs --from-json bench/results/lossy-corpus.json --opportunities
+node bench/voxel-report.mjs all
+node bench/trace-analysis.mjs --mesh garden --runs 3 --dom-samples --label garden-trace
 node bench/perf-visual.mjs --mesh chicken --tolerance 0.005
 node bench/nonvoxel-rotation-bench.mjs --models teapot,bicycle --variants baseline,order-tile4 --run-order round-robin
 node bench/nonvoxel-drag-trace.mjs --mesh teapot --degrees 360 --drag-ms 1500 --label teapot-drag --frame-details --no-print-json
-node bench/nonvoxel-frame-buckets.mjs --mesh glb:Elephant.glb --variant baseline --no-trace
+node bench/trace-analysis.mjs --page nonvoxel --mesh glb:Elephant.glb --variant baseline --no-trace
 node bench/nonvoxel-visual-compare.mjs --models bicycle,elephant,policecar --variants scene-split-target,scene-transform-perspective
 ```
 
@@ -98,7 +105,7 @@ would actually pay.
 | Page                  | Render path                            | Per-frame state update            |
 | --------------------- | -------------------------------------- | --------------------------------- |
 | `perf-html.html`      | Declarative `<poly-scene>` + `<poly-mesh>` + `<poly-controls>` custom elements | `sceneEl.setAttribute(...)` — exercises the custom-element attribute observer + reflection pipeline |
-| `perf-vanilla.html`   | Imperative `createPolyScene` + `createPolyOrbitControls` + `loadMesh` | `scene.setOptions({...})` — exercises just the imperative API + the renderer's internal cascade |
+| `perf-vanilla.html`   | Imperative `createPolyCamera` + `createPolyScene` + `createPolyOrbitControls` + `loadMesh` | `camera.update({...})` for camera motion, `scene.setOptions({...})` for light changes |
 | `perf-react.html`     | `<PolyCamera><PolyScene><PolyOrbitControls>` JSX (React 19) | `useState` setter — full React reconciliation each frame |
 | `perf-vue.html`       | `<PolyCamera><PolyScene><PolyOrbitControls>` Vue 3 (`defineComponent` + render funcs) | `ref().value = ...` — Vue's reactivity flush each frame |
 
@@ -189,27 +196,36 @@ plan-only updates to attribute animation bottlenecks.
 
 ```
 bench/
-  README.md              ← you are here
+  notes/
+    BENCH.md            ← you are here
+    PERF_INVESTIGATION.md
+    results/            (gitignored) local Markdown run summaries
+
   perf-shared.mjs        PRESETS, dirFromAzEl, parseUrlParams,
                          createPerfRecorder() (FPS counter + window.__perf__)
   perf-html.html         declarative <poly-scene> + <poly-controls>
   perf-vanilla.html      imperative createPolyScene + createPolyOrbitControls
   nonvoxel-vanilla.html  dedicated vanilla page for non-voxel experiments
                          with strategy/order/transform diagnostics
-  perf-react.html        loads polycss-react.js (JSX entry)
-  perf-vue.html          loads polycss-vue.js (Vue entry)
+  nonvoxel-variants.mjs  shared non-voxel bench variant table used by
+                         rotation, drag, trace, and visual runners
+  perf-react.html        loads .generated/polycss-react.js (JSX entry)
+  perf-vue.html          loads .generated/polycss-vue.js (Vue entry)
   animated-human.html    vanilla animated GLB page for the human run sequence
   entries/
     react.tsx            React 19 entry: useState-driven per-frame updates
     vue.ts               Vue 3 entry: ref() + render funcs (no SFC compiler)
   synth-mesh.mjs         UV-sphere generator (synth-10k/30k/50k presets)
 
-  build.mjs              esbuild driver: emits 4 bundles (vanilla,
-                         elements, react, vue). React/ReactDOM aliased
-                         to workspace-root copies so esbuild de-dupes
-                         a single instance.
+  build.mjs              esbuild driver: emits ignored bundles under
+                         bench/.generated/ (vanilla, elements,
+                         render-stats, react, vue). React/ReactDOM
+                         aliased to workspace-root copies so esbuild
+                         de-dupes a single instance.
   perf-bench.mjs         Playwright runner. Fresh chromium per scenario,
                          ephemeral port, structured JSON output.
+  voxel-report.mjs       Consolidated voxel cadence/browser report over
+                         existing bench/results JSON.
   animated-human-bench.mjs
                          GPU-default Playwright runner for the animated
                          human run sequence. Reports FPS, mixer/update cost,
@@ -226,13 +242,12 @@ bench/
                          links the four perf-*.html with example params.
   perf-visual.mjs        Screenshot diff guardrail (chicken + rock1 ×
                          3 light azimuths, vanilla path only).
+  trace-analysis.mjs     Trace/rAF bucket profiler for camera-motion runs.
+                         Reports per-cadence-bucket compositor, style,
+                         raster, script, and key trace event costs.
   nonvoxel-rotation-bench.mjs
                          Vanilla-only non-voxel rotation corpus runner.
-                         See NON_VOXEL_ROTATION_HYPOTHESES.md.
-  nonvoxel-frame-buckets.mjs
-                         Non-voxel vanilla rAF bucket profiler. Reports
-                         static leaf tag mix by cadence bucket, with optional
-                         Chromium trace attribution.
+                         See bench/notes/PERF_INVESTIGATION.md.
   nonvoxel-visual-compare.mjs
                          Static screenshot parity check for non-voxel bench
                          variants against the baked baseline.
@@ -240,10 +255,10 @@ bench/
   baselines/             chicken-* / rock1-* PNGs the visual diff compares against.
   results/               (gitignored) per-run JSON output from bench scripts.
 
-  polycss.js             (gitignored) vanilla + elements bundle, output of build.mjs.
-  polycss-elements.js    (gitignored) custom-element side-effect register bundle.
-  polycss-react.js       (gitignored) React entry bundle.
-  polycss-vue.js         (gitignored) Vue entry bundle.
+  .generated/            (gitignored) browser ESM bundles output by build.mjs:
+                         polycss.js, polycss-elements.js,
+                         polycss-render-stats.js, polycss-react.js,
+                         polycss-vue.js.
 ```
 
 ## Lossy Optimizer Bench
@@ -273,12 +288,26 @@ mostly-rectangulated and mechanical runtime cases; `AnimatedSnake.glb`,
 `Dinosaur.glb`, `Gorilla.glb`, `Hippo.glb`, `Dragon.glb`, `Lobster.glb`,
 `Octopus.glb`, and `Rat.glb` keep pressure on larger pair-heavy organic meshes.
 
+`lossy-corpus-bench.mjs` is the heavier gallery-wide version. It scans every
+GLB/GLTF/OBJ under `website/public/gallery`, excludes VOX because `loadMesh`
+bypasses the generic optimizer for voxel sources, and emits per-model
+lossless/current lossy/forced-candidate rows. JSON rows include crack-budget
+diagnostics for forced candidates plus per-model optimizer timings, so a
+proposed local crack-aware selector can be checked against the same failure
+reasons without relaxing global crack limits or hiding load-time cost.
+Use `--from-json <file> --opportunities` to mine an existing run without
+rescanning, `--compare <baseline>` to compare two corpus JSON files, and
+`--sweep` on a small `--models` subset to run a wider lossy candidate grid.
+Use `--root <dir>` to scan a temporary external GLB/GLTF/OBJ corpus without
+copying it into `website/public/gallery`; labels are relative to that root and
+the absolute root path is stored in JSON output.
+
 ---
 
 ## How a bench run works (`perf-bench.mjs`)
 
-1. **Build bundles** (`bench:build`). esbuild emits four files in
-   `bench/`. Each consumes the polycss workspace packages aliased to
+1. **Build bundles** (`bench:build`). esbuild emits browser ESM bundles in
+   `bench/.generated/`. Each consumes the polycss workspace packages aliased to
    their **source** (`packages/*/src/index.ts`), so editing source
    lands in the next `pnpm bench:build` without a tsup pass.
 
@@ -418,14 +447,15 @@ alias-resolved `@layoutit/polycss-react` source's nearest node_modules), which
 causes `Cannot read properties of null (reading 'useRef')` because each
 copy keeps its own internal hook dispatcher.
 
-Four bundles produced, all gitignored:
+Five bundles produced, all gitignored:
 
 | File                   | Size hint   | What's in it                         |
 | ---------------------- | ----------- | ------------------------------------ |
-| `polycss.js`           | ~30 KB      | Vanilla createPolyScene + controls + loadMesh + parsers |
-| `polycss-elements.js`  | ~36 KB      | Custom-element auto-register side effect |
-| `polycss-react.js`     | ~290 KB     | + React 19 + ReactDOM + @layoutit/polycss-react + entry |
-| `polycss-vue.js`       | ~150 KB     | + Vue 3 runtime + @layoutit/polycss-vue + entry |
+| `.generated/polycss.js`           | ~30 KB      | Vanilla createPolyScene + controls + loadMesh + parsers |
+| `.generated/polycss-elements.js`  | ~36 KB      | Custom-element auto-register side effect |
+| `.generated/polycss-render-stats.js` | ~1 KB    | Render stats helper re-export for browser pages |
+| `.generated/polycss-react.js`     | ~290 KB     | + React 19 + ReactDOM + @layoutit/polycss-react + entry |
+| `.generated/polycss-vue.js`       | ~150 KB     | + Vue 3 runtime + @layoutit/polycss-vue + entry |
 
 ---
 
diff --git a/bench/notes/PERF_INVESTIGATION.md b/bench/notes/PERF_INVESTIGATION.md
new file mode 100644
index 00000000..b0f9a3e0
--- /dev/null
+++ b/bench/notes/PERF_INVESTIGATION.md
@@ -0,0 +1,426 @@
+# Perf Investigation Reference
+
+This file is the durable performance reference for polycss. It is not a raw
+lab notebook and should not become append-only again.
+
+Bench command details live in `bench/notes/BENCH.md`. Local Markdown summaries
+belong in `bench/notes/results/`; raw JSON and traces belong in
+`bench/results/` or another gitignored path. When a new result matters, fold it
+into the relevant decision, cost model, or rejection below and delete any
+superseded text.
+
+`AGENTS.md` remains the architectural source of truth. This file explains why
+current perf decisions exist and how to avoid repeating invalid experiments.
+
+## How to Use This File
+
+- Start with **Current Baselines** before proposing a renderer change.
+- Check **Rejected Directions** before rerunning an old idea.
+- Use **Active Questions** for the next useful experiments.
+- Add new raw tables only when the exact numbers are needed to defend a future
+  decision. Otherwise summarize the conclusion and point at the result file.
+- Keep camera-rotation, dynamic-lighting, voxel, non-voxel, and framework
+  overhead findings separate. They have different bottlenecks.
+
+## Measurement Rules
+
+- Perf-facing browser runs default to the GPU lane. The old software backend is
+  a stress lane only; use `--software-backend` only when that is the question.
+- Record browser executable, browser args, headed/headless mode, DPR, viewport,
+  warmup/sample windows, model, renderer, mode, motion, active leaves, and
+  trace categories for any result that may guide product code.
+- Use clean cadence runs for p50/p95/p99 decisions. Use traces for attribution,
+  not as the primary FPS proof. `LayerTree.enable` and similar diagnostics can
+  perturb cadence.
+- Use repeated runs before promoting a result. Two-run sweeps are triage; five
+  repeats or stronger targeted confirmation are required for defaults.
+- Treat 100+ FPS as a capped tie unless the p99 tail improves without hurting
+  uncapped models.
+- Visual parity is mandatory. Use the relevant gate: `pnpm bench:visual` for
+  standard renderer changes, `node bench/nonvoxel-visual-compare.mjs` for
+  non-voxel variants, and fixed-angle screenshot sets for voxel prototypes.
+  A perf win that changes the image is a different renderer, not an
+  optimization.
+- Keep `pnpm test && pnpm build` as the pre-PR gate for product changes. Bench
+  wins are not ready if declarations or package builds fail.
+- Dynamic-light results do not explain camera-rotation results, and vice versa.
+
+Useful commands are documented in `bench/notes/BENCH.md`; the common ones are:
+
+```sh
+pnpm bench:perf
+pnpm bench:visual
+pnpm bench:trace
+pnpm bench:voxel-report
+node bench/nonvoxel-rotation-bench.mjs --run-order random
+node bench/trace-analysis.mjs --page nonvoxel --no-trace
+node bench/nonvoxel-visual-compare.mjs
+```
+
+### Promotion Bar
+
+| Candidate type | Promote only if | Reject if |
+| --- | --- | --- |
+| Product renderer default | It improves an uncapped primary case or p99 tail on the GPU lane, passes visual parity, and has no material regression on the relevant counterexample set. | It only helps capped medium scenes, depends on the software backend, fails screenshots, or needs model-name routing. |
+| Bench-only diagnostic | It isolates one variable and preserves enough metadata to explain the result. | It mixes DOM shape, order, culling, browser backend, and measurement changes in one run. |
+| API or public option | It has product value outside the bench and lands across vanilla/custom elements/React/Vue as required. | It exists only to make a benchmark variant selectable. |
+| Trace-backed claim | Clean cadence runs show the perf effect, and trace events explain the likely subsystem. | The trace run is the only source of the FPS win. |
+
+### Reference Model Sets
+
+| Set | Models | Use |
+| --- | --- | --- |
+| Standard perf | `chicken`, `rock1`, `saucer` | Cross-renderer and dynamic-light smoke. |
+| Non-voxel rotation | `chicken`, `rock1`, `saucer`, `teapot`, `ducky`, `elephant`, `policecar`, `bicycle` | Broad baked camera-rotation triage. |
+| Voxel GPU-hard | `AncientCrashSite`, `skyscraper`, long-window `army` | Current target class for voxel renderer work. |
+| Voxel counterexamples | `obj_house3`, `scene_mechanic2`, `Treasure`, `desert2`, `Garden` | Catch order, wrapper, and backend-specific false positives. |
+
+## Current Baselines
+
+### Voxel Fast Path
+
+Eligible baked `.vox` meshes render through the dedicated voxel path.
+
+| Layer | Current shape |
+| --- | --- |
+| Scene | One transform/perspective scene root. |
+| Mesh | One `.polycss-mesh` wrapper. |
+| Voxel hosts | None. |
+| Leaves | Plain hostless `<b>` direct-matrix exact voxel quads. |
+| Primitive | 1px on desktop-class documents; 8px on mobile-class documents with matrix scale divided by 8. |
+| Matrix | One canonical non-degenerate `matrix3d(...)` per mounted quad, including an exact `+/-1` normal column. |
+| DOM order | Projected screen-space `tile4-scanline-forward`. |
+| Culling | Only camera-facing face directions are mounted. |
+
+Accepted voxel decisions:
+
+| ID | Decision | Why it stays |
+| --- | --- | --- |
+| D1 | Preserve `PolyVoxelSource` and route eligible `.vox` meshes through the dedicated path. | It avoids the general polygon path for exact voxel quads and keeps public polygon handles for fallback/bounds. |
+| D2 | Keep hostless direct-matrix leaves as the default voxel shape. | Removing axis hosts and folding orientation/depth/scale into the leaf matrix is the strongest visual-correct one-shape baseline. |
+| D3 | Keep `tile4-scanline-forward` as the default DOM order. | It is the broadest validated one-policy order; nearby tile sizes, traversal orders, depth orders, and face orders all have hard counterexamples. |
+| D4 | Use exact parsed voxel quads, not source overpaint, for default rendering. | Source variants reduced nodes in places but did not reliably win and carry visual risk. |
+| D5 | Keep camera-facing culling. | Mounting all six faces costs more than it saves. |
+| D6 | Keep integer CSS cell snapping during `.vox` normalization. | It preserves direct integer matrix coordinates without adding a scale wrapper. |
+| D7 | Normalize visual fit before comparing voxel FPS. | Fixed zoom can crop or resize large voxel scenes enough to change the benchmark. |
+| D8 | Treat GPU as the default bench lane and software as an explicit stress lane. | Software-renderer ceilings produced false bottlenecks on medium scenes. |
+
+### Non-Voxel Polygon Path
+
+For normal OBJ/GLB/polygon meshes, active transformed leaf count is still the
+first-order camera-rotation cost. The broad product lever is reducing leaves
+through parsing, merging, simplification, culling, or LOD while preserving the
+3D visual contract.
+
+Durable non-voxel findings:
+
+- Force-atlas, disabling stable triangles, Tile4 DOM order, and removing scene
+  `will-change` are not broad wins.
+- Projection-changing transform-topology variants produced large FPS numbers
+  but failed static screenshot parity. They are invalid until the projection
+  math is equivalent.
+- Visual-safe topology variants (`matrix3d`, `no-will-change`) are not broad
+  wins. Full-corpus runs rejected them, with Saucer as a clear regression.
+- Fixed leaf buckets are visually safe but not broad. Teapot's repeatable
+  `leaf-buckets-64/128/256` win is a clue about dense curved solid meshes, not
+  a default renderer policy.
+- Use `domOrder` for pure post-render DOM-order probes. Older `polygonOrder`
+  results changed render planning too, so they are diagnostic only.
+
+Historical package-level wins worth remembering:
+
+| Area | Result | Read |
+| --- | --- | --- |
+| Parse-time merge | Saucer fell from 6384 to 4052 polygons; React/Vue stopped bypassing vanilla's merge. | Shared mesh reduction beats framework-specific cleanup. |
+| React `<Poly>` memoization | React `dynamic.light_rotate` on saucer improved about 28% in the measured run. | It removes per-frame child function-body work when only scene-root CSS vars change. |
+| JS micro-opts around `setOptions` | Flat. | Camera/light hot paths are dominated by browser cascade/compositor work, not a few skipped JS writes. |
+
+### Dynamic Lighting
+
+Dynamic light rotation is a CSS cascade/raster problem, not the same issue as
+camera rotation. Earlier traces on large non-voxel meshes showed style update
+and raster work dominating light rotation, while baked camera rotation showed
+compositor/property-tree work instead.
+
+Do not use dynamic-light wins or losses to justify camera DOM topology changes.
+Trace them separately and keep the acceptance metric tied to
+`dynamic.light_rotate`.
+
+## Browser Cost Model
+
+### Camera Rotation
+
+Changing the root transform over a `preserve-3d` subtree dirties the browser's
+3D compositor/property-tree path. Static mounted DOM is cheap, and repeatedly
+writing the same transform value is cheap; the expensive path appears when the
+root camera transform actually changes.
+
+Durable trace read:
+
+- Paint and raster are usually near zero for baked camera-rotation captures.
+- The recurring cost is compositor/layer lifecycle:
+  `PaintArtifactCompositor::Update`, `Layerize`,
+  `LayerTreeImpl::UpdateDrawProperties`, `LayerTreeHostImpl::PrepareToDraw`,
+  and draw.
+- Voxel and non-voxel scenes show a similar per-active-leaf slope when the
+  root transform changes. Active transformed leaves remain the best first
+  predictor, but model geometry and order can move cadence near thresholds.
+- Same-node-count DOM-order flips can have nearly identical per-frame
+  PAC/DrawProps/Draw summaries while landing in different vsync buckets. Treat
+  those as compositor scheduling/cadence effects, not normal JS/style wins.
+
+### Transform API Shape
+
+Chromium source and probes agree on this:
+
+- A running CSS keyframe or running WAAPI transform animation can skip full
+  `PaintArtifactCompositor::Update`.
+- JS `scene.setOptions({ rotY })` / `style.transform` mutation does not hit
+  that active-animation fast path.
+- Paused WAAPI scrubbed with `Animation.currentTime` and scroll-timeline
+  scrubbed through JS `scrollLeft` also fall back into PAC.
+- CSS custom properties used in `transform`, registered transform variables,
+  and individual `rotate` property writes still dirty the subtree like normal
+  JS transform mutation.
+
+The practical consequence: declarative auto-rotate may be useful for demos, but
+it is not an interactive pointer-driven camera fix unless a browser exposes a
+true compositor-driven scrub path.
+
+### 3D Descendant Cost
+
+Synthetic topology probes isolate the lower-level shape:
+
+| Equal-leaf topology | Read |
+| --- | --- |
+| `left/top` or 2D `translate(...)` leaves | Cheap draw-property path. |
+| `translateZ(0)`, real `translateZ(...)`, or `matrix3d(...)` leaves | Expensive 3D transform-tree/draw-property path. |
+| Fewer 3D wrappers with many 2D children | Fast only when wrapper count stays below the backend threshold and visual depth remains exact. |
+
+ANGLE/Metal GPU reread of exact depth groups with 7000 leaves:
+
+| Exact depth wrappers | Result |
+| ---: | --- |
+| Up to about 112 | Near the 112 FPS p95 bucket. |
+| 128 | Falls to about the 60 FPS p95 bucket. |
+| 136 | Collapses further. |
+| 192 | Unusable for the hard class. |
+
+Relevant voxel model visible-plane counts show why exact depth wrappers are not
+the default path:
+
+| Model | Visible exact planes | Read |
+| --- | ---: | --- |
+| `AncientCrashSite.vox` | 191 | Above threshold; still GPU-hard. |
+| `skyscraper.vox` | 173 | Above threshold; still GPU-hard. |
+| `army.vox` | 187 | Above threshold and window-sensitive. |
+| `obj_house3.vox` | 142 | Above wrapper threshold, but now mostly a capped/tie medium case on GPU. |
+| `scene_mechanic2.vox` | 163 | Above wrapper threshold, but now mostly capped/tie on GPU. |
+| `Treasure.vox` | 132 | Just above threshold; medium GPU case. |
+| `desert2.vox` | 102 | Under threshold, but already fast on GPU. |
+
+Depth wrappers remain a special-case ceiling for a future high-leaf,
+low-visible-plane asset. They are not a default renderer path.
+
+### Browser Backend
+
+The benchmark backend can change the apparent bottleneck. Bundled Playwright
+Chromium without GPU flags can fall onto `SoftwareRenderer::DoDrawQuad`; the
+perf scripts now default to the GPU lane (`--use-angle=metal` on macOS plus
+`--enable-gpu-rasterization`).
+
+The GPU reread moved medium scenes such as `obj_house3`, `scene_mechanic2`,
+`Treasure`, and `desert2` into the 100+ FPS capped/tie class. The remaining
+true target is the GPU-hard class: high active leaves plus high exact visible
+plane count, especially `AncientCrashSite`, `skyscraper`, and long-window
+`army`.
+
+## Evidence Anchors
+
+These are the few historical tables worth keeping inline because they prevent
+old ideas from being re-argued.
+
+### Voxel Order Baseline
+
+Validation that made `tile4-scanline-forward` the one-strategy default:
+
+| Model | Prior slice p95 | Tile4 scanline p95 | Read |
+| --- | ---: | ---: | --- |
+| `obj_house3.vox` | 59.9 | 113.6 | Rescues the face/locality counterexample. |
+| `obj_house5.vox` | 59.9 | 113.4 | Validated win. |
+| `desert2.vox` | 59.5 | 113.6 | Validated win. |
+| `house.vox` | 59.9 | 114.7 | Validated win. |
+| `scene_mechanic2.vox` | 40.0 | 113.5 | Validated win. |
+| `Treasure.vox` | 30.5 | 58.5 | Moves into the about-60 FPS class. |
+| `army.vox` | 39.8 | 42.1 | Weak; still needs better interval analysis. |
+| `AncientCrashSite.vox` | 39.8 | 39.8 | Neutral; remains hard. |
+| `skyscraper.vox` | 23.7 | 29.9 | Modest; still hard. |
+
+Rejected replacements after this result: `tile4-depth-front`, tile3/tile5/tile6
+scanlines, tile4 serpentine, Morton traversal, full face order, full depth
+order, dense-tile face order, and centered/lookahead interval phases.
+
+### Old Matrix-Vs-Slice Selector
+
+Do not revive the old `.vox` matrix-vs-slice router without new GPU-hard proof.
+
+The 86-model cadence corpus found matrix p95 wins on `desert2`,
+`scene_hazmat`, `scene_house`, `scene_mechanic2`, `scene_sidewalk`, and
+`Treasure`; slice p95 wins on `AncientCrashSite`, `armchair`,
+`christmas_tree`, `ff1`, `mailbox`, `obj_house3`, `obj_house8`,
+`obj_trashcan4`, `pyramid`, and `scene_park`; 66 models were flat or capped.
+
+`visibleShadedColors >= 52 && visiblePlanes < 200` was the safest partial
+gate. It caught several high-shaded matrix wins and avoided known p99 risk, but
+it missed `desert2`, hit many capped models, and changed with browser mode.
+Hostless direct matrix plus tile4 order superseded the router direction.
+
+### Non-Voxel Rotation
+
+Current non-voxel evidence:
+
+| Variant | Result | Read |
+| --- | --- | --- |
+| Force atlas | Rejected. | Normal warmup lost on Teapot, Bicycle, Elephant, and Policecar. |
+| Disable stable triangles | Rejected as broad default. | Short Bicycle movement flattened; Teapot regressed; others were flat. |
+| Tile4 DOM order | Rejected as broad default. | Corrected `domOrder` probes were flat or regressed representative meshes. |
+| Transform topology changes | Invalid if projection changed. | Large FPS wins failed visual parity. |
+| `matrix3d` / `no-will-change` topology | Rejected as broad default. | Full eight-model random pass regressed Saucer and flattened most others. |
+| Fixed leaf buckets | Narrow clue. | Teapot repeatably improved about 10-12%; Saucer regressed and other representative meshes were flat. |
+
+## Active Questions
+
+### Voxel GPU-Hard Class
+
+Primary target: high-leaf, high-visible-plane voxel scenes on the GPU lane,
+especially `AncientCrashSite`, `skyscraper`, and long-window `army`.
+
+Next useful work:
+
+1. Attribute slow intervals, not whole runs. Segment by visible-face interval
+   before testing another order phase.
+2. Measure projected overlap, footprint, depth distribution, and tile density
+   on the hard intervals. Treat these as explanatory variables for cadence, not
+   as preset model gates.
+3. Reopen exact depth wrappers only for a real high-leaf model at or below the
+   GPU wrapper threshold and only if it is not already capped.
+4. Keep occlusion alive only as an exact/geometric proof. Sampled masks either
+   failed screenshots or became interval-stable by removing too few leaves.
+5. Do not add another global order permutation without a browser/compositor
+   metric that predicts the hard counterexamples.
+
+### Non-Voxel Camera Rotation
+
+Next useful work:
+
+1. Use `trace-analysis.mjs --page nonvoxel --no-trace` to identify the slow
+   cadence buckets first; trace only after a signal survives repeated clean
+   runs.
+2. Investigate Teapot-like dense curved solid meshes separately from broad
+   default policy. Leaf buckets are a clue, not a product feature.
+3. Prefer leaf-count reduction, merge quality, simplification, or LOD over more
+   transform-chain spelling experiments.
+
+### Declarative Auto-Rotate
+
+Running CSS/WAAPI transform animation can skip PAC in traces. A product-shaped
+auto-rotate path is still open as a demo/idle feature, but it must be tested
+separately from pointer-driven controls and must pass fixed-angle screenshots.
+
+### Dynamic Light
+
+Dynamic light remains a cascade/raster investigation. Useful work here should
+measure `dynamic.light_rotate` directly and avoid importing camera-rotation
+topology conclusions.
+
+## Rejected Directions
+
+Do not rerun these without a concrete new browser version, trace signal, or
+visual-correct implementation that changes the premise.
+
+### Architecture and API
+
+| Direction | Why closed |
+| --- | --- |
+| Per-frame JS Lambert, JS filters, or JS per-polygon visual writes | Violates the CSS-driven renderer model. |
+| CSS Paint Worklet face generation | Adds JS to the paint path and is not reliable enough for the core renderer. |
+| Back-compat shims for perf-only API churn | This repo uses clean breaks; perf knobs need product justification. |
+
+### Camera Transform Shortcuts
+
+| Direction | Why closed |
+| --- | --- |
+| `will-change` alone | It can force compositing but does not make JS transform mutation hit the active animation fast path. |
+| Root transform spelling changes (`matrix3d`, perspective placement, inner target shell, transform-function perspective) | Longer validation was flat or worse. |
+| CSS variables, registered variables, or individual `rotate` for interactive camera motion | They still hit PAC/layerize like normal JS transform mutation. |
+| JS-scrubbed WAAPI or scroll-timeline camera controls | Scrubbing from JS still hit PAC once per frame. |
+| Leaf `transform-style: flat` | Catastrophic regressions, including hostless direct-matrix voxel leaves. |
+| Leaf or host `backface-visibility: hidden` | Fast-looking variants either failed visual checks or lost the win once oriented correctly. |
+
+### Voxel DOM Shape
+
+| Direction | Why closed |
+| --- | --- |
+| Axis hosts, host+brush matrix, or voxel slice hosts as the main shape | Hostless direct canonical matrix leaves are the transferable win. |
+| Mount all six face directions | Extra active DOM dominates mutation savings. |
+| Hide pooled leaves instead of removing unused faces | Flat to worse. |
+| Split large brushes or source-overpaint planners | More leaves or visual risk without reliable p95/p99 wins. |
+| Per-leaf square primitive normalization, fixed 64px quads, size bands, or CSS width/height plus unit matrix | Flat, noisy, or short-window cadence artifacts. |
+| Leaf containment, `overflow`, `will-change`, CSS resets, semantic `inert`/`aria-hidden` | Flat, visually invalid, or regressive in representative runs. |
+| Direct matrix normal-column scaling away from exact `+/-1` | Visual-equivalent but cadence-regressive on key models. |
+
+### Voxel Ordering
+
+| Direction | Why closed |
+| --- | --- |
+| Full depth order or full face order as the default | Each has hard model counterexamples. |
+| Static face-normal permutations | Model-specific and rejected by `obj_house3`, `desert2`, `house`, `AncientCrashSite`, or `Treasure` depending on the order. |
+| Source-block depth order | Transfers some wins but fails `obj_house3`, misses `army`/`skyscraper`, and does not beat the Pareto frontier. |
+| Tile3, tile5, tile6 scanline replacements | Hard counterexamples and p99 regressions; tile5's broader pass found no safe default win. |
+| Tile4 serpentine or Morton traversal | Lost `obj_house3` and stayed below row-major average. |
+| Centered interval order, lookahead offsets, boundary screen-span anchors, adaptive 3x3/5x5 density | Real short-window wins, but validation left `obj_house3`, `AncientCrashSite`, or p99 tail losses. |
+| Dense-tile face order | Product patch looked promising in one window and failed two-repeat interval validation. |
+
+### Voxel Wrappers and Culling
+
+| Direction | Why closed |
+| --- | --- |
+| Exact depth wrappers as the default | GPU threshold is about 112 wrappers; current hard models exceed it. |
+| Residual per-leaf Z inside coarse wrappers | Falls back to per-leaf 3D transform cost. |
+| Depth quantization | Visual error is too large. |
+| Spatially tiled depth wrappers | More bounded wrappers were slower than fewer broad wrappers. |
+| Sampled screen-coverage occlusion | Either failed visual checks or became too conservative to help. |
+| Interior-neighbor sampled culling plus alternate order | Wins were entangled with order; no single order handled the hard set. |
+| Interval-stable sampled culling | Passed screenshots but removed almost no p50 DOM once it had to cover the whole visible interval. |
+
+### Non-Voxel Variants
+
+| Direction | Why closed |
+| --- | --- |
+| Force atlas for rotation | Rejected by normal-warmup confirmation. |
+| Disable stable triangles broadly | Not a broad win. |
+| Voxel Tile4 order copied to non-voxel meshes | Corrected DOM-order probes did not hold broadly. |
+| Projection-changing scene split/host perspective/transform perspective variants | Failed static visual parity. |
+| `matrix3d` scene transform or `no-will-change` as defaults | Full-corpus run rejected broad use. |
+| Fixed leaf buckets as a broad default | Teapot-only signal; Saucer regressed and other representative meshes were flat. |
+
+### Measurement Traps
+
+| Trap | Rule |
+| --- | --- |
+| Optimizing `RunTask` totals | Use nested event attribution and per-frame medians; `RunTask` is just a wrapper. |
+| Summing top trace events as exclusive time | Many important trace events are nested. |
+| Treating trace FPS as final proof | Trace capture can move cadence buckets. |
+| Comparing software-backend wins to GPU-lane defaults | Software-only wins are stress-lane findings unless they also help the GPU-hard class. |
+| Drawing conclusions from fixed zoom | Normalize visual fit first. |
+
+## Update Protocol
+
+When a future investigation changes the read:
+
+1. Add or update one short decision, active question, or rejection.
+2. Keep the smallest table that proves the point.
+3. Name the result artifact if the raw data matters.
+4. Delete contradicted older text in the same edit.
+5. Update `AGENTS.md` too if the result changes a render strategy, lighting
+   mode, naming convention, public API contract, or JS-in-render-loop rule.
diff --git a/bench/perf-cracks.html b/bench/perf-cracks.html
deleted file mode 100644
index 626dd61f..00000000
--- a/bench/perf-cracks.html
+++ /dev/null
@@ -1,307 +0,0 @@
-<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <title>polycss crack finder</title>
-  <style>
-    html, body { margin: 0; padding: 0; height: 100%; background: #000; color: #fff; font: 13px/1.4 system-ui, sans-serif; overflow: hidden; }
-    #host { position: absolute; inset: 0; background: var(--bg, #000); }
-    /* Override polycss's default `backface-visibility: hidden` only when
-       in wireframe mode — wireframe edges need to be visible from both
-       sides. In red/original modes we keep backfaces hidden, otherwise
-       cracks on the front render as the back face's red showing through
-       instead of as visible black holes. Toggled by adding/removing the
-       `show-backfaces` class on <body>. */
-    body.show-backfaces .polycss-scene i { backface-visibility: visible !important; -webkit-backface-visibility: visible !important; }
-    #hud {
-      position: fixed; top: 12px; left: 12px; z-index: 10;
-      padding: 10px 12px; background: rgba(0,0,0,0.85);
-      border: 1px solid #333; border-radius: 6px; font-family: ui-monospace, monospace;
-      max-width: 360px; user-select: none;
-    }
-    #hud h1 { font-size: 12px; margin: 0 0 8px; letter-spacing: 0.05em; text-transform: uppercase; color: #888; }
-    #hud .row { display: flex; gap: 8px; align-items: center; margin-bottom: 4px; }
-    #hud label { width: 60px; color: #888; }
-    #hud select, #hud input[type=number] { background: #111; color: #fff; border: 1px solid #333; padding: 2px 6px; font: inherit; }
-    #hud select { width: 220px; }
-    #hud input[type=number] { width: 80px; }
-    #hud button { background: #1a1a1a; color: #fff; border: 1px solid #444; padding: 4px 10px; font: inherit; cursor: pointer; }
-    #hud button:hover { background: #2a2a2a; }
-    #hud .toggle { display: flex; gap: 12px; margin-top: 4px; flex-wrap: wrap; }
-    #hud .toggle label { width: auto; color: #fff; cursor: pointer; }
-    #hud .toggle input { margin-right: 4px; }
-    #hud .actions { display: flex; gap: 6px; margin-top: 8px; flex-wrap: wrap; }
-    #hud .cam-block {
-      margin-top: 10px; padding-top: 10px; border-top: 1px solid #222;
-      font-size: 12px;
-    }
-    #hud .cam-block .row { gap: 4px; }
-    #hud .cam-block .label { color: #888; }
-    #hud .cam-block .val { color: #4af; min-width: 60px; }
-    #legend {
-      position: fixed; bottom: 12px; right: 12px; z-index: 10;
-      padding: 8px 12px; background: rgba(0,0,0,0.85);
-      border: 1px solid #333; border-radius: 6px; font-size: 11px; color: #888;
-      max-width: 280px;
-    }
-    #legend strong { color: #f44; }
-  </style>
-</head>
-<body>
-  <div id="host"></div>
-
-  <div id="hud">
-    <h1>crack finder</h1>
-    <div class="row">
-      <label>mesh</label>
-      <select id="mesh-sel"></select>
-    </div>
-    <div class="row">
-      <label>paint</label>
-      <select id="paint-sel">
-        <option value="red">solid red on black</option>
-        <option value="wireframe">wireframe (edges only)</option>
-        <option value="original">original colors / textures</option>
-      </select>
-    </div>
-    <div class="row" id="line-row" style="display:none">
-      <label>line</label>
-      <input type="number" id="line-width" value="0.002" step="0.0005" min="0.0001" />
-    </div>
-    <div class="toggle">
-      <label><input type="checkbox" id="normalize-cb" /> normalize</label>
-      <label><input type="checkbox" id="autocenter-cb" checked /> autoCenter</label>
-    </div>
-    <div class="cam-block">
-      <div class="row"><span class="label">rotX</span><span class="val" id="cam-rotx">—</span></div>
-      <div class="row"><span class="label">rotY</span><span class="val" id="cam-roty">—</span></div>
-      <div class="row"><span class="label">zoom</span><span class="val" id="cam-zoom">—</span></div>
-    </div>
-    <div class="actions">
-      <button id="reload-btn">reload</button>
-      <button id="copy-url-btn">copy URL</button>
-      <button id="copy-snippet-btn">copy snippet</button>
-    </div>
-  </div>
-
-  <div id="legend">
-    In <strong>red mode</strong>, every pixel of the mesh should render
-    solid red on black. Any black pixel <em>inside</em> the silhouette is a
-    crack. Drag to rotate; scroll to zoom. When you find a viewing angle
-    that exposes a crack, click "copy" to grab the camera state — paste
-    it back to me and I'll bake it as a benchmark.
-  </div>
-
-  <script type="module">
-    import { createPolyScene, createPolyControls, loadMesh } from "./polycss.js";
-    import { preprocessModelPolygons, paintPolygonsSolid, polygonsToWireframe } from "./polycss-normalize.js";
-
-    // ── Mesh registry ───────────────────────────────────────────────────
-    // Mirror the OBJ_MODEL_CONFIG / gallery list so anything in
-    // website/public/gallery/obj/ is loadable here.
-    const MESHES = [
-      { id: "sting",      url: "/gallery/obj/sting.obj",      objOptions: { materialTextures: { Sting: "/gallery/obj/sting-diffuse.png" } } },
-      { id: "chicken",    url: "/gallery/obj/chicken.obj",    mtlUrl: "/gallery/obj/chicken.mtl" },
-      { id: "cottage",    url: "/gallery/obj/cottage.obj",    mtlUrl: "/gallery/obj/cottage.mtl",
-        objOptions: { materialTextures: { cottage_texture: "/gallery/obj/cottage-diffuse.png" }, includeObjects: ["Cube_Cube.002"] } },
-      { id: "rock1",      url: "/gallery/obj/rock1.obj",      mtlUrl: "/gallery/obj/rock1.mtl",
-        objOptions: { excludeObjects: ["Plane"] } },
-      { id: "castle",     url: "/gallery/obj/castle.obj" },
-      { id: "coliseum",   url: "/gallery/obj/coliseum.obj" },
-      { id: "saucer",     url: "/gallery/obj/saucer.obj" },
-      { id: "teapot",     url: "/gallery/obj/teapot.obj" },
-      { id: "wheelbarrow",url: "/gallery/obj/wheelbarrow.obj", mtlUrl: "/gallery/obj/wheelbarrow.mtl" },
-      { id: "insurgent",  url: "/gallery/glb/insurgent.gltf" },
-    ];
-
-    // ── URL params ──────────────────────────────────────────────────────
-    const params = new URLSearchParams(location.search);
-    const initial = {
-      mesh: params.get("mesh") || "sting",
-      paint: params.get("paint") || "red",
-      line: Number(params.get("line") ?? 0.002),
-      normalize: params.get("normalize") === "true",
-      autoCenter: params.get("autoCenter") !== "false",
-      rotX: Number(params.get("rotX") ?? 65),
-      rotY: Number(params.get("rotY") ?? 45),
-      zoom: Number(params.get("zoom") ?? 0.4),
-      bg: params.get("bg") || "#000000",
-    };
-
-    // ── DOM refs ────────────────────────────────────────────────────────
-    const host = document.getElementById("host");
-    const meshSel = document.getElementById("mesh-sel");
-    const paintSel = document.getElementById("paint-sel");
-    const lineRow = document.getElementById("line-row");
-    const lineWidthInput = document.getElementById("line-width");
-    const normalizeCb = document.getElementById("normalize-cb");
-    const autoCenterCb = document.getElementById("autocenter-cb");
-    const reloadBtn = document.getElementById("reload-btn");
-    const copyUrlBtn = document.getElementById("copy-url-btn");
-    const copySnippetBtn = document.getElementById("copy-snippet-btn");
-    const camRotX = document.getElementById("cam-rotx");
-    const camRotY = document.getElementById("cam-roty");
-    const camZoom = document.getElementById("cam-zoom");
-
-    document.documentElement.style.setProperty("--bg", initial.bg);
-
-    for (const m of MESHES) {
-      const o = document.createElement("option");
-      o.value = m.id; o.textContent = m.id;
-      if (m.id === initial.mesh) o.selected = true;
-      meshSel.appendChild(o);
-    }
-    paintSel.value = initial.paint;
-    lineWidthInput.value = initial.line;
-    normalizeCb.checked = initial.normalize;
-    autoCenterCb.checked = initial.autoCenter;
-
-    // ── Scene lifecycle ─────────────────────────────────────────────────
-    let scene = null;
-    let controls = null;
-    let mesh = null;
-    let parseResult = null;
-
-    function fmt(n, d = 2) { return n == null ? "—" : Number(n).toFixed(d); }
-    function updateCamReadout(camera) {
-      camRotX.textContent = fmt(camera?.rotX ?? scene?.getOptions().rotX);
-      camRotY.textContent = fmt(camera?.rotY ?? scene?.getOptions().rotY);
-      camZoom.textContent = fmt(camera?.zoom ?? scene?.getOptions().zoom, 4);
-    }
-
-    // Camera state PERSISTS across rebuilds (mesh swap, normalize toggle,
-    // paint toggle, autoCenter toggle) so the user's interactive angle
-    // doesn't snap back to the initial URL params every time they flip
-    // a switch. Updated on every controls "change" event.
-    let cam = { rotX: initial.rotX, rotY: initial.rotY, zoom: initial.zoom };
-
-    async function rebuild() {
-      // Capture the current camera before tearing the scene down.
-      if (scene) {
-        const cur = scene.getOptions();
-        cam = {
-          rotX: cur.rotX ?? cam.rotX,
-          rotY: cur.rotY ?? cam.rotY,
-          zoom: cur.zoom ?? cam.zoom,
-        };
-      }
-
-      // Tear down any existing scene first.
-      if (controls) { controls.destroy(); controls = null; }
-      if (mesh)     { mesh.remove(); mesh = null; }
-      if (parseResult) { try { parseResult.dispose(); } catch (_) {} parseResult = null; }
-      if (scene)    { scene.destroy(); scene = null; }
-      host.innerHTML = "";
-
-      const meshId = meshSel.value;
-      const def = MESHES.find((m) => m.id === meshId);
-      if (!def) return;
-
-      const loadOptions = {};
-      if (def.mtlUrl) loadOptions.mtlUrl = def.mtlUrl;
-      if (def.objOptions) loadOptions.objOptions = def.objOptions;
-
-      parseResult = await loadMesh(def.url, loadOptions);
-
-      // Apply normalize (if requested) and paint (if requested).
-      let polygons = parseResult.polygons;
-      if (normalizeCb.checked) {
-        polygons = preprocessModelPolygons(polygons, true);
-      }
-      if (paintSel.value === "red") {
-        polygons = paintPolygonsSolid(polygons, "#ff0000");
-      } else if (paintSel.value === "wireframe") {
-        const lw = Math.max(0.00005, Number(lineWidthInput.value) || 0.002);
-        polygons = polygonsToWireframe(polygons, lw, "#00ff88");
-      }
-      // Show/hide line-width control based on selected paint mode.
-      lineRow.style.display = paintSel.value === "wireframe" ? "" : "none";
-      // Backfaces visible only in wireframe — in red mode backface red
-      // would fill the cracks we're trying to see from the front.
-      document.body.classList.toggle("show-backfaces", paintSel.value === "wireframe");
-
-      const sceneOpts = {
-        rotX: cam.rotX, rotY: cam.rotY, zoom: cam.zoom,
-        autoCenter: autoCenterCb.checked,
-        // Baked + ambient=1 so colors are full-saturation regardless of light direction.
-        textureLighting: "baked",
-        ambientLight: { color: "#ffffff", intensity: 1 },
-        directionalLight: { direction: [0, 0, 1], color: "#000000", intensity: 0 },
-        // Wireframe mode generates very thin polygons. The atlas rasterizes
-        // each polygon's bbox at `meshSize × tile × atlasScale` pixels with
-        // a 1-pixel floor, so thin lines need a high atlasScale to render
-        // sub-mesh-unit thickness correctly.
-        atlasScale: paintSel.value === "wireframe" ? 4 : "auto",
-      };
-      scene = createPolyScene(host, sceneOpts);
-      mesh = scene.add({ ...parseResult, polygons });
-      controls = createPolyControls(scene, { drag: true, wheel: true });
-      controls.addEventListener("change", (e) => {
-        cam = { rotX: e.camera.rotX, rotY: e.camera.rotY, zoom: e.camera.zoom };
-        updateCamReadout(e.camera);
-      });
-      updateCamReadout(cam);
-    }
-
-    function currentParams() {
-      if (!scene) return null;
-      const o = scene.getOptions();
-      const meshId = meshSel.value;
-      const allParams = new URLSearchParams({
-        mesh: meshId,
-        paint: paintSel.value,
-        normalize: String(normalizeCb.checked),
-        autoCenter: String(autoCenterCb.checked),
-        rotX: o.rotX.toFixed(2),
-        rotY: o.rotY.toFixed(2),
-        zoom: o.zoom.toFixed(4),
-      });
-      if (paintSel.value === "wireframe") allParams.set("line", String(Number(lineWidthInput.value)));
-      return { meshId, o, allParams };
-    }
-
-    function flashBtn(btn, ok) {
-      const orig = btn.dataset.orig ?? btn.textContent;
-      btn.dataset.orig = orig;
-      btn.textContent = ok ? "copied!" : "fail";
-      setTimeout(() => { btn.textContent = orig; }, 1200);
-    }
-
-    function copyUrl() {
-      const c = currentParams();
-      if (!c) return;
-      const url = `${location.origin}${location.pathname}?${c.allParams}`;
-      navigator.clipboard.writeText(url).then(
-        () => flashBtn(copyUrlBtn, true),
-        () => flashBtn(copyUrlBtn, false),
-      );
-    }
-
-    function copySnippet() {
-      const c = currentParams();
-      if (!c) return;
-      const { meshId, o } = c;
-      const snippet = `{ mesh: "${meshId}", paint: "${paintSel.value}", normalize: ${normalizeCb.checked}, rotX: ${o.rotX.toFixed(2)}, rotY: ${o.rotY.toFixed(2)}, zoom: ${o.zoom.toFixed(4)}${paintSel.value === "wireframe" ? `, line: ${Number(lineWidthInput.value)}` : ""} }`;
-      navigator.clipboard.writeText(snippet).then(
-        () => flashBtn(copySnippetBtn, true),
-        () => flashBtn(copySnippetBtn, false),
-      );
-    }
-
-    // ── Wiring ──────────────────────────────────────────────────────────
-    meshSel.addEventListener("change", rebuild);
-    paintSel.addEventListener("change", rebuild);
-    lineWidthInput.addEventListener("change", rebuild);
-    normalizeCb.addEventListener("change", rebuild);
-    autoCenterCb.addEventListener("change", rebuild);
-    reloadBtn.addEventListener("click", rebuild);
-    copyUrlBtn.addEventListener("click", copyUrl);
-    copySnippetBtn.addEventListener("click", copySnippet);
-
-    rebuild().catch((err) => {
-      console.error(err);
-      host.innerHTML = `<pre style="color:#f55;padding:20px;">${err.stack || err.message}</pre>`;
-    });
-  </script>
-</body>
-</html>
diff --git a/bench/perf-html.html b/bench/perf-html.html
index 57b16d62..75eac97e 100644
--- a/bench/perf-html.html
+++ b/bench/perf-html.html
@@ -19,7 +19,7 @@
     // Imports the same bundle as perf-vanilla, but only for the side effect
     // of registering the custom elements (polycss/elements is auto-registered
     // via the bundle's elements entry).
-    import "./polycss-elements.js";
+    import "./.generated/polycss-elements.js";
     import { getSynthMesh } from "./synth-mesh.mjs";
     import {
       parseUrlParams, dirFromAzEl, createPerfRecorder,
diff --git a/bench/perf-react.html b/bench/perf-react.html
index ebca4a11..9eb95165 100644
--- a/bench/perf-react.html
+++ b/bench/perf-react.html
@@ -6,8 +6,8 @@
 </head>
 <body>
   <div id="host"></div>
-  <!-- The React entry is bundled by bench/build.mjs into bench/polycss-react.js
+  <!-- The React entry is bundled by bench/build.mjs into bench/.generated/polycss-react.js
        and pulls in React + ReactDOM + @polycss/react + the shared helpers. -->
-  <script type="module" src="./polycss-react.js"></script>
+  <script type="module" src="./.generated/polycss-react.js"></script>
 </body>
 </html>
diff --git a/bench/perf-serve.mjs b/bench/perf-serve.mjs
index 433e0f81..838fc895 100644
--- a/bench/perf-serve.mjs
+++ b/bench/perf-serve.mjs
@@ -4,7 +4,7 @@
  * Serves:
  *   /                      → small index page that links the four perf-*.html
  *   /perf-{path}.html      → bench/perf-{path}.html   (vanilla / html / react / vue)
- *   /polycss*.js           → bench/polycss*.js        (built by bench/build.mjs)
+ *   /.generated/*.js       → bench/.generated/*.js    (built by bench/build.mjs)
  *   /gallery/...           → website/public/gallery/...  (mesh assets)
  *   anything else under /  → bench/<path>
  *
diff --git a/bench/perf-shared.mjs b/bench/perf-shared.mjs
index 7d579499..c98e8b53 100644
--- a/bench/perf-shared.mjs
+++ b/bench/perf-shared.mjs
@@ -13,7 +13,7 @@
  * specific. Each page handles its own mount and its own per-frame state
  * update; this module just provides the measurement surface.
  */
-import { collectPolyRenderStats } from "./polycss-render-stats.js";
+import { collectPolyRenderStats } from "./.generated/polycss-render-stats.js";
 
 export const PRESETS = {
   saucer: {
diff --git a/bench/perf-vanilla.html b/bench/perf-vanilla.html
index 7dfad45a..10c4dc7b 100644
--- a/bench/perf-vanilla.html
+++ b/bench/perf-vanilla.html
@@ -10,9 +10,8 @@
 
   <script type="module">
     // Vanilla path: createPolyScene(host, opts) + createPolyOrbitControls + loadMesh.
-    // Per-frame state changes go through scene.setOptions(...) — exercises
-    // only the imperative API + the renderer's internal cascade.
-    import { createPolyScene, createPolyOrbitControls, loadMesh } from "./polycss.js";
+    // Per-frame state changes go through the imperative scene/camera handles.
+    import { createPolyCamera, createPolyScene, createPolyOrbitControls, loadMesh } from "./.generated/polycss.js";
     import { getSynthMesh } from "./synth-mesh.mjs";
     import {
       parseUrlParams, dirFromAzEl, createPerfRecorder,
@@ -26,8 +25,9 @@
     let azimuth = az;
 
     const host = document.getElementById("host");
+    const camera = createPolyCamera({ rotX: preset.rotX, rotY: preset.rotY, zoom: preset.zoom });
     const scene = createPolyScene(host, {
-      rotX: preset.rotX, rotY: preset.rotY, zoom: preset.zoom,
+      camera,
       directionalLight: { direction: dirFromAzEl(azimuth, el), color: "#ffffff", intensity: 1 },
       ambientLight: { color: "#ffffff", intensity: 0.4 },
       textureLighting: mode,
@@ -66,7 +66,7 @@
           });
         } else if (motion === "rot") {
           const newRotY = ((preset.rotY + frameCount * 0.5) + 360) % 360;
-          scene.setOptions({ rotY: newRotY });
+          camera.update({ rotY: newRotY });
         }
         requestAnimationFrame(tick);
       }
diff --git a/bench/perf-vue.html b/bench/perf-vue.html
index b76b3d95..3871bf8b 100644
--- a/bench/perf-vue.html
+++ b/bench/perf-vue.html
@@ -6,8 +6,8 @@
 </head>
 <body>
   <div id="host"></div>
-  <!-- The Vue entry is bundled by bench/build.mjs into bench/polycss-vue.js
+  <!-- The Vue entry is bundled by bench/build.mjs into bench/.generated/polycss-vue.js
        and pulls in Vue 3 + @polycss/vue + the shared helpers. -->
-  <script type="module" src="./polycss-vue.js"></script>
+  <script type="module" src="./.generated/polycss-vue.js"></script>
 </body>
 </html>
diff --git a/bench/polycss-normalize.js b/bench/polycss-normalize.js
deleted file mode 100644
index 434b8559..00000000
--- a/bench/polycss-normalize.js
+++ /dev/null
@@ -1,3618 +0,0 @@
-// packages/core/src/math/quaternion.ts
-var DEG_TO_RAD = Math.PI / 180;
-var RAD_TO_DEG = 180 / Math.PI;
-
-// packages/core/src/merge/mergePolygons.ts
-var EPS_NORMAL = 1e-3;
-var EPS_DISTANCE = 0.05;
-var EPS_TEXTURE_DISTANCE = 1e-3;
-var EPS_RENDER_DISTANCE = 1e-3;
-var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-var cross = (a, b) => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0]
-];
-var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-var norm = (a) => Math.hypot(a[0], a[1], a[2]);
-var eqVec = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-function edgeKey(a, b) {
-  const ka = `${a[0]},${a[1]},${a[2]}`;
-  const kb = `${b[0]},${b[1]},${b[2]}`;
-  return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
-}
-function planeOf(vertices) {
-  if (vertices.length < 3) return null;
-  const e1 = sub(vertices[1], vertices[0]);
-  const e2 = sub(vertices[2], vertices[0]);
-  const n = cross(e1, e2);
-  const len = norm(n);
-  if (len < 1e-12) return null;
-  const normal = [n[0] / len, n[1] / len, n[2] / len];
-  const d = dot(normal, vertices[0]);
-  return { normal, d };
-}
-function samePlane(a, b) {
-  const dotN = dot(a.normal, b.normal);
-  if (dotN < 1 - EPS_NORMAL) return false;
-  return Math.abs(a.d - b.d) < EPS_DISTANCE;
-}
-function sameTexturePlane(a, b) {
-  const dotN = dot(a.normal, b.normal);
-  if (dotN < 1 - EPS_NORMAL) return false;
-  return Math.abs(a.d - b.d) < EPS_TEXTURE_DISTANCE;
-}
-function mergeAlongEdge(a, b, e0, e1) {
-  const ai0 = a.vertices.findIndex((v) => eqVec(v, e0));
-  const ai1 = a.vertices.findIndex((v) => eqVec(v, e1));
-  const bi0 = b.vertices.findIndex((v) => eqVec(v, e0));
-  const bi1 = b.vertices.findIndex((v) => eqVec(v, e1));
-  if (ai0 < 0 || ai1 < 0 || bi0 < 0 || bi1 < 0) return null;
-  const an = a.vertices.length;
-  const bn = b.vertices.length;
-  const aGoesForward = (ai0 + 1) % an === ai1;
-  const bGoesForward = (bi0 + 1) % bn === bi1;
-  if (aGoesForward === bGoesForward) return null;
-  const aStart = aGoesForward ? ai1 : ai0;
-  const aEnd = aGoesForward ? ai0 : ai1;
-  const bStart = bGoesForward ? bi1 : bi0;
-  const bEnd = bGoesForward ? bi0 : bi1;
-  const trackUvs = !!(a.uvs && b.uvs);
-  const merged = [];
-  const mergedUvs = trackUvs ? [] : void 0;
-  let i = aStart;
-  while (true) {
-    merged.push(a.vertices[i]);
-    if (mergedUvs) mergedUvs.push(a.uvs[i]);
-    if (i === aEnd) break;
-    i = (i + 1) % an;
-  }
-  i = bStart;
-  while (true) {
-    merged.push(b.vertices[i]);
-    if (mergedUvs) mergedUvs.push(b.uvs[i]);
-    if (i === bEnd) break;
-    i = (i + 1) % bn;
-  }
-  const dedupV = [];
-  const dedupU = mergedUvs ? [] : void 0;
-  for (let k = 0; k < merged.length; k++) {
-    if (dedupV.length === 0 || !eqVec(merged[k], dedupV[dedupV.length - 1])) {
-      dedupV.push(merged[k]);
-      if (dedupU && mergedUvs) dedupU.push(mergedUvs[k]);
-    }
-  }
-  if (dedupV.length > 1 && eqVec(dedupV[0], dedupV[dedupV.length - 1])) {
-    dedupV.pop();
-    dedupU?.pop();
-  }
-  if (trackUvs) return rotateToNonCollinearStart(dedupV, dedupU);
-  const cleaned = [];
-  const cleanedUvs = dedupU ? [] : void 0;
-  for (let k = 0; k < dedupV.length; k++) {
-    const prev = dedupV[(k - 1 + dedupV.length) % dedupV.length];
-    const cur = dedupV[k];
-    const next = dedupV[(k + 1) % dedupV.length];
-    const c = cross(sub(cur, prev), sub(next, prev));
-    if (norm(c) > 1e-9) {
-      cleaned.push(cur);
-      if (cleanedUvs && dedupU) cleanedUvs.push(dedupU[k]);
-    }
-  }
-  if (cleaned.length < 3) return null;
-  return rotateToNonCollinearStart(cleaned, cleanedUvs);
-}
-function isConvex(vertices, normal) {
-  const n = vertices.length;
-  let sign = 0;
-  for (let i = 0; i < n; i++) {
-    const a = vertices[i];
-    const b = vertices[(i + 1) % n];
-    const c = vertices[(i + 2) % n];
-    const e1 = sub(b, a);
-    const e2 = sub(c, b);
-    const turn = dot(cross(e1, e2), normal);
-    if (Math.abs(turn) < 1e-9) continue;
-    const s = turn > 0 ? 1 : -1;
-    if (sign === 0) sign = s;
-    else if (s !== sign) return false;
-  }
-  return true;
-}
-function mergeIsPlanar(vertices, epsilon) {
-  if (vertices.length < 3) return false;
-  const plane = planeOf(vertices);
-  if (!plane) return false;
-  for (const vertex of vertices) {
-    if (Math.abs(dot(plane.normal, vertex) - plane.d) > epsilon) {
-      return false;
-    }
-  }
-  return true;
-}
-function cloneTextureTriangles(triangles) {
-  return triangles.map((triangle) => ({
-    vertices: triangle.vertices.map((vertex) => [...vertex]),
-    uvs: triangle.uvs.map((uv) => [...uv])
-  }));
-}
-function fanTextureTriangles(vertices, uvs) {
-  const triangles = [];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    triangles.push({
-      vertices: [
-        [...vertices[0]],
-        [...vertices[i]],
-        [...vertices[i + 1]]
-      ],
-      uvs: [
-        [...uvs[0]],
-        [...uvs[i]],
-        [...uvs[i + 1]]
-      ]
-    });
-  }
-  return triangles;
-}
-function rotateToNonCollinearStart(vertices, uvs) {
-  for (let i = 0; i < vertices.length; i++) {
-    const a = vertices[i];
-    const b = vertices[(i + 1) % vertices.length];
-    const c = vertices[(i + 2) % vertices.length];
-    if (norm(cross(sub(b, a), sub(c, a))) <= 1e-9) continue;
-    if (i === 0) return { vertices, uvs };
-    return {
-      vertices: [...vertices.slice(i), ...vertices.slice(0, i)],
-      uvs: uvs ? [...uvs.slice(i), ...uvs.slice(0, i)] : void 0
-    };
-  }
-  return { vertices, uvs };
-}
-function mergePolygons(input) {
-  const out = [];
-  const polys = [];
-  for (const polygon of input ?? []) {
-    if (!polygon || !polygon.vertices || polygon.vertices.length < 3) {
-      if (polygon) out.push(polygon);
-      continue;
-    }
-    const verts = polygon.vertices.map((v) => [v[0], v[1], v[2]]);
-    const plane = planeOf(verts);
-    if (!plane) {
-      out.push(polygon);
-      continue;
-    }
-    const uvs = polygon.texture && polygon.uvs && polygon.uvs.length === verts.length ? polygon.uvs.map((uv) => [uv[0], uv[1]]) : void 0;
-    const textureTriangles = polygon.texture && uvs ? polygon.textureTriangles?.length ? cloneTextureTriangles(polygon.textureTriangles) : fanTextureTriangles(verts, uvs) : void 0;
-    polys.push({
-      vertices: verts,
-      uvs,
-      color: polygon.color ?? "#cccccc",
-      texture: polygon.texture,
-      textureTriangles,
-      normal: plane.normal,
-      d: plane.d,
-      alive: true,
-      data: polygon.data
-    });
-  }
-  const tryMergePass = () => {
-    const edgeIndex = /* @__PURE__ */ new Map();
-    for (let i = 0; i < polys.length; i++) {
-      const p = polys[i];
-      if (!p.alive) continue;
-      const n = p.vertices.length;
-      for (let k = 0; k < n; k++) {
-        const a = p.vertices[k];
-        const b = p.vertices[(k + 1) % n];
-        const key = edgeKey(a, b);
-        let arr = edgeIndex.get(key);
-        if (!arr) {
-          arr = [];
-          edgeIndex.set(key, arr);
-        }
-        arr.push(i);
-      }
-    }
-    let mergedThisPass = false;
-    const findSharedEdge = (a, b) => {
-      for (let k = 0; k < a.vertices.length; k++) {
-        const va = a.vertices[k];
-        const vb = a.vertices[(k + 1) % a.vertices.length];
-        for (let j = 0; j < b.vertices.length; j++) {
-          const ub = b.vertices[j];
-          const uc = b.vertices[(j + 1) % b.vertices.length];
-          if (eqVec(va, uc) && eqVec(vb, ub)) return [va, vb];
-        }
-      }
-      return null;
-    };
-    for (const [, owners] of edgeIndex) {
-      if (owners.length < 2) continue;
-      const [ai, bi] = owners;
-      if (ai === bi) continue;
-      const a = polys[ai];
-      const b = polys[bi];
-      if (!a.alive || !b.alive) continue;
-      if (a.color !== b.color) continue;
-      if (a.texture !== b.texture) continue;
-      const hasTexture = Boolean(a.texture || b.texture);
-      if (hasTexture && (!a.textureTriangles || !b.textureTriangles)) continue;
-      if (!!a.uvs !== !!b.uvs) continue;
-      if (hasTexture ? !sameTexturePlane(a, b) : !samePlane(a, b)) continue;
-      const shared = findSharedEdge(a, b);
-      if (!shared) continue;
-      const [e0, e1] = shared;
-      const merged = mergeAlongEdge(a, b, e0, e1);
-      if (!merged) continue;
-      if (!mergeIsPlanar(merged.vertices, hasTexture ? EPS_TEXTURE_DISTANCE : EPS_RENDER_DISTANCE)) continue;
-      if (!isConvex(merged.vertices, a.normal)) continue;
-      a.vertices = merged.vertices;
-      a.uvs = merged.uvs;
-      a.textureTriangles = hasTexture ? [...a.textureTriangles ?? [], ...b.textureTriangles ?? []] : void 0;
-      b.alive = false;
-      mergedThisPass = true;
-    }
-    return mergedThisPass;
-  };
-  while (tryMergePass()) {
-  }
-  for (const p of polys) {
-    if (!p.alive) continue;
-    const out_p = {
-      vertices: p.vertices,
-      color: p.color
-    };
-    if (p.texture) out_p.texture = p.texture;
-    if (p.uvs) out_p.uvs = p.uvs;
-    if (p.textureTriangles?.length) out_p.textureTriangles = p.textureTriangles;
-    if (p.data) out_p.data = p.data;
-    out.push(out_p);
-  }
-  return out;
-}
-
-// packages/core/src/merge/dedupeOverlappingPolygons.ts
-var DEFAULT_NORMAL_TOLERANCE = 1e-3;
-var DEFAULT_DISTANCE_TOLERANCE = 0.05;
-var DEFAULT_OVERLAP_FRACTION = 0.7;
-var BUCKET_NORMAL_STEP = 0.05;
-var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-var cross2 = (a, b) => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0]
-];
-var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-function computeMeta(polygon, index) {
-  const v = polygon.vertices;
-  if (!v || v.length < 3) return null;
-  let nx = 0, ny = 0, nz = 0;
-  for (let i = 0; i < v.length; i++) {
-    const a = v[i];
-    const b = v[(i + 1) % v.length];
-    nx += (a[1] - b[1]) * (a[2] + b[2]);
-    ny += (a[2] - b[2]) * (a[0] + b[0]);
-    nz += (a[0] - b[0]) * (a[1] + b[1]);
-  }
-  const nLen = Math.hypot(nx, ny, nz);
-  if (nLen < 1e-12) return null;
-  const normal = [nx / nLen, ny / nLen, nz / nLen];
-  let cx = 0, cy = 0, cz = 0;
-  for (const p of v) {
-    cx += p[0];
-    cy += p[1];
-    cz += p[2];
-  }
-  const inv = 1 / v.length;
-  const centroid = [cx * inv, cy * inv, cz * inv];
-  const d = dot2(normal, centroid);
-  const area = nLen * 0.5;
-  return {
-    index,
-    polygon,
-    normal,
-    d,
-    centroid,
-    area,
-    local2D: null,
-    bbox2D: null,
-    basis: null
-  };
-}
-function planeBasis(normal) {
-  const axis = Math.abs(normal[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  let ux = axis[0] - normal[0] * dot2(axis, normal);
-  let uy = axis[1] - normal[1] * dot2(axis, normal);
-  let uz = axis[2] - normal[2] * dot2(axis, normal);
-  const uLen = Math.hypot(ux, uy, uz);
-  ux /= uLen;
-  uy /= uLen;
-  uz /= uLen;
-  const u = [ux, uy, uz];
-  const v = cross2(normal, u);
-  return { u, v };
-}
-function ensure2D(meta) {
-  if (meta.local2D) return;
-  const basis2 = planeBasis(meta.normal);
-  const local2D = [];
-  let minU = Infinity, minV = Infinity;
-  let maxU = -Infinity, maxV = -Infinity;
-  for (const p of meta.polygon.vertices) {
-    const u = dot2(p, basis2.u);
-    const v = dot2(p, basis2.v);
-    local2D.push([u, v]);
-    if (u < minU) minU = u;
-    if (u > maxU) maxU = u;
-    if (v < minV) minV = v;
-    if (v > maxV) maxV = v;
-  }
-  meta.local2D = local2D;
-  meta.bbox2D = { min: [minU, minV], max: [maxU, maxV] };
-  meta.basis = basis2;
-}
-function projectInto(polygon, basis2) {
-  const local2D = [];
-  let minU = Infinity, minV = Infinity;
-  let maxU = -Infinity, maxV = -Infinity;
-  for (const p of polygon.vertices) {
-    const u = dot2(p, basis2.u);
-    const v = dot2(p, basis2.v);
-    local2D.push([u, v]);
-    if (u < minU) minU = u;
-    if (u > maxU) maxU = u;
-    if (v < minV) minV = v;
-    if (v > maxV) maxV = v;
-  }
-  return { local2D, bbox2D: { min: [minU, minV], max: [maxU, maxV] } };
-}
-function bboxOverlap2D(a, b) {
-  return a.max[0] >= b.min[0] && a.min[0] <= b.max[0] && a.max[1] >= b.min[1] && a.min[1] <= b.max[1];
-}
-function pointInPolygon2D(p, poly) {
-  let inside = false;
-  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
-    const a = poly[i], b = poly[j];
-    const intersect = a[1] > p[1] !== b[1] > p[1] && p[0] < (b[0] - a[0]) * (p[1] - a[1]) / (b[1] - a[1] + 1e-30) + a[0];
-    if (intersect) inside = !inside;
-  }
-  return inside;
-}
-function centroid2D(poly) {
-  let cx = 0, cy = 0;
-  for (const p of poly) {
-    cx += p[0];
-    cy += p[1];
-  }
-  return [cx / poly.length, cy / poly.length];
-}
-function overlapScore2D(a, b) {
-  const aC = centroid2D(a);
-  const bC = centroid2D(b);
-  const inset = 1e-4;
-  let hitsAinB = 0;
-  for (const p of a) {
-    const testP = [
-      p[0] + (aC[0] - p[0]) * inset,
-      p[1] + (aC[1] - p[1]) * inset
-    ];
-    if (pointInPolygon2D(testP, b)) hitsAinB++;
-  }
-  let hitsBinA = 0;
-  for (const p of b) {
-    const testP = [
-      p[0] + (bC[0] - p[0]) * inset,
-      p[1] + (bC[1] - p[1]) * inset
-    ];
-    if (pointInPolygon2D(testP, a)) hitsBinA++;
-  }
-  const aIn = hitsAinB / a.length;
-  const bIn = hitsBinA / b.length;
-  return Math.max(aIn, bIn);
-}
-function bucketKey(meta, distanceTolerance) {
-  let nx = meta.normal[0], ny = meta.normal[1], nz = meta.normal[2];
-  const absX = Math.abs(nx), absY = Math.abs(ny), absZ = Math.abs(nz);
-  let dominant = nx;
-  if (absY > absX && absY > absZ) dominant = ny;
-  else if (absZ > absX && absZ > absY) dominant = nz;
-  if (dominant < 0) {
-    nx = -nx;
-    ny = -ny;
-    nz = -nz;
-  }
-  const qx = Math.round(nx / BUCKET_NORMAL_STEP);
-  const qy = Math.round(ny / BUCKET_NORMAL_STEP);
-  const qz = Math.round(nz / BUCKET_NORMAL_STEP);
-  const dAbs = meta.d * (meta.normal[0] === nx && meta.normal[1] === ny && meta.normal[2] === nz ? 1 : -1);
-  const qd = Math.round(dAbs / (distanceTolerance * 2));
-  return `${qx},${qy},${qz}|${qd}`;
-}
-function coplanar(a, b, normalTolerance, distanceTolerance) {
-  const d = dot2(a.normal, b.normal);
-  if (Math.abs(d) < 1 - normalTolerance) return false;
-  const sign = d > 0 ? 1 : -1;
-  return Math.abs(a.d - sign * b.d) < distanceTolerance;
-}
-function facesInward(meta, meshCentroid) {
-  const toCenter = sub2(meshCentroid, meta.centroid);
-  return dot2(meta.normal, toCenter) > 0;
-}
-function findOverlappingPolygonDuplicates(input, options) {
-  if (!input || input.length < 2) return /* @__PURE__ */ new Set();
-  const normalTolerance = options?.normalTolerance ?? DEFAULT_NORMAL_TOLERANCE;
-  const distanceTolerance = options?.distanceTolerance ?? DEFAULT_DISTANCE_TOLERANCE;
-  const overlapFraction = options?.overlapFraction ?? DEFAULT_OVERLAP_FRACTION;
-  const metas = [];
-  for (let i = 0; i < input.length; i++) {
-    const m = computeMeta(input[i], i);
-    if (m) metas.push(m);
-  }
-  if (metas.length < 2) return /* @__PURE__ */ new Set();
-  let mcx = 0, mcy = 0, mcz = 0, totalArea = 0;
-  for (const m of metas) {
-    mcx += m.centroid[0] * m.area;
-    mcy += m.centroid[1] * m.area;
-    mcz += m.centroid[2] * m.area;
-    totalArea += m.area;
-  }
-  const meshCentroid = totalArea > 0 ? [mcx / totalArea, mcy / totalArea, mcz / totalArea] : [0, 0, 0];
-  const buckets = /* @__PURE__ */ new Map();
-  for (const m of metas) {
-    const key = bucketKey(m, distanceTolerance);
-    let arr = buckets.get(key);
-    if (!arr) {
-      arr = [];
-      buckets.set(key, arr);
-    }
-    arr.push(m);
-  }
-  const dropped = /* @__PURE__ */ new Set();
-  for (const arr of buckets.values()) {
-    if (arr.length < 2) continue;
-    for (let i = 0; i < arr.length; i++) {
-      const a = arr[i];
-      if (dropped.has(a.index)) continue;
-      for (let j = i + 1; j < arr.length; j++) {
-        const b = arr[j];
-        if (dropped.has(b.index)) continue;
-        if (!coplanar(a, b, normalTolerance, distanceTolerance)) continue;
-        ensure2D(a);
-        const bProj = projectInto(b.polygon, a.basis);
-        if (!bboxOverlap2D(a.bbox2D, bProj.bbox2D)) continue;
-        const score = overlapScore2D(a.local2D, bProj.local2D);
-        if (score < overlapFraction) continue;
-        const aInward = facesInward(a, meshCentroid);
-        const bInward = facesInward(b, meshCentroid);
-        let drop;
-        if (aInward && !bInward) drop = a;
-        else if (bInward && !aInward) drop = b;
-        else drop = a.area < b.area ? a : b;
-        dropped.add(drop.index);
-        if (drop === a) break;
-      }
-    }
-  }
-  return dropped;
-}
-
-// packages/core/src/merge/coverPlanarPolygons.ts
-var DEFAULT_MIN_GROUP = 4;
-var DEFAULT_MAX_AXES = 8;
-var DEFAULT_PLANE_EPSILON = 1e-3;
-var EPS = 1e-9;
-var LOCAL_ROUND = 1e6;
-var WORLD_ROUND = 1e6;
-var sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-var scale = (v, n) => [v[0] * n, v[1] * n, v[2] * n];
-var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-var cross3 = (a, b) => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0]
-];
-var length = (v) => Math.hypot(v[0], v[1], v[2]);
-function normalize(v) {
-  const len = length(v);
-  if (len <= EPS) return null;
-  return [v[0] / len, v[1] / len, v[2] / len];
-}
-function round(value, factor) {
-  return Math.round(value * factor) / factor;
-}
-function roundLocal(value) {
-  return round(value, LOCAL_ROUND);
-}
-function roundWorld(value) {
-  return round(value, WORLD_ROUND);
-}
-function eq2(a, b) {
-  return Math.abs(a[0] - b[0]) <= 1e-7 && Math.abs(a[1] - b[1]) <= 1e-7;
-}
-function pointKey(point) {
-  return `${roundLocal(point[0])},${roundLocal(point[1])}`;
-}
-function undirectedSegmentKey(segment) {
-  const ak = pointKey(segment.a);
-  const bk = pointKey(segment.b);
-  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
-}
-function vecKey(v) {
-  return `${v[0]},${v[1]},${v[2]}`;
-}
-function edgeKey2(a, b) {
-  const ak = vecKey(a);
-  const bk = vecKey(b);
-  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
-}
-function dataKey(data) {
-  if (!data) return "";
-  return Object.keys(data).sort().map((key) => `${key}:${String(data[key])}`).join("|");
-}
-function materialKey(polygon) {
-  return [
-    polygon.color ?? "#cccccc",
-    polygon.texture ?? "",
-    polygon.uvs ? "uv" : "plain",
-    dataKey(polygon.data)
-  ].join("|");
-}
-function planeOf2(polygon) {
-  const vertices = polygon.vertices;
-  if (!vertices || vertices.length < 3) return null;
-  const origin = vertices[0];
-  let normalSum = [0, 0, 0];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    normalSum = add(normalSum, cross3(sub3(vertices[i], origin), sub3(vertices[i + 1], origin)));
-  }
-  const normal = normalize(normalSum);
-  if (!normal) return null;
-  return { normal, d: dot3(normal, origin) };
-}
-function samePlane2(a, b, epsilon) {
-  return dot3(a.normal, b.normal) > 1 - epsilon && Math.abs(a.d - b.d) <= epsilon;
-}
-function canCover(polygon) {
-  return !polygon.texture && !polygon.uvs && !polygon.textureTriangles;
-}
-function sharedData(group, polygons) {
-  const first = polygons[group[0]]?.data;
-  const firstKey = dataKey(first);
-  for (const index of group) {
-    if (dataKey(polygons[index].data) !== firstKey) return void 0;
-  }
-  return first ? { ...first } : void 0;
-}
-function buildGroups(polygons, planeEpsilon) {
-  const planes = polygons.map((polygon) => canCover(polygon) ? planeOf2(polygon) : null);
-  const eligible = planes.map(Boolean);
-  const edgeOwners = /* @__PURE__ */ new Map();
-  for (let i = 0; i < polygons.length; i++) {
-    if (!planes[i]) continue;
-    const vertices = polygons[i].vertices;
-    for (let edge = 0; edge < vertices.length; edge++) {
-      const key = edgeKey2(vertices[edge], vertices[(edge + 1) % vertices.length]);
-      const owners = edgeOwners.get(key);
-      const owner = { polygon: i, edge };
-      if (owners) owners.push(owner);
-      else edgeOwners.set(key, [owner]);
-    }
-  }
-  const adjacency = polygons.map(() => /* @__PURE__ */ new Set());
-  for (const owners of edgeOwners.values()) {
-    if (owners.length < 2) continue;
-    for (let i = 0; i < owners.length; i++) {
-      for (let j = i + 1; j < owners.length; j++) {
-        const a = owners[i].polygon;
-        const b = owners[j].polygon;
-        const planeA = planes[a];
-        const planeB = planes[b];
-        if (!planeA || !planeB) continue;
-        if (materialKey(polygons[a]) !== materialKey(polygons[b])) continue;
-        if (!samePlane2(planeA, planeB, planeEpsilon)) continue;
-        adjacency[a].add(b);
-        adjacency[b].add(a);
-      }
-    }
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const groups = [];
-  for (let i = 0; i < polygons.length; i++) {
-    if (!eligible[i] || visited.has(i)) continue;
-    const group = [];
-    const queue = [i];
-    visited.add(i);
-    while (queue.length > 0) {
-      const current = queue.shift();
-      group.push(current);
-      for (const next of adjacency[current]) {
-        if (visited.has(next)) continue;
-        visited.add(next);
-        queue.push(next);
-      }
-    }
-    groups.push(group);
-  }
-  return { groups };
-}
-function boundaryEdgesForGroup(group, polygons) {
-  const groupSet = new Set(group);
-  const owners = /* @__PURE__ */ new Map();
-  for (const polygonIndex of group) {
-    const vertices = polygons[polygonIndex].vertices;
-    for (let edge = 0; edge < vertices.length; edge++) {
-      const key = edgeKey2(vertices[edge], vertices[(edge + 1) % vertices.length]);
-      const list = owners.get(key);
-      const owner = { polygon: polygonIndex, edge };
-      if (list) list.push(owner);
-      else owners.set(key, [owner]);
-    }
-  }
-  const boundary = [];
-  for (const list of owners.values()) {
-    const localOwners = list.filter((owner) => groupSet.has(owner.polygon));
-    if (localOwners.length === 1) {
-      const owner = localOwners[0];
-      const vertices = polygons[owner.polygon].vertices;
-      boundary.push({
-        a: vertices[owner.edge],
-        b: vertices[(owner.edge + 1) % vertices.length]
-      });
-    } else if (localOwners.length !== 2) {
-      return null;
-    }
-  }
-  return boundary;
-}
-function boundaryIsClosed(boundary) {
-  const degree = /* @__PURE__ */ new Map();
-  for (const edge of boundary) {
-    degree.set(vecKey(edge.a), (degree.get(vecKey(edge.a)) ?? 0) + 1);
-    degree.set(vecKey(edge.b), (degree.get(vecKey(edge.b)) ?? 0) + 1);
-  }
-  for (const count of degree.values()) {
-    if (count % 2 !== 0) return false;
-  }
-  return true;
-}
-function canonicalAxis(axis) {
-  const out = [axis[0], axis[1], axis[2]];
-  const major = Math.abs(out[0]) >= Math.abs(out[1]) && Math.abs(out[0]) >= Math.abs(out[2]) ? 0 : Math.abs(out[1]) >= Math.abs(out[2]) ? 1 : 2;
-  if (out[major] < 0) return [-out[0], -out[1], -out[2]];
-  return out;
-}
-function axisKey(axis) {
-  const canonical = canonicalAxis(axis);
-  return `${round(canonical[0], 1e3)},${round(canonical[1], 1e3)},${round(canonical[2], 1e3)}`;
-}
-function fallbackAxis(normal) {
-  const seed = Math.abs(normal[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const projected = sub3(seed, scale(normal, dot3(seed, normal)));
-  return normalize(projected) ?? [1, 0, 0];
-}
-function candidateAxes(boundary, normal, maxAxes) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const edge of boundary) {
-    const edgeVector = sub3(edge.b, edge.a);
-    const projected = sub3(edgeVector, scale(normal, dot3(edgeVector, normal)));
-    const axis = normalize(projected);
-    if (!axis) continue;
-    const canonical = canonicalAxis(axis);
-    const key = axisKey(canonical);
-    const weight = length(projected);
-    const current = byKey.get(key);
-    if (current) current.weight += weight;
-    else byKey.set(key, { axis: canonical, weight });
-  }
-  const axes = [...byKey.values()].sort((a, b) => b.weight - a.weight).slice(0, maxAxes).map((candidate) => candidate.axis);
-  if (axes.length === 0) axes.push(fallbackAxis(normal));
-  return axes;
-}
-function projectPoint(point, origin, xAxis, yAxis) {
-  const local = sub3(point, origin);
-  return [roundLocal(dot3(local, xAxis)), roundLocal(dot3(local, yAxis))];
-}
-function uniqueSorted(values) {
-  const sorted = [...values].sort((a, b) => a - b);
-  const out = [];
-  for (const value of sorted) {
-    if (out.length === 0 || Math.abs(value - out[out.length - 1]) > 1e-7) {
-      out.push(value);
-    }
-  }
-  return out;
-}
-function segmentYAt(segment, x) {
-  const [x0, y0] = segment.a;
-  const [x1, y1] = segment.b;
-  const t = (x - x0) / (x1 - x0);
-  return roundLocal(y0 + (y1 - y0) * t);
-}
-function cleanLocalPolygon(points) {
-  const dedup = [];
-  for (const point of points) {
-    if (dedup.length === 0 || Math.abs(point[0] - dedup[dedup.length - 1][0]) > 1e-7 || Math.abs(point[1] - dedup[dedup.length - 1][1]) > 1e-7) {
-      dedup.push(point);
-    }
-  }
-  if (dedup.length > 1 && Math.abs(dedup[0][0] - dedup[dedup.length - 1][0]) <= 1e-7 && Math.abs(dedup[0][1] - dedup[dedup.length - 1][1]) <= 1e-7) {
-    dedup.pop();
-  }
-  const cleaned = [];
-  for (let i = 0; i < dedup.length; i++) {
-    const prev = dedup[(i - 1 + dedup.length) % dedup.length];
-    const current = dedup[i];
-    const next = dedup[(i + 1) % dedup.length];
-    const cross22 = (current[0] - prev[0]) * (next[1] - current[1]) - (current[1] - prev[1]) * (next[0] - current[0]);
-    if (Math.abs(cross22) > 1e-8) cleaned.push(current);
-  }
-  return cleaned;
-}
-function signedArea(points) {
-  let area = 0;
-  for (let i = 0; i < points.length; i++) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    area += a[0] * b[1] - b[0] * a[1];
-  }
-  return area / 2;
-}
-function localBBox(points) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of points) {
-    minX = Math.min(minX, x);
-    minY = Math.min(minY, y);
-    maxX = Math.max(maxX, x);
-    maxY = Math.max(maxY, y);
-  }
-  return { minX, minY, maxX, maxY };
-}
-function localBBoxesCanTouch(ab, bb) {
-  return !(ab.maxX < bb.minX - 1e-7 || bb.maxX < ab.minX - 1e-7 || ab.maxY < bb.minY - 1e-7 || bb.maxY < ab.minY - 1e-7);
-}
-function localAreaAbs(points) {
-  return Math.abs(signedArea(points));
-}
-function isConvexLocal(points) {
-  if (points.length < 3) return false;
-  let sign = 0;
-  for (let i = 0; i < points.length; i++) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    const c = points[(i + 2) % points.length];
-    const turn = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
-    if (Math.abs(turn) <= 1e-8) continue;
-    const nextSign = turn > 0 ? 1 : -1;
-    if (sign === 0) sign = nextSign;
-    else if (sign !== nextSign) return false;
-  }
-  return true;
-}
-function pointOnSegment(point, a, b) {
-  const abx = b[0] - a[0];
-  const aby = b[1] - a[1];
-  const apx = point[0] - a[0];
-  const apy = point[1] - a[1];
-  const cross22 = abx * apy - aby * apx;
-  const len = Math.hypot(abx, aby);
-  if (len <= 1e-9 || Math.abs(cross22) > Math.max(1e-8, len * 1e-8)) return false;
-  const dot22 = apx * abx + apy * aby;
-  return dot22 >= -1e-8 && dot22 <= abx * abx + aby * aby + 1e-8;
-}
-function pointParameterOnSegment(point, a, b) {
-  const dx = b[0] - a[0];
-  const dy = b[1] - a[1];
-  const denom = dx * dx + dy * dy;
-  if (denom <= 1e-12) return 0;
-  return ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy) / denom;
-}
-function colinearSegmentsOverlap(a0, a1, b0, b1) {
-  const ax = a1[0] - a0[0];
-  const ay = a1[1] - a0[1];
-  const bx = b1[0] - b0[0];
-  const by = b1[1] - b0[1];
-  const aLen = Math.hypot(ax, ay);
-  const bLen = Math.hypot(bx, by);
-  if (aLen <= 1e-9 || bLen <= 1e-9) return false;
-  const crossB0 = ax * (b0[1] - a0[1]) - ay * (b0[0] - a0[0]);
-  const crossB1 = ax * (b1[1] - a0[1]) - ay * (b1[0] - a0[0]);
-  const crossAxes = ax * by - ay * bx;
-  const tolerance = Math.max(1e-8, Math.max(aLen, bLen) * 1e-8);
-  if (Math.abs(crossB0) > tolerance || Math.abs(crossB1) > tolerance || Math.abs(crossAxes) > tolerance) {
-    return false;
-  }
-  const useX = Math.abs(ax) >= Math.abs(ay);
-  const aMin = Math.min(useX ? a0[0] : a0[1], useX ? a1[0] : a1[1]);
-  const aMax = Math.max(useX ? a0[0] : a0[1], useX ? a1[0] : a1[1]);
-  const bMin = Math.min(useX ? b0[0] : b0[1], useX ? b1[0] : b1[1]);
-  const bMax = Math.max(useX ? b0[0] : b0[1], useX ? b1[0] : b1[1]);
-  return Math.min(aMax, bMax) - Math.max(aMin, bMin) > 1e-8;
-}
-function polygonsMayShareBoundary(a, b) {
-  for (let i = 0; i < a.length; i++) {
-    const a0 = a[i];
-    const a1 = a[(i + 1) % a.length];
-    for (let j = 0; j < b.length; j++) {
-      if (colinearSegmentsOverlap(a0, a1, b[j], b[(j + 1) % b.length])) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function splitDirectedEdges(polygon, splitPoints) {
-  const segments = [];
-  for (let i = 0; i < polygon.length; i++) {
-    const a = polygon[i];
-    const b = polygon[(i + 1) % polygon.length];
-    const splits = [
-      { t: 0, point: a },
-      { t: 1, point: b }
-    ];
-    for (const point of splitPoints) {
-      if (eq2(point, a) || eq2(point, b)) continue;
-      if (!pointOnSegment(point, a, b)) continue;
-      splits.push({
-        t: pointParameterOnSegment(point, a, b),
-        point
-      });
-    }
-    splits.sort((left, right) => left.t - right.t);
-    const unique = [];
-    for (const split of splits) {
-      if (unique.some((item) => Math.abs(item.t - split.t) <= 1e-8 || eq2(item.point, split.point))) continue;
-      unique.push(split);
-    }
-    for (let j = 0; j < unique.length - 1; j++) {
-      const start = unique[j].point;
-      const end = unique[j + 1].point;
-      if (Math.hypot(end[0] - start[0], end[1] - start[1]) <= 1e-8) continue;
-      segments.push({
-        a: [roundLocal(start[0]), roundLocal(start[1])],
-        b: [roundLocal(end[0]), roundLocal(end[1])]
-      });
-    }
-  }
-  return segments;
-}
-function unionConvexLocalPair(a, b, aBBox = localBBox(a), bBBox = localBBox(b)) {
-  if (!localBBoxesCanTouch(aBBox, bBBox) || !polygonsMayShareBoundary(a, b)) return null;
-  const pieces = [
-    ...splitDirectedEdges(a, b),
-    ...splitDirectedEdges(b, a)
-  ];
-  const grouped = /* @__PURE__ */ new Map();
-  for (const segment of pieces) {
-    const key = undirectedSegmentKey(segment);
-    const current = grouped.get(key);
-    if (current) current.push(segment);
-    else grouped.set(key, [segment]);
-  }
-  let hadSharedEdge = false;
-  const boundary = [];
-  for (const group of grouped.values()) {
-    if (group.length === 1) {
-      boundary.push(group[0]);
-      continue;
-    }
-    hadSharedEdge = true;
-    const forward = group.filter((segment) => pointKey(segment.a) < pointKey(segment.b)).length;
-    const backward = group.length - forward;
-    if (forward !== backward) return null;
-  }
-  if (!hadSharedEdge || boundary.length < 3) return null;
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const segment of boundary) {
-    const key = pointKey(segment.a);
-    if (outgoing.has(key)) return null;
-    outgoing.set(key, segment);
-  }
-  const start = boundary[0];
-  const startKey = pointKey(start.a);
-  const loop = [];
-  const used = /* @__PURE__ */ new Set();
-  let currentKey = startKey;
-  for (let guard = 0; guard <= boundary.length; guard++) {
-    const segment = outgoing.get(currentKey);
-    if (!segment) return null;
-    const edgeKey22 = `${pointKey(segment.a)}>${pointKey(segment.b)}`;
-    if (used.has(edgeKey22)) return null;
-    used.add(edgeKey22);
-    loop.push(segment.a);
-    currentKey = pointKey(segment.b);
-    if (currentKey === startKey) break;
-  }
-  if (currentKey !== startKey || used.size !== boundary.length) return null;
-  const cleaned = cleanLocalPolygon(loop);
-  if (cleaned.length < 3 || !isConvexLocal(cleaned)) return null;
-  const area = localAreaAbs(cleaned);
-  const expectedArea = localAreaAbs(a) + localAreaAbs(b);
-  if (Math.abs(area - expectedArea) > Math.max(1e-5, expectedArea * 1e-5)) return null;
-  return signedArea(cleaned) >= 0 ? cleaned : [...cleaned].reverse();
-}
-function mergeLocalCells(cells) {
-  const polygons = cells.map(cleanLocalPolygon).filter((polygon) => polygon.length >= 3 && localAreaAbs(polygon) > 1e-8);
-  const bboxes = polygons.map(localBBox);
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (let i = 0; i < polygons.length; i++) {
-      for (let j = i + 1; j < polygons.length; j++) {
-        const merged = unionConvexLocalPair(polygons[i], polygons[j], bboxes[i], bboxes[j]);
-        if (!merged) continue;
-        polygons[i] = merged;
-        bboxes[i] = localBBox(merged);
-        polygons.splice(j, 1);
-        bboxes.splice(j, 1);
-        changed = true;
-        break;
-      }
-      if (changed) break;
-    }
-  }
-  return polygons;
-}
-function localToWorldFactory(origin, xAxis, yAxis) {
-  const snap = /* @__PURE__ */ new Map();
-  return (point) => {
-    const x = roundLocal(point[0]);
-    const y = roundLocal(point[1]);
-    const key = `${x},${y}`;
-    const existing = snap.get(key);
-    if (existing) return [existing[0], existing[1], existing[2]];
-    const world = add(origin, add(scale(xAxis, x), scale(yAxis, y)));
-    const rounded = [roundWorld(world[0]), roundWorld(world[1]), roundWorld(world[2])];
-    snap.set(key, rounded);
-    return [rounded[0], rounded[1], rounded[2]];
-  };
-}
-function decomposeWithAxis(group, polygons, boundary, normal, xAxisInput) {
-  const origin = boundary[0]?.a;
-  if (!origin) return null;
-  const xAxisProjected = normalize(sub3(xAxisInput, scale(normal, dot3(xAxisInput, normal))));
-  if (!xAxisProjected) return null;
-  const yAxis = normalize(cross3(normal, xAxisProjected));
-  if (!yAxis) return null;
-  const segments = [];
-  const xs = [];
-  for (const edge of boundary) {
-    const a = projectPoint(edge.a, origin, xAxisProjected, yAxis);
-    const b = projectPoint(edge.b, origin, xAxisProjected, yAxis);
-    if (Math.hypot(a[0] - b[0], a[1] - b[1]) <= 1e-7) continue;
-    segments.push({ a, b });
-    xs.push(a[0], b[0]);
-  }
-  const sortedXs = uniqueSorted(xs);
-  if (segments.length < 3 || sortedXs.length < 2) return null;
-  const color = polygons[group[0]].color;
-  const data = sharedData(group, polygons);
-  const localCells = [];
-  for (let i = 0; i < sortedXs.length - 1; i++) {
-    const x0 = sortedXs[i];
-    const x1 = sortedXs[i + 1];
-    if (x1 - x0 <= 1e-7) continue;
-    const xm = (x0 + x1) / 2;
-    const active = segments.filter((segment) => {
-      const minX = Math.min(segment.a[0], segment.b[0]);
-      const maxX = Math.max(segment.a[0], segment.b[0]);
-      return minX < xm && xm < maxX && Math.abs(segment.a[0] - segment.b[0]) > 1e-7;
-    }).map((segment) => ({
-      segment,
-      yMid: segmentYAt(segment, xm)
-    })).sort((a, b) => a.yMid - b.yMid);
-    if (active.length === 0) continue;
-    if (active.length % 2 !== 0) return null;
-    for (let j = 0; j < active.length; j += 2) {
-      const low = active[j].segment;
-      const high = active[j + 1].segment;
-      const low0 = segmentYAt(low, x0);
-      const low1 = segmentYAt(low, x1);
-      const high0 = segmentYAt(high, x0);
-      const high1 = segmentYAt(high, x1);
-      const local = cleanLocalPolygon([
-        [x0, low0],
-        [x1, low1],
-        [x1, high1],
-        [x0, high0]
-      ]);
-      if (local.length < 3 || Math.abs(signedArea(local)) <= 1e-8) continue;
-      const oriented = signedArea(local) > 0 ? local : [...local].reverse();
-      localCells.push(oriented);
-    }
-  }
-  if (localCells.length === 0) return null;
-  const toWorld = localToWorldFactory(origin, xAxisProjected, yAxis);
-  const cells = mergeLocalCells(localCells).map((local) => ({
-    vertices: local.map(toWorld),
-    ...color ? { color } : {},
-    ...data ? { data } : {}
-  }));
-  return mergePolygons(cells);
-}
-function optimizeGroup(group, polygons, maxCandidateAxes) {
-  const boundary = boundaryEdgesForGroup(group, polygons);
-  if (!boundary || boundary.length < 3 || !boundaryIsClosed(boundary)) return null;
-  const plane = planeOf2(polygons[group[0]]);
-  if (!plane) return null;
-  let best = null;
-  for (const axis of candidateAxes(boundary, plane.normal, maxCandidateAxes)) {
-    const result = decomposeWithAxis(group, polygons, boundary, plane.normal, axis);
-    if (!result) continue;
-    if (!best || result.length < best.length) best = result;
-  }
-  if (!best || best.length >= group.length) return null;
-  return best;
-}
-function coverPlanarPolygons(input, options = {}) {
-  const minGroupPolygons = options.minGroupPolygons ?? DEFAULT_MIN_GROUP;
-  const maxCandidateAxes = options.maxCandidateAxes ?? DEFAULT_MAX_AXES;
-  const planeEpsilon = options.planeEpsilon ?? DEFAULT_PLANE_EPSILON;
-  const polygons = input ?? [];
-  if (polygons.length < minGroupPolygons) return polygons;
-  const { groups } = buildGroups(polygons, planeEpsilon);
-  if (groups.length === 0) return polygons;
-  const replacements = /* @__PURE__ */ new Map();
-  const replaced = /* @__PURE__ */ new Set();
-  for (const group of groups) {
-    if (group.length < minGroupPolygons) continue;
-    const optimized = optimizeGroup(group, polygons, maxCandidateAxes);
-    if (!optimized) continue;
-    replacements.set(group[0], optimized);
-    for (const index of group) replaced.add(index);
-  }
-  if (replacements.size === 0) return polygons;
-  const output = [];
-  for (let i = 0; i < polygons.length; i++) {
-    const replacement = replacements.get(i);
-    if (replacement) {
-      output.push(...replacement);
-      continue;
-    }
-    if (replaced.has(i)) continue;
-    output.push(polygons[i]);
-  }
-  return output;
-}
-
-// packages/core/src/cull/cullInteriorPolygons.ts
-var DEFAULT_HEMISPHERE_SAMPLES = 8;
-var RAY_ORIGIN_OFFSET = 1e-3;
-var MIN_HIT_T = 1e-3;
-var PARALLEL_EPS = 1e-9;
-var ORIGIN_INSET = 0.08;
-function precompute(p) {
-  const verts = p.vertices;
-  if (!verts || verts.length < 3) return null;
-  let cx = 0, cy = 0, cz = 0;
-  for (const [x, y, z] of verts) {
-    cx += x;
-    cy += y;
-    cz += z;
-  }
-  const inv = 1 / verts.length;
-  cx *= inv;
-  cy *= inv;
-  cz *= inv;
-  const v0 = verts[0], v1 = verts[1], v2 = verts[2];
-  const e1x = v1[0] - v0[0], e1y = v1[1] - v0[1], e1z = v1[2] - v0[2];
-  const e2x = v2[0] - v0[0], e2y = v2[1] - v0[1], e2z = v2[2] - v0[2];
-  let nx = e1y * e2z - e1z * e2y;
-  let ny = e1z * e2x - e1x * e2z;
-  let nz = e1x * e2y - e1y * e2x;
-  const nLen = Math.hypot(nx, ny, nz);
-  if (nLen < PARALLEL_EPS) return null;
-  nx /= nLen;
-  ny /= nLen;
-  nz /= nLen;
-  const nTri = verts.length - 2;
-  const triFlat = new Float64Array(nTri * 9);
-  let ti = 0;
-  for (let i = 1; i < verts.length - 1; i++) {
-    const a = verts[0], b = verts[i], c = verts[i + 1];
-    triFlat[ti++] = a[0];
-    triFlat[ti++] = a[1];
-    triFlat[ti++] = a[2];
-    triFlat[ti++] = b[0];
-    triFlat[ti++] = b[1];
-    triFlat[ti++] = b[2];
-    triFlat[ti++] = c[0];
-    triFlat[ti++] = c[1];
-    triFlat[ti++] = c[2];
-  }
-  let br2 = 0;
-  let minX = Infinity, minY = Infinity, minZ = Infinity;
-  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-  for (const [x, y, z] of verts) {
-    const ddx = x - cx, ddy = y - cy, ddz = z - cz;
-    const d2 = ddx * ddx + ddy * ddy + ddz * ddz;
-    if (d2 > br2) br2 = d2;
-    if (x < minX) minX = x;
-    if (x > maxX) maxX = x;
-    if (y < minY) minY = y;
-    if (y > maxY) maxY = y;
-    if (z < minZ) minZ = z;
-    if (z > maxZ) maxZ = z;
-  }
-  return {
-    centroid: [cx, cy, cz],
-    normal: [nx, ny, nz],
-    vertices: verts,
-    triFlat,
-    bcx: cx,
-    bcy: cy,
-    bcz: cz,
-    br2,
-    minX,
-    minY,
-    minZ,
-    maxX,
-    maxY,
-    maxZ
-  };
-}
-function rayTriFlat(ox, oy, oz, dx, dy, dz, tf, base) {
-  const ax = tf[base], ay = tf[base + 1], az = tf[base + 2];
-  const e1x = tf[base + 3] - ax, e1y = tf[base + 4] - ay, e1z = tf[base + 5] - az;
-  const e2x = tf[base + 6] - ax, e2y = tf[base + 7] - ay, e2z = tf[base + 8] - az;
-  const hx = dy * e2z - dz * e2y;
-  const hy = dz * e2x - dx * e2z;
-  const hz = dx * e2y - dy * e2x;
-  const det = e1x * hx + e1y * hy + e1z * hz;
-  if (det > -PARALLEL_EPS && det < PARALLEL_EPS) return false;
-  const invDet = 1 / det;
-  const sx = ox - ax, sy = oy - ay, sz = oz - az;
-  const u = invDet * (sx * hx + sy * hy + sz * hz);
-  if (u < 0 || u > 1) return false;
-  const qx = sy * e1z - sz * e1y;
-  const qy = sz * e1x - sx * e1z;
-  const qz = sx * e1y - sy * e1x;
-  const v = invDet * (dx * qx + dy * qy + dz * qz);
-  if (v < 0 || u + v > 1) return false;
-  return invDet * (e2x * qx + e2y * qy + e2z * qz) > MIN_HIT_T;
-}
-function rayHitsPolygon(ox, oy, oz, dx, dy, dz, q) {
-  const vx = q.bcx - ox, vy = q.bcy - oy, vz = q.bcz - oz;
-  const proj = vx * dx + vy * dy + vz * dz;
-  const perpX = vx - proj * dx;
-  const perpY = vy - proj * dy;
-  const perpZ = vz - proj * dz;
-  if (perpX * perpX + perpY * perpY + perpZ * perpZ > q.br2) return false;
-  const tf = q.triFlat;
-  const n = tf.length;
-  for (let b = 0; b < n; b += 9) {
-    if (rayTriFlat(ox, oy, oz, dx, dy, dz, tf, b)) return true;
-  }
-  return false;
-}
-var BVH_STRIDE = 9;
-var BVH_LEAF_SIZE = 6;
-var SAH_BUCKETS = 12;
-function aabbSA(minX, minY, minZ, maxX, maxY, maxZ) {
-  const dx = maxX - minX, dy = maxY - minY, dz = maxZ - minZ;
-  return dx * dy + dy * dz + dz * dx;
-}
-function buildBVH(meta) {
-  const valid = [];
-  for (let i = 0; i < meta.length; i++) {
-    if (meta[i]) valid.push(i);
-  }
-  const n = valid.length;
-  const polyIndices = new Int32Array(n);
-  for (let i = 0; i < n; i++) polyIndices[i] = valid[i];
-  const centX = new Float64Array(n);
-  const centY = new Float64Array(n);
-  const centZ = new Float64Array(n);
-  for (let i = 0; i < n; i++) {
-    const m = meta[polyIndices[i]];
-    centX[i] = (m.minX + m.maxX) * 0.5;
-    centY[i] = (m.minY + m.maxY) * 0.5;
-    centZ[i] = (m.minZ + m.maxZ) * 0.5;
-  }
-  const maxNodes = 2 * Math.max(1, n) + 1;
-  const data = new Float64Array(maxNodes * BVH_STRIDE);
-  let nodeCount = 0;
-  const bMinX = new Float64Array(SAH_BUCKETS);
-  const bMinY = new Float64Array(SAH_BUCKETS);
-  const bMinZ = new Float64Array(SAH_BUCKETS);
-  const bMaxX = new Float64Array(SAH_BUCKETS);
-  const bMaxY = new Float64Array(SAH_BUCKETS);
-  const bMaxZ = new Float64Array(SAH_BUCKETS);
-  const bCnt = new Int32Array(SAH_BUCKETS);
-  const lSA = new Float64Array(SAH_BUCKETS - 1);
-  const lCnt = new Int32Array(SAH_BUCKETS - 1);
-  const rSA = new Float64Array(SAH_BUCKETS - 1);
-  const rCnt = new Int32Array(SAH_BUCKETS - 1);
-  function buildNode(start, end) {
-    const ni = nodeCount++;
-    const base = ni * BVH_STRIDE;
-    const count = end - start;
-    let minX = Infinity, minY = Infinity, minZ = Infinity;
-    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    for (let i = start; i < end; i++) {
-      const m = meta[polyIndices[i]];
-      if (m.minX < minX) minX = m.minX;
-      if (m.maxX > maxX) maxX = m.maxX;
-      if (m.minY < minY) minY = m.minY;
-      if (m.maxY > maxY) maxY = m.maxY;
-      if (m.minZ < minZ) minZ = m.minZ;
-      if (m.maxZ > maxZ) maxZ = m.maxZ;
-    }
-    data[base] = minX;
-    data[base + 1] = minY;
-    data[base + 2] = minZ;
-    data[base + 3] = maxX;
-    data[base + 4] = maxY;
-    data[base + 5] = maxZ;
-    if (count <= BVH_LEAF_SIZE) {
-      data[base + 6] = 1;
-      data[base + 7] = start;
-      data[base + 8] = end;
-      return ni;
-    }
-    let cxMin = Infinity, cyMin = Infinity, czMin = Infinity;
-    let cxMax = -Infinity, cyMax = -Infinity, czMax = -Infinity;
-    for (let i = start; i < end; i++) {
-      if (centX[i] < cxMin) cxMin = centX[i];
-      if (centX[i] > cxMax) cxMax = centX[i];
-      if (centY[i] < cyMin) cyMin = centY[i];
-      if (centY[i] > cyMax) cyMax = centY[i];
-      if (centZ[i] < czMin) czMin = centZ[i];
-      if (centZ[i] > czMax) czMax = centZ[i];
-    }
-    const extX = cxMax - cxMin, extY = cyMax - cyMin, extZ = czMax - czMin;
-    if (extX === 0 && extY === 0 && extZ === 0) {
-      data[base + 6] = 1;
-      data[base + 7] = start;
-      data[base + 8] = end;
-      return ni;
-    }
-    const nodeSA = aabbSA(minX, minY, minZ, maxX, maxY, maxZ);
-    const invSA = nodeSA > 0 ? 1 / nodeSA : 0;
-    let bestCost = count + 1;
-    let bestAxis = 0, bestSplitVal = 0;
-    for (let axis = 0; axis < 3; axis++) {
-      const cMin = axis === 0 ? cxMin : axis === 1 ? cyMin : czMin;
-      const ext = axis === 0 ? extX : axis === 1 ? extY : extZ;
-      if (ext === 0) continue;
-      const centArr = axis === 0 ? centX : axis === 1 ? centY : centZ;
-      const scale2 = SAH_BUCKETS / ext;
-      bMinX.fill(Infinity);
-      bMinY.fill(Infinity);
-      bMinZ.fill(Infinity);
-      bMaxX.fill(-Infinity);
-      bMaxY.fill(-Infinity);
-      bMaxZ.fill(-Infinity);
-      bCnt.fill(0);
-      for (let i = start; i < end; i++) {
-        let b = (centArr[i] - cMin) * scale2 | 0;
-        if (b >= SAH_BUCKETS) b = SAH_BUCKETS - 1;
-        const m = meta[polyIndices[i]];
-        if (m.minX < bMinX[b]) bMinX[b] = m.minX;
-        if (m.maxX > bMaxX[b]) bMaxX[b] = m.maxX;
-        if (m.minY < bMinY[b]) bMinY[b] = m.minY;
-        if (m.maxY > bMaxY[b]) bMaxY[b] = m.maxY;
-        if (m.minZ < bMinZ[b]) bMinZ[b] = m.minZ;
-        if (m.maxZ > bMaxZ[b]) bMaxZ[b] = m.maxZ;
-        bCnt[b]++;
-      }
-      let lx0 = Infinity, ly0 = Infinity, lz0 = Infinity;
-      let lx1 = -Infinity, ly1 = -Infinity, lz1 = -Infinity;
-      let lc = 0;
-      for (let k = 0; k < SAH_BUCKETS - 1; k++) {
-        if (bMinX[k] < lx0) lx0 = bMinX[k];
-        if (bMaxX[k] > lx1) lx1 = bMaxX[k];
-        if (bMinY[k] < ly0) ly0 = bMinY[k];
-        if (bMaxY[k] > ly1) ly1 = bMaxY[k];
-        if (bMinZ[k] < lz0) lz0 = bMinZ[k];
-        if (bMaxZ[k] > lz1) lz1 = bMaxZ[k];
-        lc += bCnt[k];
-        lSA[k] = aabbSA(lx0, ly0, lz0, lx1, ly1, lz1);
-        lCnt[k] = lc;
-      }
-      let rx0 = Infinity, ry0 = Infinity, rz0 = Infinity;
-      let rx1 = -Infinity, ry1 = -Infinity, rz1 = -Infinity;
-      let rc = 0;
-      for (let k = SAH_BUCKETS - 2; k >= 0; k--) {
-        const kb = k + 1;
-        if (bMinX[kb] < rx0) rx0 = bMinX[kb];
-        if (bMaxX[kb] > rx1) rx1 = bMaxX[kb];
-        if (bMinY[kb] < ry0) ry0 = bMinY[kb];
-        if (bMaxY[kb] > ry1) ry1 = bMaxY[kb];
-        if (bMinZ[kb] < rz0) rz0 = bMinZ[kb];
-        if (bMaxZ[kb] > rz1) rz1 = bMaxZ[kb];
-        rc += bCnt[kb];
-        rSA[k] = aabbSA(rx0, ry0, rz0, rx1, ry1, rz1);
-        rCnt[k] = rc;
-      }
-      for (let k = 0; k < SAH_BUCKETS - 1; k++) {
-        if (lCnt[k] === 0 || rCnt[k] === 0) continue;
-        const cost = 0.125 + (lSA[k] * lCnt[k] + rSA[k] * rCnt[k]) * invSA;
-        if (cost < bestCost) {
-          bestCost = cost;
-          bestAxis = axis;
-          bestSplitVal = cMin + (k + 1) / scale2;
-        }
-      }
-    }
-    const centArr2 = bestAxis === 0 ? centX : bestAxis === 1 ? centY : centZ;
-    let lo = start, hi = end - 1;
-    while (lo <= hi) {
-      if (centArr2[lo] < bestSplitVal) {
-        lo++;
-      } else {
-        const tmp = polyIndices[lo];
-        polyIndices[lo] = polyIndices[hi];
-        polyIndices[hi] = tmp;
-        const t0 = centX[lo];
-        centX[lo] = centX[hi];
-        centX[hi] = t0;
-        const t1 = centY[lo];
-        centY[lo] = centY[hi];
-        centY[hi] = t1;
-        const t2 = centZ[lo];
-        centZ[lo] = centZ[hi];
-        centZ[hi] = t2;
-        hi--;
-      }
-    }
-    let mid = lo;
-    if (mid === start || mid === end) mid = start + end >> 1;
-    data[base + 6] = 0;
-    const left = buildNode(start, mid);
-    const right = buildNode(mid, end);
-    data[ni * BVH_STRIDE + 7] = left;
-    data[ni * BVH_STRIDE + 8] = right;
-    return ni;
-  }
-  if (n > 0) buildNode(0, n);
-  return { data, nodeCount, polyIndices, meta };
-}
-function rayHitsAnyInBVH(ox, oy, oz, dx, dy, dz, selfIdx, bvh, stack) {
-  if (bvh.nodeCount === 0) return false;
-  const { data, polyIndices, meta } = bvh;
-  const invDx = dx !== 0 ? 1 / dx : dx >= 0 ? Infinity : -Infinity;
-  const invDy = dy !== 0 ? 1 / dy : dy >= 0 ? Infinity : -Infinity;
-  const invDz = dz !== 0 ? 1 / dz : dz >= 0 ? Infinity : -Infinity;
-  let top = 0;
-  stack[top++] = 0;
-  while (top > 0) {
-    const ni = stack[--top];
-    const base = ni * BVH_STRIDE;
-    const tx1 = (data[base] - ox) * invDx;
-    const tx2 = (data[base + 3] - ox) * invDx;
-    let tMin = tx1 < tx2 ? tx1 : tx2;
-    let tMax = tx1 < tx2 ? tx2 : tx1;
-    const ty1 = (data[base + 1] - oy) * invDy;
-    const ty2 = (data[base + 4] - oy) * invDy;
-    const tyMin = ty1 < ty2 ? ty1 : ty2;
-    const tyMax = ty1 < ty2 ? ty2 : ty1;
-    if (tMin > tyMax || tyMin > tMax) continue;
-    if (tyMin > tMin) tMin = tyMin;
-    if (tyMax < tMax) tMax = tyMax;
-    const tz1 = (data[base + 2] - oz) * invDz;
-    const tz2 = (data[base + 5] - oz) * invDz;
-    const tzMin = tz1 < tz2 ? tz1 : tz2;
-    const tzMax = tz1 < tz2 ? tz2 : tz1;
-    if (tMin > tzMax || tzMin > tMax) continue;
-    if (tzMax < tMax) tMax = tzMax;
-    if (tMax < MIN_HIT_T) continue;
-    if (data[base + 6] === 1) {
-      const start = data[base + 7] | 0;
-      const end = data[base + 8] | 0;
-      for (let k = start; k < end; k++) {
-        const j = polyIndices[k];
-        if (j === selfIdx) continue;
-        const q = meta[j];
-        if (q && rayHitsPolygon(ox, oy, oz, dx, dy, dz, q)) return true;
-      }
-    } else {
-      stack[top++] = data[base + 7] | 0;
-      stack[top++] = data[base + 8] | 0;
-    }
-  }
-  return false;
-}
-function hemisphereSamplesFlat(k) {
-  const phi = (1 + Math.sqrt(5)) / 2;
-  const out = new Float64Array(k * 3);
-  for (let i = 0; i < k; i++) {
-    const z = (i + 0.5) / k;
-    const r = Math.sqrt(Math.max(0, 1 - z * z));
-    const theta = 2 * Math.PI * (i / phi);
-    out[i * 3] = r * Math.cos(theta);
-    out[i * 3 + 1] = r * Math.sin(theta);
-    out[i * 3 + 2] = z;
-  }
-  return out;
-}
-function basis(n) {
-  const ax = Math.abs(n[0]) > 0.9 ? 0 : 1;
-  const ay = Math.abs(n[0]) > 0.9 ? 1 : 0;
-  let ux = ay * n[2];
-  let uy = -ax * n[2];
-  let uz = ax * n[1] - ay * n[0];
-  const uLen = Math.hypot(ux, uy, uz);
-  ux /= uLen;
-  uy /= uLen;
-  uz /= uLen;
-  const vx = n[1] * uz - n[2] * uy;
-  const vy = n[2] * ux - n[0] * uz;
-  const vz = n[0] * uy - n[1] * ux;
-  return { ux, uy, uz, vx, vy, vz };
-}
-function cullInteriorPolygons(polygons, options) {
-  const k = options?.samples ?? DEFAULT_HEMISPHERE_SAMPLES;
-  if (polygons.length < 4 || k < 1) return polygons;
-  const meta = polygons.map(precompute);
-  const samplesFlat = hemisphereSamplesFlat(k);
-  const kept = [];
-  const bvh = buildBVH(meta);
-  const stack = new Int32Array(Math.max(64, bvh.nodeCount));
-  const MAX_ORIGINS = 64 * 3;
-  const origBuf = new Float64Array(MAX_ORIGINS);
-  for (let i = 0; i < polygons.length; i++) {
-    const p = meta[i];
-    if (!p) {
-      kept.push(polygons[i]);
-      continue;
-    }
-    const nx = p.normal[0], ny = p.normal[1], nz = p.normal[2];
-    const offX = RAY_ORIGIN_OFFSET * nx;
-    const offY = RAY_ORIGIN_OFFSET * ny;
-    const offZ = RAY_ORIGIN_OFFSET * nz;
-    {
-      const ox1 = p.centroid[0] + offX;
-      const oy1 = p.centroid[1] + offY;
-      const oz1 = p.centroid[2] + offZ;
-      if (!rayHitsAnyInBVH(ox1, oy1, oz1, nx, ny, nz, i, bvh, stack)) {
-        kept.push(polygons[i]);
-        continue;
-      }
-    }
-    const { ux, uy, uz, vx, vy, vz } = basis(p.normal);
-    const cx0 = p.centroid[0], cy0 = p.centroid[1], cz0 = p.centroid[2];
-    const verts = p.vertices;
-    const vCount = verts.length;
-    let oCnt = 0;
-    origBuf[oCnt++] = cx0 + offX;
-    origBuf[oCnt++] = cy0 + offY;
-    origBuf[oCnt++] = cz0 + offZ;
-    for (let vi = 0; vi < vCount; vi++) {
-      const v = verts[vi];
-      origBuf[oCnt++] = v[0] + (cx0 - v[0]) * ORIGIN_INSET + offX;
-      origBuf[oCnt++] = v[1] + (cy0 - v[1]) * ORIGIN_INSET + offY;
-      origBuf[oCnt++] = v[2] + (cz0 - v[2]) * ORIGIN_INSET + offZ;
-    }
-    for (let vi = 0; vi < vCount; vi++) {
-      const a = verts[vi];
-      const b = verts[(vi + 1) % vCount];
-      const mx = (a[0] + b[0]) * 0.5;
-      const my = (a[1] + b[1]) * 0.5;
-      const mz = (a[2] + b[2]) * 0.5;
-      origBuf[oCnt++] = mx + (cx0 - mx) * ORIGIN_INSET + offX;
-      origBuf[oCnt++] = my + (cy0 - my) * ORIGIN_INSET + offY;
-      origBuf[oCnt++] = mz + (cz0 - mz) * ORIGIN_INSET + offZ;
-    }
-    let escaped = false;
-    outer: for (let si = 0; si < samplesFlat.length; si += 3) {
-      const lx = samplesFlat[si], ly = samplesFlat[si + 1], lz = samplesFlat[si + 2];
-      const rdx = lx * ux + ly * vx + lz * nx;
-      const rdy = lx * uy + ly * vy + lz * ny;
-      const rdz = lx * uz + ly * vz + lz * nz;
-      for (let oi = 0; oi < oCnt; oi += 3) {
-        const rox = origBuf[oi], roy = origBuf[oi + 1], roz = origBuf[oi + 2];
-        if (!rayHitsAnyInBVH(rox, roy, roz, rdx, rdy, rdz, i, bvh, stack)) {
-          escaped = true;
-          break outer;
-        }
-      }
-    }
-    if (escaped) kept.push(polygons[i]);
-  }
-  return kept;
-}
-
-// packages/core/src/merge/optimizePolygons.ts
-var NORMALIZE_MAX_ANGLE_DEG = 3;
-var NORMALIZE_MAX_PLANE_DISPLACEMENT = 0.03;
-var NORMALIZE_MAX_BOUNDARY_DISPLACEMENT = 0.02;
-var DEFAULT_NORMALIZE_OPTIONS = {
-  maxAngleDeg: NORMALIZE_MAX_ANGLE_DEG,
-  maxPlaneDisplacement: NORMALIZE_MAX_PLANE_DISPLACEMENT,
-  maxBoundaryDisplacement: NORMALIZE_MAX_BOUNDARY_DISPLACEMENT,
-  isolatedPairs: false
-};
-var DEFAULT_LOSSY_APPROXIMATE_OPTIONS = {
-  maxAngleDeg: 15,
-  maxPlaneDisplacement: 0.35,
-  maxBoundaryDisplacement: 0.0725,
-  isolatedPairs: true
-};
-var LOSSY_BUDGET_SWEEP = [
-  {
-    maxAngleDeg: 15,
-    maxPlaneDisplacement: 0.35,
-    maxBoundaryDisplacement: 0.02
-  },
-  {
-    maxAngleDeg: 15,
-    maxPlaneDisplacement: 0.35,
-    maxBoundaryDisplacement: 0.0725
-  },
-  {
-    maxAngleDeg: 45,
-    maxPlaneDisplacement: 1,
-    maxBoundaryDisplacement: 0.0725
-  }
-];
-var LOSSY_COLOR_QUANTIZE_STEPS = [4, 8, 12];
-var LOSSY_RECTANGULATED_MIN_POLYGONS = 300;
-var LOSSY_RECTANGULATED_MAX_TRIANGLE_RATIO = 0.3;
-var LOSSY_AUTOMATIC_GROUP_MAX_POLYGONS = 300;
-var LOSSY_CRACK_COST_SLACK = 16;
-var LOSSY_CRACK_RELATIVE_COST_SLACK = 0.015;
-var LOSSY_CRACK_QUALITY_SEARCH_MULTIPLIER = 2.6;
-var LOSSY_POLYGON_PAIR_MAX_PASSES = 3;
-var RECT_COVER_MOSTLY_QUAD_TRIANGLE_LIMIT = 96;
-var AUTOMATIC_RECT_COVER_MAX_POLYGONS = 1800;
-var AUTOMATIC_RECT_COVER_MIN_TRIANGLE_RATIO = 0.65;
-var LOSSY_RECTANGULATED_FAST_EXIT_MIN_POLYGONS = 900;
-var AUTOMATIC_GEOMETRY_SKIP_MIN_POLYGONS = 300;
-var CARDINAL_NORMAL_EPSILON = 1e-5;
-var DEFAULT_RECT_COVER_OPTIONS = {
-  minGroupPolygons: 2,
-  maxCandidateAxes: 24
-};
-var AUTOMATIC_LOSSY_RECT_COVER_OPTIONS = {
-  ...DEFAULT_RECT_COVER_OPTIONS,
-  maxCandidateAxes: 1
-};
-var EMPTY_CRACK_METRICS = {
-  maxGap: 0,
-  internalBoundaryLength: 0,
-  excessBoundaryLength: 0
-};
-function optimizeMeshPolygons(polygons, options = {}) {
-  const meshResolution = options.meshResolution ?? "lossy";
-  const preprocessCache = {};
-  const baseline = preprocessModelPolygons(polygons, false, preprocessCache);
-  let best = baseline;
-  let bestCost = polygonRenderCost(baseline);
-  const acceptCandidate = (candidate, cost = polygonRenderCost(candidate)) => {
-    if (cost >= bestCost) return false;
-    best = candidate;
-    bestCost = cost;
-    return true;
-  };
-  const initialRectCover = meshResolution === "lossy" && options.rectCover === void 0 ? automaticLossyRectCoverOptions(baseline) : options.rectCover;
-  const rectCovered = applyRectCoverCandidate(baseline, initialRectCover);
-  if (rectCovered !== baseline) acceptCandidate(rectCovered);
-  if (meshResolution === "lossy" && options.approximateMerge !== false) {
-    const qualityCandidates = [];
-    const referenceCandidate = best;
-    let crackSource = null;
-    let referenceCracks = null;
-    const getCrackSource = () => {
-      crackSource ?? (crackSource = createCrackSourceContext(polygons));
-      return crackSource;
-    };
-    const getReferenceCracks = () => {
-      referenceCracks ?? (referenceCracks = candidateCrackQualityMetrics(
-        getCrackSource(),
-        referenceCandidate,
-        DEFAULT_LOSSY_APPROXIMATE_OPTIONS.maxBoundaryDisplacement
-      ).metrics);
-      return referenceCracks;
-    };
-    const automaticApproximate = options.approximateMerge === void 0 || options.approximateMerge === true;
-    const passesLossyCrackBudget = (sample, allowReferenceCracks = true) => !crackMetricsExceed(
-      getCrackSource(),
-      sample.metrics,
-      sample.tolerance,
-      allowReferenceCracks ? getReferenceCracks() : null
-    );
-    const sampleCandidateCracks = (candidate, maxBoundaryDisplacement, allowReferenceCracks = true) => {
-      const source = getCrackSource();
-      const tolerance = crackToleranceForSource(source, maxBoundaryDisplacement);
-      return candidateCrackQualityMetrics(
-        source,
-        candidate,
-        maxBoundaryDisplacement,
-        crackMetricLimits(
-          source,
-          tolerance,
-          allowReferenceCracks ? getReferenceCracks() : null
-        )
-      );
-    };
-    const acceptLossyCandidate = (candidate, cost) => {
-      acceptCandidate(candidate, cost);
-    };
-    const considerQualityCandidate = (candidate, cost, maxBoundaryDisplacement = DEFAULT_LOSSY_APPROXIMATE_OPTIONS.maxBoundaryDisplacement, metrics) => {
-      if (!automaticApproximate || cost > bestCost + lossyCrackCostSlack(bestCost)) return;
-      qualityCandidates.push({
-        polygons: candidate,
-        cost,
-        maxBoundaryDisplacement,
-        metrics
-      });
-    };
-    const coverLossyCandidates = options.rectCover !== void 0 && options.rectCover !== false;
-    const skipAutomaticGeometryApproximation = automaticApproximate && shouldSkipAutomaticGeometryApproximation(baseline);
-    const approximateCandidates = skipAutomaticGeometryApproximation ? [] : lossyApproximateCandidates(
-      options.approximateMerge,
-      automaticApproximate ? baseline : void 0
-    );
-    const colorQuantizeCandidates = automaticApproximate ? lossyColorQuantizeCandidates(polygons) : [];
-    for (let approximateIndex = 0; approximateIndex < approximateCandidates.length; approximateIndex++) {
-      const approximateOptions = approximateCandidates[approximateIndex];
-      const approximate = preprocessModelPolygons(polygons, approximateOptions, preprocessCache);
-      const approximateCost = polygonRenderCost(approximate);
-      let approximateCracks = null;
-      let approximateMetrics;
-      const sampleApproximateCracks = (allowReferenceCracks) => {
-        approximateCracks ?? (approximateCracks = sampleCandidateCracks(
-          approximate,
-          approximateOptions.maxBoundaryDisplacement,
-          allowReferenceCracks
-        ));
-        return approximateCracks;
-      };
-      const approximateAllowsReferenceCracks = !!approximateOptions.allowReferenceCracks;
-      let approximatePassesCrackBudget = true;
-      if (automaticApproximate || approximateOptions.guard) {
-        const sample = sampleApproximateCracks(approximateAllowsReferenceCracks);
-        approximateMetrics = sample.metrics;
-        approximatePassesCrackBudget = passesLossyCrackBudget(sample, approximateAllowsReferenceCracks);
-      }
-      if (!approximatePassesCrackBudget && approximateCost < bestCost) {
-        continue;
-      }
-      if (approximatePassesCrackBudget) {
-        acceptLossyCandidate(approximate, approximateCost);
-        considerQualityCandidate(
-          approximate,
-          approximateCost,
-          approximateOptions.maxBoundaryDisplacement,
-          approximateMetrics
-        );
-      }
-      if (coverLossyCandidates) {
-        const coveredApproximate = applyRectCoverCandidate(approximate, options.rectCover);
-        const coveredApproximateCost = polygonRenderCost(coveredApproximate);
-        let coveredApproximateCracks = null;
-        let coveredApproximateMetrics;
-        const sampleCoveredApproximateCracks = (allowReferenceCracks) => {
-          coveredApproximateCracks ?? (coveredApproximateCracks = sampleCandidateCracks(
-            coveredApproximate,
-            approximateOptions.maxBoundaryDisplacement,
-            allowReferenceCracks
-          ));
-          return coveredApproximateCracks;
-        };
-        if (coveredApproximate !== approximate && coveredApproximateCost < bestCost) {
-          let coveredPassesCrackGuard = true;
-          if (automaticApproximate || approximateOptions.guard) {
-            const sample = sampleCoveredApproximateCracks(approximateAllowsReferenceCracks);
-            coveredApproximateMetrics = sample.metrics;
-            coveredPassesCrackGuard = passesLossyCrackBudget(sample, approximateAllowsReferenceCracks);
-          }
-          if (coveredPassesCrackGuard) {
-            acceptLossyCandidate(coveredApproximate, coveredApproximateCost);
-            considerQualityCandidate(
-              coveredApproximate,
-              coveredApproximateCost,
-              approximateOptions.maxBoundaryDisplacement,
-              coveredApproximateMetrics
-            );
-          }
-        }
-      }
-    }
-    if (automaticApproximate && colorQuantizeCandidates.length === 0 && shouldUseRectangulatedFastExit(baseline)) {
-      return best;
-    }
-    if (automaticApproximate) {
-      for (const colorPolygons of colorQuantizeCandidates) {
-        const colorCache = createColorPreprocessCache(colorPolygons, preprocessCache);
-        const colorBaseline = colorCache.baseline;
-        const colorCost = polygonRenderCost(colorBaseline);
-        let colorPassesCrackBudget = true;
-        let colorCracks = null;
-        let colorMetrics;
-        const sampleColorCracks = () => {
-          colorCracks ?? (colorCracks = sampleCandidateCracks(
-            colorBaseline,
-            DEFAULT_LOSSY_APPROXIMATE_OPTIONS.maxBoundaryDisplacement
-          ));
-          return colorCracks;
-        };
-        if (colorCost < bestCost) {
-          const sample = sampleColorCracks();
-          colorMetrics = sample.metrics;
-          colorPassesCrackBudget = passesLossyCrackBudget(sample);
-        }
-        if (colorPassesCrackBudget) {
-          acceptLossyCandidate(colorBaseline, colorCost);
-          considerQualityCandidate(colorBaseline, colorCost, void 0, colorMetrics);
-        }
-        if (coverLossyCandidates) {
-          const coveredColor = applyRectCoverCandidate(colorBaseline, options.rectCover);
-          if (coveredColor !== colorBaseline) {
-            const coveredColorCost = polygonRenderCost(coveredColor);
-            let coveredColorCracks = null;
-            let coveredColorMetrics;
-            const sampleCoveredColorCracks = () => {
-              coveredColorCracks ?? (coveredColorCracks = sampleCandidateCracks(
-                coveredColor,
-                DEFAULT_LOSSY_APPROXIMATE_OPTIONS.maxBoundaryDisplacement
-              ));
-              return coveredColorCracks;
-            };
-            const coveredColorPassesCrackBudget = () => {
-              const sample = sampleCoveredColorCracks();
-              coveredColorMetrics = sample.metrics;
-              return passesLossyCrackBudget(sample);
-            };
-            if (coveredColorCost >= bestCost || coveredColorPassesCrackBudget()) {
-              acceptLossyCandidate(coveredColor, coveredColorCost);
-              considerQualityCandidate(coveredColor, coveredColorCost, void 0, coveredColorMetrics);
-            }
-          }
-        }
-        const colorApproximateCandidates = skipAutomaticGeometryApproximation ? [] : lossyApproximateCandidates(
-          options.approximateMerge,
-          colorCache.baseline
-        );
-        for (const approximateOptions of colorApproximateCandidates) {
-          const approximate = preprocessModelPolygons(colorPolygons, approximateOptions, colorCache);
-          const approximateCost = polygonRenderCost(approximate);
-          let approximateCracks = null;
-          let approximateMetrics;
-          const sampleApproximateCracks = (allowReferenceCracks) => {
-            approximateCracks ?? (approximateCracks = sampleCandidateCracks(
-              approximate,
-              approximateOptions.maxBoundaryDisplacement,
-              allowReferenceCracks
-            ));
-            return approximateCracks;
-          };
-          const approximateAllowsReferenceCracks = !!approximateOptions.allowReferenceCracks;
-          let approximatePassesCrackBudget = true;
-          if (automaticApproximate || approximateOptions.guard) {
-            const sample = sampleApproximateCracks(approximateAllowsReferenceCracks);
-            approximateMetrics = sample.metrics;
-            approximatePassesCrackBudget = passesLossyCrackBudget(sample, approximateAllowsReferenceCracks);
-          }
-          if (!approximatePassesCrackBudget && approximateCost < bestCost) {
-            continue;
-          }
-          if (approximatePassesCrackBudget) {
-            acceptLossyCandidate(approximate, approximateCost);
-            considerQualityCandidate(
-              approximate,
-              approximateCost,
-              approximateOptions.maxBoundaryDisplacement,
-              approximateMetrics
-            );
-          }
-          if (coverLossyCandidates) {
-            const coveredApproximate = applyRectCoverCandidate(approximate, options.rectCover);
-            const coveredApproximateCost = polygonRenderCost(coveredApproximate);
-            let coveredApproximateCracks = null;
-            let coveredApproximateMetrics;
-            const sampleCoveredApproximateCracks = (allowReferenceCracks) => {
-              coveredApproximateCracks ?? (coveredApproximateCracks = sampleCandidateCracks(
-                coveredApproximate,
-                approximateOptions.maxBoundaryDisplacement,
-                allowReferenceCracks
-              ));
-              return coveredApproximateCracks;
-            };
-            if (coveredApproximate !== approximate && coveredApproximateCost < bestCost) {
-              let coveredPassesCrackGuard = true;
-              if (automaticApproximate || approximateOptions.guard) {
-                const sample = sampleCoveredApproximateCracks(approximateAllowsReferenceCracks);
-                coveredApproximateMetrics = sample.metrics;
-                coveredPassesCrackGuard = passesLossyCrackBudget(sample, approximateAllowsReferenceCracks);
-              }
-              if (coveredPassesCrackGuard) {
-                acceptLossyCandidate(coveredApproximate, coveredApproximateCost);
-                considerQualityCandidate(
-                  coveredApproximate,
-                  coveredApproximateCost,
-                  approximateOptions.maxBoundaryDisplacement,
-                  coveredApproximateMetrics
-                );
-              }
-            }
-          }
-        }
-      }
-    }
-    if (automaticApproximate && !skipAutomaticGeometryApproximation) {
-      for (const budget of LOSSY_BUDGET_SWEEP) {
-        const polygonPairOptions = resolveNormalizeOptions({ ...budget, isolatedPairs: true });
-        const polygonPaired = mergeAdjacentApproximatePolygonPairs(best, polygonPairOptions);
-        if (polygonPaired === best) continue;
-        const polygonPairCost = polygonRenderCost(polygonPaired);
-        if (polygonPairCost >= bestCost) continue;
-        const polygonPairCracks = sampleCandidateCracks(
-          polygonPaired,
-          polygonPairOptions.maxBoundaryDisplacement
-        );
-        if (!passesLossyCrackBudget(polygonPairCracks)) continue;
-        acceptLossyCandidate(polygonPaired, polygonPairCost);
-        considerQualityCandidate(
-          polygonPaired,
-          polygonPairCost,
-          polygonPairOptions.maxBoundaryDisplacement,
-          polygonPairCracks.metrics
-        );
-      }
-    }
-    const qualityBest = chooseLossyQualityCandidate(
-      qualityCandidates,
-      best,
-      bestCost,
-      (candidate) => {
-        candidate.metrics ?? (candidate.metrics = candidateCrackQualityMetrics(
-          getCrackSource(),
-          candidate.polygons,
-          candidate.maxBoundaryDisplacement
-        ).metrics);
-        return candidate.metrics;
-      },
-      () => candidateCrackQualityMetrics(
-        getCrackSource(),
-        best,
-        DEFAULT_LOSSY_APPROXIMATE_OPTIONS.maxBoundaryDisplacement
-      ).metrics
-    );
-    if (qualityBest) {
-      best = qualityBest.polygons;
-      bestCost = qualityBest.cost;
-    }
-  }
-  return best;
-}
-function lossyColorQuantizeCandidates(polygons) {
-  const profile = solidHexColorProfile(polygons);
-  if (profile.eligiblePolygons < 24 || profile.colorCount < 8) return [];
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const step of LOSSY_COLOR_QUANTIZE_STEPS) {
-    const quantized = quantizeSolidHexColors(polygons, step, profile.colorCount);
-    if (!quantized) continue;
-    const signature = colorSignature(quantized);
-    if (seen.has(signature)) continue;
-    seen.add(signature);
-    candidates.push(quantized);
-  }
-  return candidates;
-}
-function solidHexColorProfile(polygons) {
-  const colors = /* @__PURE__ */ new Set();
-  let eligiblePolygons = 0;
-  for (const polygon of polygons) {
-    if (polygon.texture || polygon.material?.texture || polygon.uvs || polygon.textureTriangles?.length) {
-      continue;
-    }
-    if (!parseHexColor(polygon.color)) continue;
-    eligiblePolygons += 1;
-    colors.add(polygon.color ?? "#cccccc");
-  }
-  return { eligiblePolygons, colorCount: colors.size };
-}
-function quantizeSolidHexColors(polygons, step, originalColorCount) {
-  let changed = false;
-  const quantizedColors = /* @__PURE__ */ new Set();
-  const output = polygons.map((polygon) => {
-    if (polygon.texture || polygon.material?.texture || polygon.uvs || polygon.textureTriangles?.length) {
-      return polygon;
-    }
-    const color = parseHexColor(polygon.color);
-    if (!color) return polygon;
-    const nextColor = formatHexColor([
-      Math.round(color[0] / step) * step,
-      Math.round(color[1] / step) * step,
-      Math.round(color[2] / step) * step
-    ]);
-    quantizedColors.add(nextColor);
-    if (nextColor === polygon.color) return polygon;
-    changed = true;
-    return { ...polygon, color: nextColor };
-  });
-  if (!changed || quantizedColors.size >= originalColorCount) return null;
-  return output;
-}
-function parseHexColor(color) {
-  const value = color ?? "#cccccc";
-  const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(value);
-  if (short) {
-    return [
-      parseInt(short[1] + short[1], 16),
-      parseInt(short[2] + short[2], 16),
-      parseInt(short[3] + short[3], 16)
-    ];
-  }
-  const full = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(value);
-  if (!full) return null;
-  return [
-    parseInt(full[1], 16),
-    parseInt(full[2], 16),
-    parseInt(full[3], 16)
-  ];
-}
-function formatHexColor(color) {
-  return `#${color.map(
-    (channel) => Math.max(0, Math.min(255, Math.round(channel))).toString(16).padStart(2, "0")
-  ).join("")}`;
-}
-function colorSignature(polygons) {
-  return polygons.map((polygon) => polygon.color ?? "").join("|");
-}
-function lossyApproximateCandidates(setting, baseline) {
-  if (setting && setting !== true) {
-    if (typeof setting.isolatedPairs === "boolean") {
-      return [{ ...setting, guard: setting.isolatedPairs === false }];
-    }
-    return [
-      { ...setting, isolatedPairs: true, guard: false },
-      { ...setting, isolatedPairs: false, guard: true }
-    ];
-  }
-  if (baseline && shouldUseRectangulatedLossyPath(baseline)) {
-    return [{
-      ...LOSSY_BUDGET_SWEEP[0],
-      isolatedPairs: true,
-      guard: false,
-      allowReferenceCracks: true
-    }];
-  }
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  const isolatedPairModes = baseline && baseline.length > LOSSY_AUTOMATIC_GROUP_MAX_POLYGONS ? [true] : [true, false];
-  for (let budgetIndex = 0; budgetIndex < LOSSY_BUDGET_SWEEP.length; budgetIndex++) {
-    const budget = LOSSY_BUDGET_SWEEP[budgetIndex];
-    for (const isolatedPairs of isolatedPairModes) {
-      const candidate = {
-        ...budget,
-        isolatedPairs,
-        guard: budgetIndex > 0 || isolatedPairs === false,
-        allowReferenceCracks: true
-      };
-      const key = [
-        candidate.maxAngleDeg,
-        candidate.maxPlaneDisplacement,
-        candidate.maxBoundaryDisplacement,
-        candidate.isolatedPairs
-      ].join("|");
-      if (seen.has(key)) continue;
-      seen.add(key);
-      candidates.push(candidate);
-    }
-  }
-  if (candidates.length === 0) {
-    return [{ ...DEFAULT_LOSSY_APPROXIMATE_OPTIONS, guard: false }];
-  }
-  return candidates;
-}
-function shouldUseRectangulatedLossyPath(baseline) {
-  if (baseline.length < LOSSY_RECTANGULATED_MIN_POLYGONS) return false;
-  const triangles = polygonTriangleCount(baseline);
-  return triangles / baseline.length <= LOSSY_RECTANGULATED_MAX_TRIANGLE_RATIO;
-}
-function shouldUseRectangulatedFastExit(baseline) {
-  return baseline.length >= LOSSY_RECTANGULATED_FAST_EXIT_MIN_POLYGONS && shouldUseRectangulatedLossyPath(baseline);
-}
-function shouldSkipAutomaticGeometryApproximation(baseline) {
-  if (baseline.length < AUTOMATIC_GEOMETRY_SKIP_MIN_POLYGONS) return false;
-  for (const polygon of baseline) {
-    if (polygon.vertices.length !== 4) return false;
-    if (polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length) return false;
-    const plane = planeOfPolygon(polygon);
-    if (!plane || !isCardinalNormal(plane.normal)) return false;
-  }
-  return true;
-}
-function isCardinalNormal(normal) {
-  const ax = Math.abs(normal[0]);
-  const ay = Math.abs(normal[1]);
-  const az = Math.abs(normal[2]);
-  const dominant = Math.max(ax, ay, az);
-  return dominant >= 1 - CARDINAL_NORMAL_EPSILON && ax + ay + az - dominant <= CARDINAL_NORMAL_EPSILON;
-}
-function polygonRenderCost(polygons) {
-  let cost = 0;
-  for (const polygon of polygons) {
-    const vertexCount = polygon.vertices.length;
-    const irregularPenalty = vertexCount <= 4 ? 0 : Math.min(4, vertexCount - 4) * 0.12;
-    const texturePenalty = polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length ? 0.15 : 0;
-    cost += 1 + irregularPenalty + texturePenalty;
-  }
-  return cost;
-}
-function lossyCrackCostSlack(cost) {
-  return Math.max(LOSSY_CRACK_COST_SLACK, cost * LOSSY_CRACK_RELATIVE_COST_SLACK);
-}
-function chooseLossyQualityCandidate(candidates, best, bestCost, candidateMetrics, bestMetrics) {
-  if (candidates.length === 0) return null;
-  const slack = lossyCrackCostSlack(bestCost);
-  const currentCandidate = candidates.find((candidate) => candidate.polygons === best);
-  let currentMetrics = null;
-  let selected = null;
-  let selectedMetrics = null;
-  for (const candidate of candidates) {
-    if (candidate.polygons === best || candidate.cost > bestCost + slack) continue;
-    const metrics = candidateMetrics(candidate);
-    currentMetrics ?? (currentMetrics = currentCandidate ? candidateMetrics(currentCandidate) : bestMetrics());
-    if (!crackMetricsMateriallyBetter(metrics, currentMetrics)) continue;
-    if (!selected || !selectedMetrics || compareLossyQualityCandidates(candidate, metrics, selected, selectedMetrics) < 0) {
-      selected = candidate;
-      selectedMetrics = metrics;
-    }
-  }
-  return selected;
-}
-function compareLossyQualityCandidates(a, aMetrics, b, bMetrics) {
-  return aMetrics.maxGap - bMetrics.maxGap || aMetrics.internalBoundaryLength - bMetrics.internalBoundaryLength || aMetrics.excessBoundaryLength - bMetrics.excessBoundaryLength || a.cost - b.cost;
-}
-function crackMetricsMateriallyBetter(candidate, current) {
-  const gapSlack = Math.max(5e-4, current.maxGap * 0.02);
-  if (candidate.maxGap < current.maxGap - gapSlack) return true;
-  if (candidate.maxGap > current.maxGap + gapSlack) return false;
-  const lengthSlack = Math.max(8, current.internalBoundaryLength * 0.01);
-  if (candidate.internalBoundaryLength < current.internalBoundaryLength - lengthSlack) return true;
-  if (candidate.internalBoundaryLength > current.internalBoundaryLength + lengthSlack) return false;
-  const excessSlack = Math.max(8, current.excessBoundaryLength * 0.01);
-  return candidate.excessBoundaryLength < current.excessBoundaryLength - excessSlack;
-}
-function crackMetricsExceed(source, metrics, tolerance, reference = null) {
-  return crackMetricsExceedLimits(metrics, crackMetricLimits(source, tolerance, reference));
-}
-function crackMetricLimits(source, tolerance, reference = null) {
-  if (!reference) {
-    return {
-      maxGap: Infinity,
-      internalBoundaryLength: 0,
-      excessBoundaryLength: tolerance
-    };
-  }
-  const gapSlack = Math.max(tolerance * 0.1, 1e-6);
-  const referenceGapLimit = reference.maxGap + gapSlack;
-  const gapLimit = tolerance <= 0.08 ? Math.max(referenceGapLimit, Math.min(tolerance * 0.75, 0.04)) : referenceGapLimit;
-  const lengthSlack = Math.max(tolerance * 2, reference.internalBoundaryLength * 0.15);
-  const excessSlack = Math.max(tolerance * 2, reference.excessBoundaryLength * 0.15);
-  return {
-    maxGap: gapLimit,
-    internalBoundaryLength: reference.internalBoundaryLength + lengthSlack,
-    excessBoundaryLength: reference.excessBoundaryLength + excessSlack
-  };
-}
-function crackMetricsExceedLimits(metrics, limits) {
-  return metrics.maxGap > limits.maxGap || metrics.internalBoundaryLength > limits.internalBoundaryLength || metrics.excessBoundaryLength > limits.excessBoundaryLength;
-}
-function candidateCrackMetrics(source, candidate, maxBoundaryDisplacement = 0, searchTolerance = crackToleranceForSource(source, maxBoundaryDisplacement), stopLimits) {
-  const sourceEdges = source.edges;
-  const candidateEdges = collectEdgeStats(candidate);
-  const tolerance = crackToleranceForSource(source, maxBoundaryDisplacement);
-  const internalIndex = searchTolerance > 0 ? internalSegmentIndexForSource(source, searchTolerance) : null;
-  const metrics = {
-    ...EMPTY_CRACK_METRICS,
-    excessBoundaryLength: Math.max(0, candidateEdges.boundaryLength - sourceEdges.boundaryLength)
-  };
-  if (stopLimits && crackMetricsExceedLimits(metrics, stopLimits)) {
-    return { metrics, tolerance };
-  }
-  for (const edge of candidateEdges.boundarySegments) {
-    const key = edgeKey3(edge.a, edge.b);
-    if (sourceEdges.boundaryKeys.has(key)) continue;
-    if (sourceEdges.internalKeys.has(key)) {
-      metrics.internalBoundaryLength += distanceVec(edge.a, edge.b);
-      if (stopLimits && crackMetricsExceedLimits(metrics, stopLimits)) break;
-      continue;
-    }
-    const gap = internalIndex ? indexedInternalEdgeGap(edge, internalIndex, searchTolerance) : null;
-    if (gap !== null) {
-      metrics.maxGap = Math.max(metrics.maxGap, gap);
-      metrics.internalBoundaryLength += distanceVec(edge.a, edge.b);
-      if (stopLimits && crackMetricsExceedLimits(metrics, stopLimits)) break;
-    }
-  }
-  return { metrics, tolerance };
-}
-function candidateCrackQualityMetrics(source, candidate, maxBoundaryDisplacement = 0, stopLimits) {
-  return candidateCrackMetrics(
-    source,
-    candidate,
-    maxBoundaryDisplacement,
-    crackQualitySearchToleranceForSource(source, maxBoundaryDisplacement),
-    stopLimits
-  );
-}
-function createCrackSourceContext(polygons) {
-  const diagonal = modelDiagonal(polygons);
-  const baseTolerance = diagonal > 0 ? Math.min(0.08, Math.max(1e-3, diagonal * 1e-3)) : 0;
-  return {
-    edges: collectEdgeStats(polygons),
-    baseTolerance,
-    polygonCount: polygons.length,
-    indexes: /* @__PURE__ */ new Map()
-  };
-}
-function crackToleranceForSource(source, maxBoundaryDisplacement = 0) {
-  return Math.max(source.baseTolerance, maxBoundaryDisplacement * 1.05);
-}
-function crackQualitySearchToleranceForSource(source, maxBoundaryDisplacement = 0) {
-  return Math.max(
-    crackToleranceForSource(source, maxBoundaryDisplacement),
-    source.baseTolerance * LOSSY_CRACK_QUALITY_SEARCH_MULTIPLIER,
-    maxBoundaryDisplacement * LOSSY_CRACK_QUALITY_SEARCH_MULTIPLIER
-  );
-}
-function internalSegmentIndexForSource(source, tolerance) {
-  const key = tolerance.toFixed(6);
-  const current = source.indexes.get(key);
-  if (current) return current;
-  const index = buildSegmentIndex(source.edges.internalSegments, tolerance);
-  source.indexes.set(key, index);
-  return index;
-}
-function collectEdgeStats(polygons) {
-  const edges = /* @__PURE__ */ new Map();
-  for (const polygon of polygons) {
-    for (let i = 0; i < polygon.vertices.length; i++) {
-      const a = polygon.vertices[i];
-      const b = polygon.vertices[(i + 1) % polygon.vertices.length];
-      const key = edgeKey3(a, b);
-      const current = edges.get(key);
-      if (current) current.count += 1;
-      else edges.set(key, { count: 1, a, b });
-    }
-  }
-  const boundaryKeys = /* @__PURE__ */ new Set();
-  const internalKeys = /* @__PURE__ */ new Set();
-  const boundarySegments = [];
-  const internalSegments = [];
-  let boundaryLength = 0;
-  for (const [key, edge] of edges) {
-    const segment = { a: edge.a, b: edge.b };
-    if (edge.count === 1) {
-      boundaryKeys.add(key);
-      boundarySegments.push(segment);
-      boundaryLength += distanceVec(segment.a, segment.b);
-    } else {
-      internalKeys.add(key);
-      internalSegments.push(segment);
-    }
-  }
-  return { boundaryKeys, internalKeys, boundarySegments, internalSegments, boundaryLength };
-}
-function modelDiagonal(polygons) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const polygon of polygons) {
-    for (const [x, y, z] of polygon.vertices) {
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      minZ = Math.min(minZ, z);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      maxZ = Math.max(maxZ, z);
-    }
-  }
-  return Number.isFinite(minX) ? Math.hypot(maxX - minX, maxY - minY, maxZ - minZ) : 0;
-}
-function buildSegmentIndex(segments, tolerance) {
-  const cellSize = Math.max(tolerance * 2, 1e-6);
-  const cells = /* @__PURE__ */ new Map();
-  for (const segment of segments) {
-    const [cx, cy, cz] = segmentCell(segment, cellSize);
-    const key = cellKey(cx, cy, cz);
-    const bucket = cells.get(key);
-    if (bucket) bucket.push(segment);
-    else cells.set(key, [segment]);
-  }
-  return { cellSize, cells };
-}
-function indexedInternalEdgeGap(segment, index, tolerance) {
-  const [cx, cy, cz] = segmentCell(segment, index.cellSize);
-  let best = null;
-  for (let dx = -1; dx <= 1; dx++) {
-    for (let dy = -1; dy <= 1; dy++) {
-      for (let dz = -1; dz <= 1; dz++) {
-        const bucket = index.cells.get(cellKey(cx + dx, cy + dy, cz + dz));
-        if (!bucket) continue;
-        for (const candidate of bucket) {
-          const gap = segmentEndpointGap(segment, candidate);
-          if (gap <= tolerance) best = best === null ? gap : Math.min(best, gap);
-        }
-      }
-    }
-  }
-  return best;
-}
-function segmentCell(segment, cellSize) {
-  return [
-    Math.floor((segment.a[0] + segment.b[0]) / 2 / cellSize),
-    Math.floor((segment.a[1] + segment.b[1]) / 2 / cellSize),
-    Math.floor((segment.a[2] + segment.b[2]) / 2 / cellSize)
-  ];
-}
-function cellKey(x, y, z) {
-  return `${x},${y},${z}`;
-}
-function segmentEndpointGap(a, b) {
-  return Math.min(
-    Math.max(distanceVec(a.a, b.a), distanceVec(a.b, b.b)),
-    Math.max(distanceVec(a.a, b.b), distanceVec(a.b, b.a))
-  );
-}
-function applyRectCoverCandidate(polygons, setting) {
-  if (setting === false) return polygons;
-  const options = resolveRectCoverOptions(polygons, setting);
-  if (!options) return polygons;
-  const covered = coverPlanarPolygons(polygons, options);
-  return covered.length < polygons.length ? covered : polygons;
-}
-function resolveRectCoverOptions(polygons, setting) {
-  if (setting && setting !== true) return setting;
-  const polygonCount = polygons.length;
-  if (polygonCount > 2200) return null;
-  if (polygonCount > 1200) {
-    return {
-      ...DEFAULT_RECT_COVER_OPTIONS,
-      maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 2)
-    };
-  }
-  if (polygonCount > 300 && polygonTriangleCount(polygons) <= RECT_COVER_MOSTLY_QUAD_TRIANGLE_LIMIT) {
-    return {
-      ...DEFAULT_RECT_COVER_OPTIONS,
-      maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 2)
-    };
-  }
-  if (polygonCount > 900) {
-    return {
-      ...DEFAULT_RECT_COVER_OPTIONS,
-      maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 4)
-    };
-  }
-  return DEFAULT_RECT_COVER_OPTIONS;
-}
-function automaticLossyRectCoverOptions(polygons) {
-  if (polygons.length > AUTOMATIC_RECT_COVER_MAX_POLYGONS) return false;
-  if (polygons.length === 0) return false;
-  if (polygonTriangleCount(polygons) / polygons.length < AUTOMATIC_RECT_COVER_MIN_TRIANGLE_RATIO) {
-    return false;
-  }
-  return AUTOMATIC_LOSSY_RECT_COVER_OPTIONS;
-}
-function polygonTriangleCount(polygons) {
-  let triangles = 0;
-  for (const polygon of polygons) {
-    if (polygon.vertices.length === 3) triangles += 1;
-  }
-  return triangles;
-}
-function applyIndexFilter(polygons, filter) {
-  if (filter === void 0 || filter === null) return polygons;
-  return filter.map((index) => polygons[index]).filter((polygon) => !!polygon);
-}
-function keptIndexFilter(input, kept) {
-  if (kept === input) return null;
-  if (kept.length === input.length && kept.every((polygon, index) => polygon === input[index])) {
-    return null;
-  }
-  const keptSet = new Set(kept);
-  const indices = [];
-  for (let i = 0; i < input.length; i++) {
-    if (keptSet.has(input[i])) indices.push(i);
-  }
-  return indices.length === input.length ? null : indices;
-}
-function dedupedPolygonsForMerge(polygons, cache) {
-  if (cache?.deduped) return cache.deduped;
-  let filter = cache?.dedupedIndices;
-  if (filter === void 0) {
-    const dropped = findOverlappingPolygonDuplicates(polygons);
-    if (dropped.size === 0) {
-      filter = null;
-    } else {
-      filter = [];
-      for (let i = 0; i < polygons.length; i++) {
-        if (!dropped.has(i)) filter.push(i);
-      }
-    }
-    if (cache) cache.dedupedIndices = filter;
-  }
-  const deduped = applyIndexFilter(polygons, filter);
-  if (cache) cache.deduped = deduped;
-  return deduped;
-}
-function interiorPolygonsForMerge(polygons, cache) {
-  if (cache?.interior) return cache.interior;
-  let filter = cache?.interiorIndices;
-  if (filter === void 0) {
-    const kept = cullInteriorPolygons(polygons);
-    filter = keptIndexFilter(polygons, kept);
-    if (cache) cache.interiorIndices = filter;
-  }
-  const interior = applyIndexFilter(polygons, filter);
-  if (cache) cache.interior = interior;
-  return interior;
-}
-function createColorPreprocessCache(polygons, source) {
-  const cache = {
-    dedupedIndices: source.dedupedIndices,
-    interiorIndices: source.interiorIndices,
-    snappedInteriorIndices: source.snappedInteriorIndices
-  };
-  const deduped = dedupedPolygonsForMerge(polygons, cache);
-  if (source.snapped && source.snapped.length === deduped.length) {
-    cache.snapped = applyGeometryTemplate(deduped, source.snapped);
-  }
-  const interior = interiorPolygonsForMerge(deduped, cache);
-  cache.baseline = mergePolygons(interior);
-  return cache;
-}
-function applyGeometryTemplate(polygons, template) {
-  return polygons.map((polygon, index) => {
-    const geometry = template[index];
-    if (!geometry) return polygon;
-    return {
-      ...polygon,
-      vertices: geometry.vertices,
-      ...geometry.uvs ? { uvs: geometry.uvs } : {},
-      ...geometry.textureTriangles ? { textureTriangles: geometry.textureTriangles } : {}
-    };
-  });
-}
-function preprocessModelPolygons(polygons, normalizeGeometry, cache) {
-  const deduped = dedupedPolygonsForMerge(polygons, cache);
-  const interior = interiorPolygonsForMerge(deduped, cache);
-  const baseline = cache?.baseline ?? mergePolygons(interior);
-  if (cache && !cache.baseline) cache.baseline = baseline;
-  if (!normalizeGeometry) return baseline;
-  const options = normalizeGeometry === true ? DEFAULT_NORMALIZE_OPTIONS : resolveNormalizeOptions(normalizeGeometry);
-  if (options.isolatedPairs) {
-    const paired = mergeIsolatedTrianglePairs(snappedInteriorPolygonsForMerge(deduped, cache), options);
-    const mergedPaired = mergePolygons(paired);
-    return mergedPaired.length < baseline.length ? mergedPaired : baseline;
-  }
-  const normalized = mergePolygons(cullInteriorPolygons(normalizeGeometryForMerge(deduped, options, cache)));
-  return normalized.length < baseline.length ? normalized : baseline;
-}
-function snappedPolygonsForMerge(polygons, cache) {
-  if (!cache) return snapGeometryForMerge(polygons);
-  if (!cache.snapped) cache.snapped = snapGeometryForMerge(polygons);
-  return cache.snapped;
-}
-function snappedInteriorPolygonsForMerge(polygons, cache) {
-  if (!cache) return cullInteriorPolygons(snapGeometryForMerge(polygons));
-  if (!cache.snappedInterior) {
-    const snapped = snappedPolygonsForMerge(polygons, cache);
-    if (cache.snappedInteriorIndices === void 0) {
-      const kept = cullInteriorPolygons(snapped);
-      cache.snappedInteriorIndices = keptIndexFilter(snapped, kept);
-      cache.snappedInterior = kept;
-    } else {
-      cache.snappedInterior = applyIndexFilter(snapped, cache.snappedInteriorIndices);
-    }
-  }
-  return cache.snappedInterior;
-}
-function resolveNormalizeOptions(options) {
-  return {
-    maxAngleDeg: options.maxAngleDeg ?? DEFAULT_NORMALIZE_OPTIONS.maxAngleDeg,
-    maxPlaneDisplacement: options.maxPlaneDisplacement ?? DEFAULT_NORMALIZE_OPTIONS.maxPlaneDisplacement,
-    maxBoundaryDisplacement: options.maxBoundaryDisplacement ?? DEFAULT_NORMALIZE_OPTIONS.maxBoundaryDisplacement,
-    isolatedPairs: options.isolatedPairs ?? DEFAULT_NORMALIZE_OPTIONS.isolatedPairs
-  };
-}
-function mergeIsolatedTrianglePairs(polygons, options) {
-  const metas = polygons.map((polygon) => {
-    const plane = planeOfPolygon(polygon);
-    if (!plane) return null;
-    return {
-      polygon,
-      normal: plane.normal,
-      area: plane.area,
-      materialKey: materialKeyForPolygon(polygon)
-    };
-  });
-  const edgeOwners = /* @__PURE__ */ new Map();
-  for (let i = 0; i < polygons.length; i++) {
-    const polygon = polygons[i];
-    if (polygon.vertices.length !== 3 || !metas[i]) continue;
-    for (let j = 0; j < polygon.vertices.length; j++) {
-      const key = edgeKey3(polygon.vertices[j], polygon.vertices[(j + 1) % polygon.vertices.length]);
-      const owners = edgeOwners.get(key);
-      if (owners) owners.push(i);
-      else edgeOwners.set(key, [i]);
-    }
-  }
-  const candidates = [];
-  for (const owners of edgeOwners.values()) {
-    if (owners.length !== 2) continue;
-    const [a, b] = owners;
-    const candidate = approximateTrianglePairCandidate(a, b, polygons, metas, options);
-    if (candidate) candidates.push(candidate);
-  }
-  const used = /* @__PURE__ */ new Set();
-  const replacements = /* @__PURE__ */ new Map();
-  const skipped = /* @__PURE__ */ new Set();
-  const selected = choosePairCandidates(candidates);
-  const vertexMoves = averagedVertexPositionMoves(selected.flatMap((candidate) => candidate.vertexMoves));
-  for (const candidate of selected) {
-    used.add(candidate.a);
-    used.add(candidate.b);
-    const outputIndex = Math.min(candidate.a, candidate.b);
-    replacements.set(outputIndex, candidate.polygon);
-    skipped.add(Math.max(candidate.a, candidate.b));
-  }
-  const output = [];
-  for (let i = 0; i < polygons.length; i++) {
-    const replacement = replacements.get(i);
-    if (replacement) {
-      output.push(replacement);
-      continue;
-    }
-    if (skipped.has(i)) continue;
-    output.push(polygons[i]);
-  }
-  return vertexMoves.size > 0 ? applyVertexPositionMoves(output, vertexMoves) : output;
-}
-function choosePairCandidates(candidates) {
-  if (candidates.length > 3e3) return choosePairCandidatesStatic(candidates);
-  return choosePairCandidatesDynamic(candidates);
-}
-function choosePairCandidatesStatic(candidates) {
-  const pairDegrees = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    pairDegrees.set(candidate.a, (pairDegrees.get(candidate.a) ?? 0) + 1);
-    pairDegrees.set(candidate.b, (pairDegrees.get(candidate.b) ?? 0) + 1);
-  }
-  const sorted = [...candidates].sort((a, b) => {
-    const degreeA = (pairDegrees.get(a.a) ?? 0) + (pairDegrees.get(a.b) ?? 0);
-    const degreeB = (pairDegrees.get(b.a) ?? 0) + (pairDegrees.get(b.b) ?? 0);
-    return degreeA - degreeB || a.score - b.score;
-  });
-  const used = /* @__PURE__ */ new Set();
-  const selected = [];
-  for (const candidate of sorted) {
-    if (used.has(candidate.a) || used.has(candidate.b)) continue;
-    used.add(candidate.a);
-    used.add(candidate.b);
-    selected.push(candidate);
-  }
-  return selected;
-}
-function choosePairCandidatesDynamic(candidates) {
-  const incident = /* @__PURE__ */ new Map();
-  for (let i = 0; i < candidates.length; i++) {
-    const candidate = candidates[i];
-    const aIncident = incident.get(candidate.a);
-    if (aIncident) aIncident.push(i);
-    else incident.set(candidate.a, [i]);
-    const bIncident = incident.get(candidate.b);
-    if (bIncident) bIncident.push(i);
-    else incident.set(candidate.b, [i]);
-  }
-  const selected = [];
-  const live = new Array(candidates.length).fill(true);
-  const liveIncidentCount = /* @__PURE__ */ new Map();
-  const heap = new PairCandidateRankHeap();
-  for (const [polygon, list] of incident) liveIncidentCount.set(polygon, list.length);
-  const liveDegree = (candidate) => (liveIncidentCount.get(candidate.a) ?? 0) + (liveIncidentCount.get(candidate.b) ?? 0);
-  const pushRank = (index) => {
-    const candidate = candidates[index];
-    heap.push({
-      degree: liveDegree(candidate),
-      score: candidate.score,
-      index
-    });
-  };
-  const invalidate = (index, changedPolygons) => {
-    if (!live[index]) return;
-    live[index] = false;
-    const candidate = candidates[index];
-    for (const polygon of [candidate.a, candidate.b]) {
-      liveIncidentCount.set(polygon, (liveIncidentCount.get(polygon) ?? 0) - 1);
-      changedPolygons.add(polygon);
-    }
-  };
-  for (let i = 0; i < candidates.length; i++) pushRank(i);
-  while (heap.size() > 0) {
-    const rank = heap.pop();
-    if (!live[rank.index]) continue;
-    const candidate = candidates[rank.index];
-    const degree = liveDegree(candidate);
-    if (degree !== rank.degree) {
-      pushRank(rank.index);
-      continue;
-    }
-    selected.push(candidate);
-    const changedPolygons = /* @__PURE__ */ new Set();
-    for (const polygon of [candidate.a, candidate.b]) {
-      for (const index of incident.get(polygon) ?? []) {
-        invalidate(index, changedPolygons);
-      }
-    }
-    for (const polygon of changedPolygons) {
-      for (const index of incident.get(polygon) ?? []) {
-        if (live[index]) pushRank(index);
-      }
-    }
-  }
-  return selected;
-}
-var PairCandidateRankHeap = class {
-  constructor() {
-    this.items = [];
-  }
-  size() {
-    return this.items.length;
-  }
-  push(item) {
-    this.items.push(item);
-    let index = this.items.length - 1;
-    while (index > 0) {
-      const parent = index - 1 >> 1;
-      if (comparePairCandidateRanks(this.items[parent], this.items[index]) <= 0) break;
-      [this.items[parent], this.items[index]] = [this.items[index], this.items[parent]];
-      index = parent;
-    }
-  }
-  pop() {
-    if (this.items.length === 0) return null;
-    const top = this.items[0];
-    const last = this.items.pop();
-    if (this.items.length > 0) {
-      this.items[0] = last;
-      let index = 0;
-      for (; ; ) {
-        const left = index * 2 + 1;
-        const right = left + 1;
-        let best = index;
-        if (left < this.items.length && comparePairCandidateRanks(this.items[left], this.items[best]) < 0) best = left;
-        if (right < this.items.length && comparePairCandidateRanks(this.items[right], this.items[best]) < 0) best = right;
-        if (best === index) break;
-        [this.items[index], this.items[best]] = [this.items[best], this.items[index]];
-        index = best;
-      }
-    }
-    return top;
-  }
-};
-function comparePairCandidateRanks(a, b) {
-  return a.degree - b.degree || a.score - b.score || a.index - b.index;
-}
-function mergeAdjacentApproximatePolygonPairs(polygons, options) {
-  let current = polygons;
-  let currentCost = polygonRenderCost(current);
-  let origins = vertexOriginsForPolygons(current);
-  for (let pass = 0; pass < LOSSY_POLYGON_PAIR_MAX_PASSES; pass++) {
-    const result = mergeAdjacentApproximatePolygonPairPass(current, options, origins);
-    if (!result) break;
-    const nextCost = polygonRenderCost(result.polygons);
-    if (nextCost >= currentCost) break;
-    current = result.polygons;
-    currentCost = nextCost;
-    origins = result.origins;
-  }
-  return current === polygons ? polygons : current;
-}
-function mergeAdjacentApproximatePolygonPairPass(polygons, options, origins) {
-  const metas = polygons.map((polygon) => {
-    const plane = planeOfPolygon(polygon);
-    if (!plane) return null;
-    return {
-      polygon,
-      normal: plane.normal,
-      area: plane.area,
-      materialKey: materialKeyForPolygon(polygon)
-    };
-  });
-  const edgeOwners = /* @__PURE__ */ new Map();
-  for (let i = 0; i < polygons.length; i++) {
-    const polygon = polygons[i];
-    if (!metas[i] || polygon.vertices.length < 3) continue;
-    for (let edge = 0; edge < polygon.vertices.length; edge++) {
-      const key = edgeKey3(polygon.vertices[edge], polygon.vertices[(edge + 1) % polygon.vertices.length]);
-      const owners = edgeOwners.get(key);
-      if (owners) owners.push({ polygon: i, edge });
-      else edgeOwners.set(key, [{ polygon: i, edge }]);
-    }
-  }
-  const candidates = [];
-  for (const owners of edgeOwners.values()) {
-    if (owners.length !== 2) continue;
-    const [a, b] = owners;
-    const candidate = approximatePolygonPairCandidate(a.polygon, a.edge, b.polygon, b.edge, polygons, metas, options);
-    if (candidate) candidates.push(candidate);
-  }
-  if (candidates.length === 0) return null;
-  candidates.sort((a, b) => b.score - a.score);
-  const used = /* @__PURE__ */ new Set();
-  const selected = [];
-  for (const candidate of candidates) {
-    if (used.has(candidate.a) || used.has(candidate.b)) continue;
-    used.add(candidate.a);
-    used.add(candidate.b);
-    selected.push(candidate);
-  }
-  if (selected.length === 0) return null;
-  const vertexMoves = averagedVertexPositionMoves(selected.flatMap((candidate) => candidate.vertexMoves));
-  if (!vertexPositionMovesWithinOriginBudget(vertexMoves, origins, options.maxBoundaryDisplacement)) {
-    return null;
-  }
-  const moved = applyVertexPositionMoves(polygons, vertexMoves);
-  const movedOrigins = applyVertexPositionMovesToOrigins(polygons, vertexMoves, origins);
-  const merged = mergePolygons(moved);
-  return polygonRenderCost(merged) < polygonRenderCost(polygons) ? { polygons: merged, origins: pruneVertexOriginsToPolygons(merged, movedOrigins) } : null;
-}
-function approximatePolygonPairCandidate(aIndex, aEdge, bIndex, bEdge, polygons, metas, options) {
-  const a = polygons[aIndex];
-  const b = polygons[bIndex];
-  const aMeta = metas[aIndex];
-  const bMeta = metas[bIndex];
-  if (!aMeta || !bMeta) return null;
-  if (a.vertices.length === 3 && b.vertices.length === 3) return null;
-  if (!canApproximatePairMerge(a, b, aMeta, bMeta)) return null;
-  const normalDot = Math.abs(dotVec(aMeta.normal, bMeta.normal));
-  const minNormalDot = Math.cos(options.maxAngleDeg * Math.PI / 180);
-  if (normalDot < minNormalDot) return null;
-  const ring = boundaryRingForAdjacentPair(a, b, aEdge) ?? boundaryRingForAdjacentPair(b, a, bEdge);
-  if (!ring || ring.length < 4 || ring.length > 10) return null;
-  const fit = fitPlaneForVertices(ring);
-  if (!fit) return null;
-  let maxDistance = 0;
-  let squaredDistance = 0;
-  for (const vertex of ring) {
-    const distance = Math.abs(signedPlaneDistance(vertex, fit));
-    maxDistance = Math.max(maxDistance, distance);
-    squaredDistance += distance * distance;
-  }
-  if (maxDistance > Math.min(options.maxPlaneDisplacement, options.maxBoundaryDisplacement)) return null;
-  const projected = ring.map((vertex) => projectVecToPlane(vertex, fit));
-  if (!isConvexPolygon(projected, fit.normal)) return null;
-  const projectedPlane = planeOfPolygon({ vertices: projected });
-  if (!projectedPlane || dotVec(projectedPlane.normal, aMeta.normal) < 0.2 || dotVec(projectedPlane.normal, bMeta.normal) < 0.2) {
-    return null;
-  }
-  const vertexMoves = [
-    ...ring.map((vertex, index) => ({
-      key: vertexKey(vertex),
-      target: projected[index]
-    })),
-    ...textureTriangleVertexProjectionMoves([a, b], fit)
-  ];
-  const projectedPair = applyVertexPositionMoves([a, b], averagedVertexPositionMoves(vertexMoves));
-  const sourceCost = polygonRenderCost([a, b]);
-  const projectedCost = polygonRenderCost(mergePolygons(projectedPair));
-  if (projectedCost >= sourceCost) return null;
-  const score = sourceCost - projectedCost - (squaredDistance / ring.length + maxDistance * 0.25 + (1 - normalDot) * 0.1);
-  if (score <= 0) return null;
-  return {
-    a: aIndex,
-    b: bIndex,
-    vertexMoves,
-    score
-  };
-}
-function boundaryRingForAdjacentPair(a, b, aEdge) {
-  const aVertices = a.vertices;
-  const bVertices = b.vertices;
-  const a0 = aVertices[aEdge];
-  const a1 = aVertices[(aEdge + 1) % aVertices.length];
-  let bEdge = -1;
-  for (let i = 0; i < bVertices.length; i++) {
-    if (eqVec2(bVertices[i], a1) && eqVec2(bVertices[(i + 1) % bVertices.length], a0)) {
-      bEdge = i;
-      break;
-    }
-  }
-  if (bEdge < 0) return null;
-  const ring = [];
-  let index = (aEdge + 1) % aVertices.length;
-  ring.push(aVertices[index]);
-  while (index !== aEdge) {
-    index = (index + 1) % aVertices.length;
-    ring.push(aVertices[index]);
-  }
-  index = (bEdge + 2) % bVertices.length;
-  while (index !== bEdge) {
-    const vertex = bVertices[index];
-    if (!eqVec2(vertex, ring[ring.length - 1])) ring.push(vertex);
-    index = (index + 1) % bVertices.length;
-  }
-  if (ring.length > 1 && eqVec2(ring[0], ring[ring.length - 1])) ring.pop();
-  return ring;
-}
-function vertexPositionMovesWithinOriginBudget(moves, origins, budget) {
-  for (const [key, target] of moves) {
-    const fallback = vertexFromKey(key);
-    const candidates = origins.get(key) ?? (fallback ? [fallback] : []);
-    if (candidates.length === 0) return false;
-    for (const source of candidates) {
-      if (distanceVec(source, target) > budget + 1e-6) return false;
-    }
-  }
-  return true;
-}
-function vertexOriginsForPolygons(polygons) {
-  const origins = /* @__PURE__ */ new Map();
-  for (const polygon of polygons) {
-    for (const vertex of polygon.vertices) {
-      addVertexOrigin(origins, vertexKey(vertex), vertex);
-    }
-    for (const triangle of polygon.textureTriangles ?? []) {
-      for (const vertex of triangle.vertices) {
-        addVertexOrigin(origins, vertexKey(vertex), vertex);
-      }
-    }
-  }
-  return origins;
-}
-function applyVertexPositionMovesToOrigins(polygons, moves, origins) {
-  const moved = /* @__PURE__ */ new Map();
-  for (const polygon of polygons) {
-    const vertices = [
-      ...polygon.vertices,
-      ...(polygon.textureTriangles ?? []).flatMap((triangle) => triangle.vertices)
-    ];
-    for (const vertex of vertices) {
-      const sourceKey = vertexKey(vertex);
-      const target = moves.get(sourceKey) ?? vertex;
-      const targetKey = vertexKey(target);
-      for (const origin of origins.get(sourceKey) ?? [vertex]) {
-        addVertexOrigin(moved, targetKey, origin);
-      }
-    }
-  }
-  return moved;
-}
-function pruneVertexOriginsToPolygons(polygons, origins) {
-  const pruned = /* @__PURE__ */ new Map();
-  for (const polygon of polygons) {
-    const vertices = [
-      ...polygon.vertices,
-      ...(polygon.textureTriangles ?? []).flatMap((triangle) => triangle.vertices)
-    ];
-    for (const vertex of vertices) {
-      const key = vertexKey(vertex);
-      for (const origin of origins.get(key) ?? [vertex]) {
-        addVertexOrigin(pruned, key, origin);
-      }
-    }
-  }
-  return pruned;
-}
-function addVertexOrigin(origins, key, origin) {
-  const values = origins.get(key);
-  if (!values) {
-    origins.set(key, [origin]);
-    return;
-  }
-  const originKey = vertexKey(origin);
-  if (!values.some((value) => vertexKey(value) === originKey)) values.push(origin);
-}
-function vertexFromKey(key) {
-  const parts = key.split(",").map(Number);
-  return parts.length === 3 && parts.every(Number.isFinite) ? [parts[0], parts[1], parts[2]] : null;
-}
-function averagedVertexPositionMoves(moves) {
-  const totals = /* @__PURE__ */ new Map();
-  for (const move of moves) {
-    const total = totals.get(move.key);
-    if (total) {
-      total.x += move.target[0];
-      total.y += move.target[1];
-      total.z += move.target[2];
-      total.count += 1;
-    } else {
-      totals.set(move.key, {
-        x: move.target[0],
-        y: move.target[1],
-        z: move.target[2],
-        count: 1
-      });
-    }
-  }
-  const averaged = /* @__PURE__ */ new Map();
-  for (const [key, total] of totals) {
-    averaged.set(key, [
-      total.x / total.count,
-      total.y / total.count,
-      total.z / total.count
-    ]);
-  }
-  return averaged;
-}
-function vertexPositionMovesForProjection(source, projected) {
-  const moves = [];
-  for (let i = 0; i < source.length; i++) {
-    const sourceVertices = source[i].vertices;
-    const projectedVertices = projected[i]?.vertices;
-    if (!projectedVertices || projectedVertices.length !== sourceVertices.length) continue;
-    for (let j = 0; j < sourceVertices.length; j++) {
-      moves.push({
-        key: vertexKey(sourceVertices[j]),
-        target: projectedVertices[j]
-      });
-    }
-    const sourceTriangles = source[i].textureTriangles ?? [];
-    const projectedTriangles = projected[i]?.textureTriangles ?? [];
-    for (let j = 0; j < sourceTriangles.length; j++) {
-      const projectedTriangle = projectedTriangles[j];
-      if (!projectedTriangle) continue;
-      for (let k = 0; k < sourceTriangles[j].vertices.length; k++) {
-        moves.push({
-          key: vertexKey(sourceTriangles[j].vertices[k]),
-          target: projectedTriangle.vertices[k]
-        });
-      }
-    }
-  }
-  return moves;
-}
-function textureTriangleVertexProjectionMoves(polygons, fit) {
-  const moves = [];
-  for (const polygon of polygons) {
-    for (const triangle of polygon.textureTriangles ?? []) {
-      for (const vertex of triangle.vertices) {
-        moves.push({
-          key: vertexKey(vertex),
-          target: projectVecToPlane(vertex, fit)
-        });
-      }
-    }
-  }
-  return moves;
-}
-function applyVertexPositionMoves(polygons, moves) {
-  return polygons.map((polygon) => {
-    let changed = false;
-    const moveVertex = (vertex) => {
-      const target = moves.get(vertexKey(vertex));
-      if (!target) return vertex;
-      changed = true;
-      return target;
-    };
-    const vertices = polygon.vertices.map(moveVertex);
-    const textureTriangles = mapTextureTriangleVertices(polygon.textureTriangles, moveVertex);
-    return changed ? {
-      ...polygon,
-      vertices,
-      ...textureTriangles ? { textureTriangles } : {}
-    } : polygon;
-  });
-}
-function approximateTrianglePairCandidate(aIndex, bIndex, polygons, metas, options) {
-  const a = polygons[aIndex];
-  const b = polygons[bIndex];
-  const aMeta = metas[aIndex];
-  const bMeta = metas[bIndex];
-  if (!aMeta || !bMeta) return null;
-  if (a.vertices.length !== 3 || b.vertices.length !== 3) return null;
-  if (!canApproximatePairMerge(a, b, aMeta, bMeta)) return null;
-  const shared = sharedEdgeIndices(a, b);
-  if (!shared) return null;
-  const [ai0, ai1, bi0, bi1] = shared;
-  const bGoesSameDirection = (bi0 + 1) % b.vertices.length === bi1;
-  if (bGoesSameDirection) return null;
-  const normalDot = Math.abs(dotVec(aMeta.normal, bMeta.normal));
-  const minNormalDot = Math.cos(options.maxAngleDeg * Math.PI / 180);
-  if (normalDot < minNormalDot) return null;
-  const aThird = (ai1 + 1) % a.vertices.length;
-  const bThird = 3 - bi0 - bi1;
-  const ring = [
-    a.vertices[ai1],
-    a.vertices[aThird],
-    a.vertices[ai0],
-    b.vertices[bThird]
-  ];
-  const fit = fitPlaneForVertices(ring);
-  if (!fit) return null;
-  let maxDistance = 0;
-  let squaredDistance = 0;
-  for (const vertex of ring) {
-    const distance = Math.abs(signedPlaneDistance(vertex, fit));
-    maxDistance = Math.max(maxDistance, distance);
-    squaredDistance += distance * distance;
-  }
-  if (maxDistance > Math.min(options.maxPlaneDisplacement, options.maxBoundaryDisplacement)) return null;
-  const projected = ring.map((vertex) => projectVecToPlane(vertex, fit));
-  if (!isConvexPolygon(projected, fit.normal)) return null;
-  const projectedPlane = planeOfPolygon({ vertices: projected });
-  if (!projectedPlane || dotVec(projectedPlane.normal, aMeta.normal) < 0.2 || dotVec(projectedPlane.normal, bMeta.normal) < 0.2) {
-    return null;
-  }
-  const polygon = {
-    vertices: ring,
-    color: a.color,
-    ...a.data ? { data: { ...a.data } } : {}
-  };
-  if (canUseTexturedLossyMerge(a, b) && a.uvs && b.uvs && a.texture) {
-    polygon.texture = a.texture;
-    polygon.uvs = [
-      [...a.uvs[ai1]],
-      [...a.uvs[aThird]],
-      [...a.uvs[ai0]],
-      [...b.uvs[bThird]]
-    ];
-    const textureTriangles = textureTrianglesForPolygons([a, b]);
-    if (textureTriangles?.length) polygon.textureTriangles = textureTriangles;
-  }
-  return {
-    a: aIndex,
-    b: bIndex,
-    polygon,
-    vertexMoves: [
-      ...ring.map((vertex, index) => ({
-        key: vertexKey(vertex),
-        target: projected[index]
-      })),
-      ...textureTriangleVertexProjectionMoves([a, b], fit)
-    ],
-    score: squaredDistance / ring.length + maxDistance * 0.25 + (1 - normalDot) * 0.1
-  };
-}
-function fitPlaneForVertices(vertices) {
-  if (vertices.length < 3) return null;
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  let px = 0;
-  let py = 0;
-  let pz = 0;
-  for (let i = 0; i < vertices.length; i++) {
-    const current = vertices[i];
-    const next = vertices[(i + 1) % vertices.length];
-    nx += (current[1] - next[1]) * (current[2] + next[2]);
-    ny += (current[2] - next[2]) * (current[0] + next[0]);
-    nz += (current[0] - next[0]) * (current[1] + next[1]);
-    px += current[0];
-    py += current[1];
-    pz += current[2];
-  }
-  const normal = normalizeVec([nx, ny, nz]);
-  if (!normal) return null;
-  return {
-    normal,
-    point: [px / vertices.length, py / vertices.length, pz / vertices.length]
-  };
-}
-function isConvexPolygon(vertices, normal) {
-  let sign = 0;
-  for (let i = 0; i < vertices.length; i++) {
-    const a = vertices[i];
-    const b = vertices[(i + 1) % vertices.length];
-    const c = vertices[(i + 2) % vertices.length];
-    const turn = dotVec(crossVec(subVec(b, a), subVec(c, b)), normal);
-    if (Math.abs(turn) <= 1e-9) continue;
-    const nextSign = turn > 0 ? 1 : -1;
-    if (sign === 0) sign = nextSign;
-    else if (sign !== nextSign) return false;
-  }
-  return true;
-}
-function normalizeGeometryForMerge(polygons, options, cache) {
-  const snapped = snappedPolygonsForMerge(polygons, cache);
-  const planeEpsilon = planeFitEpsilon(snapped, options);
-  if (planeEpsilon <= 0) return snapped;
-  const metas = snapped.map((polygon) => {
-    const plane = planeOfPolygon(polygon);
-    if (!plane) return null;
-    return {
-      polygon,
-      normal: plane.normal,
-      area: plane.area,
-      materialKey: materialKeyForPolygon(polygon)
-    };
-  });
-  const adjacency = buildMergeAdjacency(snapped, metas);
-  const assigned = /* @__PURE__ */ new Set();
-  const output = Array(snapped.length);
-  const vertexMoves = [];
-  const writeOutput = (index, polygon) => {
-    output[index] = polygon;
-  };
-  for (let i = 0; i < snapped.length; i++) {
-    const meta = metas[i];
-    if (assigned.has(i)) continue;
-    if (!meta) {
-      writeOutput(i, snapped[i]);
-      continue;
-    }
-    const group = growPlaneGroup(i, metas, adjacency, assigned, planeEpsilon, options);
-    for (const index of group) assigned.add(index);
-    if (group.length < 2) {
-      writeOutput(i, snapped[i]);
-      continue;
-    }
-    const replacements = choosePlaneGroupReplacements(group, snapped, metas, adjacency, planeEpsilon, options);
-    vertexMoves.push(...replacements.vertexMoves);
-    for (const index of group) {
-      writeOutput(index, replacements.polygons.get(index) ?? snapped[index]);
-    }
-  }
-  const projected = output.flatMap((polygon) => polygon ? [polygon] : []);
-  const moved = vertexMoves.length > 0 ? applyVertexPositionMoves(projected, averagedVertexPositionMoves(vertexMoves)) : projected;
-  return snapGeometryForMerge(moved);
-}
-function snapGeometryForMerge(polygons) {
-  const geometryEpsilon = geometrySnapEpsilon(polygons);
-  const uvEpsilon = 1e-4;
-  if (geometryEpsilon <= 0) return polygons;
-  const vertices = createVec3Snapper(geometryEpsilon);
-  const uvs = createVec2Snapper(uvEpsilon);
-  return polygons.map((polygon) => {
-    const snapVertex = (vertex) => vertices.snap(vertex);
-    const snappedVertices = polygon.vertices.map(snapVertex);
-    const snappedUvs = polygon.uvs && polygon.uvs.length === polygon.vertices.length ? polygon.uvs.map((uv) => uvs.snap(uv)) : void 0;
-    const snappedTextureTriangles = mapTextureTriangleVertices(polygon.textureTriangles, snapVertex);
-    const snappedPolygon = {
-      ...polygon,
-      vertices: snappedVertices,
-      ...snappedUvs ? { uvs: snappedUvs } : {},
-      ...snappedTextureTriangles ? { textureTriangles: snappedTextureTriangles } : {}
-    };
-    return {
-      ...snappedPolygon,
-      ...snappedPolygon.texture ? { textureTriangles: textureTrianglesForPolygon(snappedPolygon) } : {}
-    };
-  });
-}
-function textureTrianglesForPolygon(polygon) {
-  if (!polygon.texture) return void 0;
-  if (polygon.textureTriangles?.length) return cloneTextureTriangles2(polygon.textureTriangles);
-  if (polygon.uvs && polygon.uvs.length === polygon.vertices.length) {
-    return fanTextureTriangles2(polygon.vertices, polygon.uvs);
-  }
-  return void 0;
-}
-function textureTrianglesForPolygons(polygons) {
-  const triangles = polygons.flatMap((polygon) => textureTrianglesForPolygon(polygon) ?? []);
-  return triangles.length > 0 ? triangles : void 0;
-}
-function fanTextureTriangles2(vertices, uvs) {
-  const triangles = [];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    triangles.push({
-      vertices: [
-        [...vertices[0]],
-        [...vertices[i]],
-        [...vertices[i + 1]]
-      ],
-      uvs: [
-        [...uvs[0]],
-        [...uvs[i]],
-        [...uvs[i + 1]]
-      ]
-    });
-  }
-  return triangles;
-}
-function cloneTextureTriangles2(triangles) {
-  return triangles.map((triangle) => ({
-    vertices: triangle.vertices.map((vertex) => [...vertex]),
-    uvs: triangle.uvs.map((uv) => [...uv])
-  }));
-}
-function mapTextureTriangleVertices(triangles, mapVertex) {
-  if (!triangles?.length) return void 0;
-  return triangles.map((triangle) => ({
-    vertices: triangle.vertices.map(mapVertex),
-    uvs: triangle.uvs.map((uv) => [...uv])
-  }));
-}
-function choosePlaneGroupReplacements(group, polygons, metas, adjacency, planeEpsilon, options) {
-  const fullGroup = projectedPlanePatchCandidate(group, polygons, metas, planeEpsilon, options);
-  if (fullGroup) return replacementsForPlanePatch(fullGroup);
-  return splitPlaneGroupIntoWinningPatches(group, polygons, metas, adjacency, planeEpsilon, options);
-}
-function splitPlaneGroupIntoWinningPatches(group, polygons, metas, adjacency, planeEpsilon, options) {
-  const groupSet = new Set(group);
-  const candidates = [];
-  for (const a of group) {
-    for (const b of adjacency.get(a) ?? []) {
-      if (a >= b || !groupSet.has(b)) continue;
-      const candidate = projectedPlanePatchCandidate([a, b], polygons, metas, planeEpsilon, options);
-      if (candidate) candidates.push(candidate);
-    }
-  }
-  candidates.sort((a, b) => b.score - a.score);
-  const used = /* @__PURE__ */ new Set();
-  const replacements = /* @__PURE__ */ new Map();
-  const vertexMoves = [];
-  for (const candidate of candidates) {
-    if (candidate.indices.some((index) => used.has(index))) continue;
-    vertexMoves.push(...candidate.vertexMoves);
-    for (let i = 0; i < candidate.indices.length; i++) {
-      const index = candidate.indices[i];
-      used.add(index);
-      replacements.set(index, polygons[index]);
-    }
-  }
-  return { polygons: replacements, vertexMoves };
-}
-function replacementsForPlanePatch(candidate) {
-  const replacements = /* @__PURE__ */ new Map();
-  for (let i = 0; i < candidate.indices.length; i++) {
-    replacements.set(candidate.indices[i], candidate.source[i]);
-  }
-  return { polygons: replacements, vertexMoves: candidate.vertexMoves };
-}
-function projectedPlanePatchCandidate(group, polygons, metas, planeEpsilon, options) {
-  const fit = fitPlaneForGroup(group, metas);
-  if (!fit || !groupWithinPlaneBudget(group, metas, fit, planeEpsilon, options)) return null;
-  const source = group.map((index) => polygons[index]);
-  const projected = source.map((polygon) => projectPolygonToPlane(polygon, fit));
-  const sourceCost = polygonRenderCost(mergePolygons(source));
-  const projectedCost = polygonRenderCost(mergePolygons(projected));
-  if (projectedCost >= sourceCost) return null;
-  return {
-    indices: group,
-    source,
-    projected,
-    vertexMoves: vertexPositionMovesForProjection(source, projected),
-    score: sourceCost - projectedCost
-  };
-}
-function planeFitEpsilon(polygons, options) {
-  const geometryEpsilon = geometrySnapEpsilon(polygons);
-  if (geometryEpsilon <= 0) return 0;
-  return options.maxPlaneDisplacement;
-}
-function geometrySnapEpsilon(polygons) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const polygon of polygons) {
-    for (const [x, y, z] of polygon.vertices) {
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      minZ = Math.min(minZ, z);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      maxZ = Math.max(maxZ, z);
-    }
-  }
-  if (!Number.isFinite(minX)) return 0;
-  const diagonal = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ);
-  if (diagonal <= 0) return 0;
-  return Math.min(0.025, Math.max(1e-4, diagonal * 25e-5));
-}
-function createVec3Snapper(epsilon) {
-  const buckets = /* @__PURE__ */ new Map();
-  const cell = (value) => Math.floor(value / epsilon);
-  const key = (x, y, z) => `${x},${y},${z}`;
-  return {
-    snap(input) {
-      const cx = cell(input[0]);
-      const cy = cell(input[1]);
-      const cz = cell(input[2]);
-      for (let dx = -1; dx <= 1; dx++) {
-        for (let dy = -1; dy <= 1; dy++) {
-          for (let dz = -1; dz <= 1; dz++) {
-            const bucket2 = buckets.get(key(cx + dx, cy + dy, cz + dz));
-            if (!bucket2) continue;
-            for (const candidate of bucket2) {
-              if (distanceVec(input, candidate) <= epsilon) {
-                return [candidate[0], candidate[1], candidate[2]];
-              }
-            }
-          }
-        }
-      }
-      const snapped = [input[0], input[1], input[2]];
-      const bucketKey2 = key(cx, cy, cz);
-      const bucket = buckets.get(bucketKey2);
-      if (bucket) bucket.push(snapped);
-      else buckets.set(bucketKey2, [snapped]);
-      return snapped;
-    }
-  };
-}
-function createVec2Snapper(epsilon) {
-  const buckets = /* @__PURE__ */ new Map();
-  const cell = (value) => Math.floor(value / epsilon);
-  const key = (x, y) => `${x},${y}`;
-  return {
-    snap(input) {
-      const cx = cell(input[0]);
-      const cy = cell(input[1]);
-      for (let dx = -1; dx <= 1; dx++) {
-        for (let dy = -1; dy <= 1; dy++) {
-          const bucket2 = buckets.get(key(cx + dx, cy + dy));
-          if (!bucket2) continue;
-          for (const candidate of bucket2) {
-            if (Math.hypot(input[0] - candidate[0], input[1] - candidate[1]) <= epsilon) {
-              return [candidate[0], candidate[1]];
-            }
-          }
-        }
-      }
-      const snapped = [input[0], input[1]];
-      const bucketKey2 = key(cx, cy);
-      const bucket = buckets.get(bucketKey2);
-      if (bucket) bucket.push(snapped);
-      else buckets.set(bucketKey2, [snapped]);
-      return snapped;
-    }
-  };
-}
-function materialKeyForPolygon(polygon) {
-  return `${polygon.color ?? "#cccccc"}|${polygon.texture ?? ""}|${polygon.uvs ? "uv" : "plain"}`;
-}
-function planeOfPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (!vertices || vertices.length < 3) return null;
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  const origin = vertices[0];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    const a = subVec(vertices[i], origin);
-    const b = subVec(vertices[i + 1], origin);
-    const cross4 = crossVec(a, b);
-    nx += cross4[0];
-    ny += cross4[1];
-    nz += cross4[2];
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-10) return null;
-  return {
-    normal: [nx / len, ny / len, nz / len],
-    area: len / 2
-  };
-}
-function buildMergeAdjacency(polygons, metas) {
-  const edgeOwners = /* @__PURE__ */ new Map();
-  const adjacency = /* @__PURE__ */ new Map();
-  for (let i = 0; i < polygons.length; i++) {
-    const polygon = polygons[i];
-    if (!metas[i] || polygon.vertices.length < 3) continue;
-    for (let j = 0; j < polygon.vertices.length; j++) {
-      const key = edgeKey3(polygon.vertices[j], polygon.vertices[(j + 1) % polygon.vertices.length]);
-      const owners = edgeOwners.get(key);
-      if (owners) owners.push(i);
-      else edgeOwners.set(key, [i]);
-    }
-  }
-  for (const owners of edgeOwners.values()) {
-    for (let a = 0; a < owners.length; a++) {
-      for (let b = a + 1; b < owners.length; b++) {
-        const ai = owners[a];
-        const bi = owners[b];
-        if (canShareMergePatch(polygons[ai], polygons[bi], metas[ai], metas[bi])) {
-          addAdjacency(adjacency, ai, bi);
-          addAdjacency(adjacency, bi, ai);
-        }
-      }
-    }
-  }
-  return adjacency;
-}
-function canShareMergePatch(a, b, aMeta, bMeta) {
-  if (!aMeta || !bMeta) return false;
-  if (aMeta.materialKey !== bMeta.materialKey) return false;
-  if (!!a.uvs !== !!b.uvs) return false;
-  if (hasTextureMergeState(a) || hasTextureMergeState(b)) return canUseTexturedLossyMerge(a, b);
-  if (!a.uvs || !b.uvs) return true;
-  const shared = sharedEdgeIndices(a, b);
-  if (!shared) return false;
-  const [ai0, ai1, bi0, bi1] = shared;
-  return eqUv(a.uvs[ai0], b.uvs[bi0]) && eqUv(a.uvs[ai1], b.uvs[bi1]);
-}
-function canApproximatePairMerge(a, b, aMeta, bMeta) {
-  if (aMeta.materialKey !== bMeta.materialKey) return false;
-  if (hasTextureMergeState(a) || hasTextureMergeState(b)) return canUseTexturedLossyMerge(a, b);
-  return !a.uvs && !b.uvs && !a.textureTriangles?.length && !b.textureTriangles?.length;
-}
-function hasTextureMergeState(polygon) {
-  return Boolean(polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length);
-}
-function canUseTexturedLossyMerge(a, b) {
-  if (!a.texture || !b.texture || a.texture !== b.texture) return false;
-  if (a.material?.texture || b.material?.texture) return false;
-  if (!a.uvs || !b.uvs) return false;
-  if (a.uvs.length !== a.vertices.length || b.uvs.length !== b.vertices.length) return false;
-  const shared = sharedEdgeIndices(a, b);
-  if (!shared) return false;
-  const [ai0, ai1, bi0, bi1] = shared;
-  return eqUv(a.uvs[ai0], b.uvs[bi0]) && eqUv(a.uvs[ai1], b.uvs[bi1]);
-}
-function addAdjacency(adjacency, from, to) {
-  const values = adjacency.get(from);
-  if (values) values.add(to);
-  else adjacency.set(from, /* @__PURE__ */ new Set([to]));
-}
-function growPlaneGroup(seed, metas, adjacency, assigned, planeEpsilon, options) {
-  const group = [seed];
-  const queued = /* @__PURE__ */ new Set([seed]);
-  const queue = [seed];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    for (const next of adjacency.get(current) ?? []) {
-      if (assigned.has(next) || queued.has(next)) continue;
-      const nextMeta = metas[next];
-      const seedMeta = metas[seed];
-      if (!nextMeta || !seedMeta) continue;
-      if (nextMeta.materialKey !== seedMeta.materialKey) continue;
-      if (!canJoinPlaneGroup([...group, next], metas, planeEpsilon, options)) continue;
-      group.push(next);
-      queued.add(next);
-      queue.push(next);
-    }
-  }
-  return group;
-}
-function canJoinPlaneGroup(group, metas, planeEpsilon, options) {
-  const fit = fitPlaneForGroup(group, metas);
-  return !!fit && groupWithinPlaneBudget(group, metas, fit, planeEpsilon, options);
-}
-function fitPlaneForGroup(group, metas) {
-  const seed = metas[group[0]];
-  if (!seed) return null;
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  let px = 0;
-  let py = 0;
-  let pz = 0;
-  let weightSum = 0;
-  for (const index of group) {
-    const meta = metas[index];
-    if (!meta) return null;
-    const direction = dotVec(seed.normal, meta.normal) < 0 ? -1 : 1;
-    const weight = Math.max(meta.area, 1e-6);
-    nx += meta.normal[0] * direction * weight;
-    ny += meta.normal[1] * direction * weight;
-    nz += meta.normal[2] * direction * weight;
-    for (const vertex of meta.polygon.vertices) {
-      px += vertex[0];
-      py += vertex[1];
-      pz += vertex[2];
-      weightSum += 1;
-    }
-  }
-  const normal = normalizeVec([nx, ny, nz]);
-  if (!normal || weightSum === 0) return null;
-  const boundaryVertices = groupBoundaryVertexKeys(group, metas);
-  const boundaryD = planeOffsetRangeForVertices(group, metas, normal, boundaryVertices);
-  if (boundaryD) {
-    const d = (boundaryD.min + boundaryD.max) / 2;
-    return {
-      normal,
-      point: [normal[0] * d, normal[1] * d, normal[2] * d]
-    };
-  }
-  return {
-    normal,
-    point: [px / weightSum, py / weightSum, pz / weightSum]
-  };
-}
-function planeOffsetRangeForVertices(group, metas, normal, vertexKeys) {
-  let min = Infinity;
-  let max = -Infinity;
-  for (const index of group) {
-    const meta = metas[index];
-    if (!meta) continue;
-    for (const vertex of meta.polygon.vertices) {
-      if (!vertexKeys.has(vertexKey(vertex))) continue;
-      const d = dotVec(vertex, normal);
-      min = Math.min(min, d);
-      max = Math.max(max, d);
-    }
-  }
-  return Number.isFinite(min) && Number.isFinite(max) ? { min, max } : null;
-}
-function groupWithinPlaneBudget(group, metas, fit, planeEpsilon, options) {
-  const normalDotMin = Math.cos(options.maxAngleDeg * Math.PI / 180);
-  const boundaryVertices = groupBoundaryVertexKeys(group, metas);
-  for (const index of group) {
-    const meta = metas[index];
-    if (!meta) return false;
-    if (Math.abs(dotVec(meta.normal, fit.normal)) < normalDotMin) return false;
-    for (const vertex of meta.polygon.vertices) {
-      const limit = boundaryVertices.has(vertexKey(vertex)) ? options.maxBoundaryDisplacement : planeEpsilon;
-      if (Math.abs(signedPlaneDistance(vertex, fit)) > limit) return false;
-    }
-  }
-  return true;
-}
-function groupBoundaryVertexKeys(group, metas) {
-  const edgeCounts = /* @__PURE__ */ new Map();
-  for (const index of group) {
-    const meta = metas[index];
-    if (!meta) continue;
-    const vertices = meta.polygon.vertices;
-    for (let i = 0; i < vertices.length; i++) {
-      const a = vertices[i];
-      const b = vertices[(i + 1) % vertices.length];
-      const key = edgeKey3(a, b);
-      const current = edgeCounts.get(key);
-      if (current) current.count += 1;
-      else edgeCounts.set(key, { count: 1, a, b });
-    }
-  }
-  const boundary = /* @__PURE__ */ new Set();
-  for (const edge of edgeCounts.values()) {
-    if (edge.count !== 1) continue;
-    boundary.add(vertexKey(edge.a));
-    boundary.add(vertexKey(edge.b));
-  }
-  return boundary;
-}
-function projectPolygonToPlane(polygon, fit) {
-  const projectVertex = (vertex) => projectVecToPlane(vertex, fit);
-  const textureTriangles = mapTextureTriangleVertices(polygon.textureTriangles, projectVertex);
-  return {
-    ...polygon,
-    vertices: polygon.vertices.map(projectVertex),
-    ...textureTriangles ? { textureTriangles } : {}
-  };
-}
-function sharedEdgeIndices(a, b) {
-  for (let ai0 = 0; ai0 < a.vertices.length; ai0++) {
-    const ai1 = (ai0 + 1) % a.vertices.length;
-    for (let bi0 = 0; bi0 < b.vertices.length; bi0++) {
-      const bi1 = (bi0 + 1) % b.vertices.length;
-      if (eqVec2(a.vertices[ai0], b.vertices[bi0]) && eqVec2(a.vertices[ai1], b.vertices[bi1])) {
-        return [ai0, ai1, bi0, bi1];
-      }
-      if (eqVec2(a.vertices[ai0], b.vertices[bi1]) && eqVec2(a.vertices[ai1], b.vertices[bi0])) {
-        return [ai0, ai1, bi1, bi0];
-      }
-    }
-  }
-  return null;
-}
-function edgeKey3(a, b) {
-  const ak = vertexKey(a);
-  const bk = vertexKey(b);
-  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
-}
-function vertexKey(vertex) {
-  return `${vertex[0]},${vertex[1]},${vertex[2]}`;
-}
-function eqVec2(a, b) {
-  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-}
-function eqUv(a, b) {
-  return Math.abs(a[0] - b[0]) <= 1e-4 && Math.abs(a[1] - b[1]) <= 1e-4;
-}
-function subVec(a, b) {
-  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-}
-function crossVec(a, b) {
-  return [
-    a[1] * b[2] - a[2] * b[1],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0]
-  ];
-}
-function dotVec(a, b) {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-function distanceVec(a, b) {
-  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-}
-function normalizeVec(value) {
-  const length2 = Math.hypot(value[0], value[1], value[2]);
-  if (length2 <= 1e-10) return null;
-  return [value[0] / length2, value[1] / length2, value[2] / length2];
-}
-function signedPlaneDistance(vertex, fit) {
-  return dotVec(subVec(vertex, fit.point), fit.normal);
-}
-function projectVecToPlane(vertex, fit) {
-  const distance = signedPlaneDistance(vertex, fit);
-  return [
-    vertex[0] - fit.normal[0] * distance,
-    vertex[1] - fit.normal[1] * distance,
-    vertex[2] - fit.normal[2] * distance
-  ];
-}
-
-// packages/core/src/parser/solidTextureSamples.ts
-var DEFAULT_MAX_TEXTURE_PIXELS = 16 * 1024 * 1024;
-
-// packages/core/src/voxel/voxelSlicePlanner.ts
-var CUBE_FACES = ["t", "b", "bl", "br", "fr", "fl"];
-var FACE_ORDER = new Map(CUBE_FACES.map((face, index) => [face, index]));
-
-// packages/polycss/src/render/textureAtlas.ts
-var ATLAS_MAX_SIZE = 4096;
-var AUTO_ATLAS_LOW_AREA = ATLAS_MAX_SIZE * ATLAS_MAX_SIZE;
-var AUTO_ATLAS_MEDIUM_AREA = AUTO_ATLAS_LOW_AREA * 3;
-var AUTO_ATLAS_MAX_DECODED_BYTES_MOBILE = 4 * 1024 * 1024;
-var AUTO_ATLAS_MAX_DECODED_BYTES_DESKTOP = 16 * 1024 * 1024;
-var PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = Number.POSITIVE_INFINITY;
-
-// bench/entries/normalize.ts
-function preprocessModelPolygons2(polygons, normalizeGeometry) {
-  return optimizeMeshPolygons(polygons, {
-    meshResolution: normalizeGeometry ? "lossy" : "lossless"
-  });
-}
-function paintPolygonsSolid(polygons, color) {
-  return polygons.map((p) => ({
-    ...p,
-    color,
-    texture: void 0,
-    uvs: void 0,
-    textureTriangles: void 0
-  }));
-}
-function polygonsToWireframe(polygons, lineWidth, color) {
-  const out = [];
-  for (const p of polygons) {
-    const v = p.vertices;
-    if (!v || v.length < 3) continue;
-    const n = computePolygonNormal(v);
-    if (!n) continue;
-    const half = lineWidth / 2;
-    for (let i = 0; i < v.length; i++) {
-      const a = v[i];
-      const b = v[(i + 1) % v.length];
-      const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
-      const len = Math.hypot(dx, dy, dz);
-      if (len < 1e-9) continue;
-      const ex = dx / len, ey = dy / len, ez = dz / len;
-      const px = n[1] * ez - n[2] * ey;
-      const py = n[2] * ex - n[0] * ez;
-      const pz = n[0] * ey - n[1] * ex;
-      const plen = Math.hypot(px, py, pz) || 1;
-      const ox = px / plen * half;
-      const oy = py / plen * half;
-      const oz = pz / plen * half;
-      out.push({
-        vertices: [
-          [a[0] + ox, a[1] + oy, a[2] + oz],
-          [b[0] + ox, b[1] + oy, b[2] + oz],
-          [b[0] - ox, b[1] - oy, b[2] - oz],
-          [a[0] - ox, a[1] - oy, a[2] - oz]
-        ],
-        color
-      });
-    }
-  }
-  return out;
-}
-function computePolygonNormal(vertices) {
-  let nx = 0, ny = 0, nz = 0;
-  const o = vertices[0];
-  for (let i = 1; i < vertices.length - 1; i++) {
-    const a = vertices[i];
-    const b = vertices[i + 1];
-    const ax = a[0] - o[0], ay = a[1] - o[1], az = a[2] - o[2];
-    const bx = b[0] - o[0], by = b[1] - o[1], bz = b[2] - o[2];
-    nx += ay * bz - az * by;
-    ny += az * bx - ax * bz;
-    nz += ax * by - ay * bx;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len < 1e-12) return null;
-  return [nx / len, ny / len, nz / len];
-}
-export {
-  paintPolygonsSolid,
-  polygonsToWireframe,
-  preprocessModelPolygons2 as preprocessModelPolygons
-};
diff --git a/bench/snap-cracks.mjs b/bench/snap-cracks.mjs
deleted file mode 100644
index b419d72d..00000000
--- a/bench/snap-cracks.mjs
+++ /dev/null
@@ -1,51 +0,0 @@
-import { chromium } from "playwright";
-import { writeFileSync } from "node:fs";
-
-// Parse positional args: ignore --flags. argv[2] = url, argv[3] = output path.
-const positional = process.argv.slice(2).filter((a) => !a.startsWith("--"));
-const URL = (positional[0] && positional[0].length > 0)
-  ? positional[0]
-  : "http://localhost:4400/perf-cracks.html?mesh=sting&paint=red&normalize=true&autoCenter=true&rotX=83.79&rotY=182.21&zoom=1.6377";
-const OUT = positional[1] ?? "/tmp/snap.png";
-const SHOW_BACKFACES = process.argv.includes("--backfaces");
-const WIDTH = 1280, HEIGHT = 800;
-
-const browser = await chromium.launch();
-const ctx = await browser.newContext({ viewport: { width: WIDTH, height: HEIGHT }, deviceScaleFactor: 1 });
-const page = await ctx.newPage();
-await page.goto(URL);
-// .polycss-scene is a 0×0 anchor (position:absolute top/left:50%) so
-// Playwright's default visibility check fails. Wait for it to be in the
-// DOM instead, then for at least one rendered <i> child to exist.
-await page.waitForSelector(".polycss-scene", { state: "attached", timeout: 10000 });
-await page.waitForFunction(() => {
-  const scene = document.querySelector(".polycss-scene");
-  return scene && scene.querySelectorAll("i").length > 0;
-}, { timeout: 15000 });
-// Give the atlas blob URLs a moment to load + the browser to composite.
-await page.waitForTimeout(1500);
-
-// Hide the HUD/legend overlays so they don't cover the mesh in the shot.
-let css = "#hud, #legend, #cam { display: none !important; }";
-if (SHOW_BACKFACES) {
-  // Force backface visibility on every polygon — used to test whether
-  // visible "cracks" in red mode are actually back-culled polygons.
-  css += " .polycss-scene i { backface-visibility: visible !important; -webkit-backface-visibility: visible !important; }";
-}
-await page.addStyleTag({ content: css });
-await page.waitForTimeout(150);
-
-await page.screenshot({ path: OUT, fullPage: false });
-
-// Compute coverage stats: count R/G/B values across pixels.
-const stats = await page.evaluate(async () => {
-  const sceneEl = document.querySelector(".polycss-scene");
-  if (!sceneEl) return null;
-  const W = window.innerWidth, H = window.innerHeight;
-  // We can't easily readback DOM, so just return scene bbox + viewport size.
-  const r = sceneEl.getBoundingClientRect();
-  return { sceneBox: { x: r.x, y: r.y, w: r.width, h: r.height }, viewport: { w: W, h: H } };
-});
-console.log(JSON.stringify(stats));
-
-await browser.close();
diff --git a/bench/trace-frame-buckets.mjs b/bench/trace-analysis.mjs
similarity index 64%
rename from bench/trace-frame-buckets.mjs
rename to bench/trace-analysis.mjs
index f41650b5..5f042ecd 100644
--- a/bench/trace-frame-buckets.mjs
+++ b/bench/trace-analysis.mjs
@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+/**
+ * Chrome trace analysis for polycss camera-motion runs.
+ *
+ * Captures a perf or non-voxel bench page, aligns trace events to rAF frame
+ * samples, and reports compositor/style/raster/script cost per cadence bucket.
+ *
+ * Usage:
+ *   node bench/trace-analysis.mjs
+ *   node bench/trace-analysis.mjs --mesh ancient-crash-site --runs 3 --dom-samples
+ *   node bench/trace-analysis.mjs --mesh obj-house3 --renderer vanilla --label obj-house3-trace
+ *   node bench/trace-analysis.mjs --page nonvoxel --mesh glb:Elephant.glb --variant order-tile4 --no-trace
+ */
 import { createServer } from "node:http";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -6,6 +18,7 @@ import { dirname, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium } from "playwright";
 import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
+import { getNonVoxelVariantParams, knownNonVoxelVariantIds } from "./nonvoxel-variants.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
@@ -37,16 +50,20 @@ const optNum = (name, dflt) => {
 };
 const hasFlag = (name) => flag(name) >= 0;
 
-const MESH = optStr("mesh", "garden");
+const HELP = argv.includes("--help") || argv.includes("-h");
+const PAGE = optStr("page", "perf");
+const MESH = optStr("mesh", PAGE === "nonvoxel" ? "glb:Elephant.glb" : "garden");
 const MODE = optStr("mode", "baked");
 const MOTION = optStr("motion", "rot");
 const RENDERER = optStr("renderer", "vanilla");
+const VARIANT = optStr("variant", "baseline");
 const WARMUP_MS = optNum("warmup", 1500);
 const SAMPLE_MS = optNum("sample", 6000);
 const RUNS = optNum("runs", 1);
 const LABEL = optStr("label");
 const HEADED = hasFlag("headed");
 const JSON_ONLY = hasFlag("json");
+const TRACE = !hasFlag("no-trace");
 const DOM_SAMPLES = hasFlag("dom-samples");
 const BROWSER_EXECUTABLE = optStr("browser-executable");
 const SOFTWARE_BACKEND = hasFlag("software-backend");
@@ -129,6 +146,30 @@ const KEY_EVENTS = [
   "RasterTask",
 ];
 
+function printHelp() {
+  console.log(`Usage: node bench/trace-analysis.mjs [options]
+
+Options:
+  --page <name>               perf | nonvoxel. Default: perf
+  --mesh <id>                 Mesh id or path accepted by the selected page.
+  --renderer <name>           html | vanilla | react | vue. Default: vanilla
+  --variant <name>            Non-voxel page variant. Default: baseline
+  --mode <name>               baked | dynamic. Default: baked
+  --motion <name>             rot | light | none. Default: rot
+  --runs <n>                  Repeat count. Default: 1
+  --warmup <ms>               Warmup window. Default: 1500
+  --sample <ms>               Trace sample window. Default: 6000
+  --label <name>              Write bench/results/<name>.json
+  --no-trace                  Collect rAF bucket stats without Chrome tracing
+  --dom-samples               Sample mounted leaf/tag counts by rAF frame
+  --headed                    Run headed Chromium
+  --browser-executable <path> Use a specific Chromium/Chrome executable
+  --software-backend          Force the old software/stress backend
+  --chromium-arg <arg>        Extra Chromium arg, repeatable
+  --json                      Print only JSON
+`);
+}
+
 function startServer() {
   return new Promise((resolveStart, rejectStart) => {
     const server = createServer(async (req, res) => {
@@ -240,7 +281,10 @@ function attachDomSamples(frames, domSamples) {
     }
     const sample = domSamples[sampleIndex];
     if (sample && sample.t >= frame.start - 1 && sample.t <= frame.end + 1) {
-      frame.leaves = sample.leaves;
+      frame.leaves = sample.leaves ?? sample.leafCount;
+      frame.tags = sample.tags;
+      frame.bucketCount = sample.bucketCount;
+      frame.inlineStyleChars = sample.inlineStyleChars;
     }
   }
 }
@@ -266,6 +310,9 @@ function emptyBucket(bucket) {
     frame_time_p95_ms: null,
     leaves_p50: null,
     leaves_p95: null,
+    bucketCount_p50: null,
+    tags_p50: { b: null, i: null, s: null, u: null, q: null },
+    inlineStyleChars_p50: null,
     groups_ms_per_frame: {},
     events_ms_per_frame: {},
     topEvents: [],
@@ -279,19 +326,31 @@ function addDuration(map, name, durationMs) {
   map.set(name, entry);
 }
 
-function summarizeBuckets(events, frames, tracePerfOffsetMs) {
+function summarizeBuckets(events, frames, tracePerfOffsetMs, renderStats) {
+  const fallbackTags = renderStats?.dom?.tags ?? null;
+  const fallbackLeaves = renderStats?.dom?.leafCount ?? null;
+  const fallbackBucketCount = renderStats?.dom?.buckets ?? null;
+  const fallbackInlineStyleChars = renderStats?.dom?.inlineStyleChars ?? null;
   const buckets = new Map();
   for (const frame of frames) {
     const bucket = buckets.get(frame.bucket) ?? {
       ...emptyBucket(frame.bucket),
       frameDts: [],
       leaves: [],
+      bucketCounts: [],
+      inlineStyleChars: [],
+      tagCounts: { b: [], i: [], s: [], u: [], q: [] },
       eventTotals: new Map(),
       groupTotals: new Map(),
     };
     bucket.frameCount += 1;
     bucket.frameDts.push(frame.dt);
     if (Number.isFinite(frame.leaves)) bucket.leaves.push(frame.leaves);
+    if (Number.isFinite(frame.bucketCount)) bucket.bucketCounts.push(frame.bucketCount);
+    if (Number.isFinite(frame.inlineStyleChars)) bucket.inlineStyleChars.push(frame.inlineStyleChars);
+    for (const tag of ["b", "i", "s", "u", "q"]) {
+      if (Number.isFinite(frame.tags?.[tag])) bucket.tagCounts[tag].push(frame.tags[tag]);
+    }
     buckets.set(frame.bucket, bucket);
   }
 
@@ -326,6 +385,10 @@ function summarizeBuckets(events, frames, tracePerfOffsetMs) {
       for (const group of Object.keys(EVENT_GROUPS)) {
         groups_ms_per_frame[group] = +((bucket.groupTotals.get(group)?.duration_ms ?? 0) / frameCount).toFixed(4);
       }
+      const tags_p50 = {};
+      for (const tag of ["b", "i", "s", "u", "q"]) {
+        tags_p50[tag] = bucket.tagCounts[tag].length ? +(median(bucket.tagCounts[tag]) ?? 0).toFixed(0) : null;
+      }
       const topEvents = [...bucket.eventTotals.entries()]
         .map(([event, total]) => ({
           event,
@@ -334,17 +397,24 @@ function summarizeBuckets(events, frames, tracePerfOffsetMs) {
         }))
         .sort((a, b) => b.ms_per_frame - a.ms_per_frame)
         .slice(0, 12);
-      return {
+      const summary = {
         bucket: name,
         frameCount: bucket.frameCount,
         frame_time_p50_ms: +(median(bucket.frameDts) ?? 0).toFixed(3),
         frame_time_p95_ms: +(quantile(bucket.frameDts, 0.95) ?? 0).toFixed(3),
-        leaves_p50: bucket.leaves.length ? +(median(bucket.leaves) ?? 0).toFixed(0) : null,
+        leaves_p50: bucket.leaves.length ? +(median(bucket.leaves) ?? 0).toFixed(0) : fallbackLeaves,
         leaves_p95: bucket.leaves.length ? +(quantile(bucket.leaves, 0.95) ?? 0).toFixed(0) : null,
+        bucketCount_p50: bucket.bucketCounts.length ? +(median(bucket.bucketCounts) ?? 0).toFixed(0) : fallbackBucketCount,
+        tags_p50,
+        inlineStyleChars_p50: bucket.inlineStyleChars.length ? +(median(bucket.inlineStyleChars) ?? 0).toFixed(0) : fallbackInlineStyleChars,
         groups_ms_per_frame,
         events_ms_per_frame,
         topEvents,
       };
+      if (fallbackTags && Object.values(tags_p50).every((value) => value === null)) {
+        summary.tags_p50 = fallbackTags;
+      }
+      return summary;
     });
 }
 
@@ -362,6 +432,11 @@ function aggregateEventTotals(events, tracePerfOffsetMs, startPerfNow, endPerfNo
     .slice(0, 40);
 }
 
+function tagText(tags) {
+  if (!tags) return "";
+  return `b/i/s/u/q=${tags.b ?? ""}/${tags.i ?? ""}/${tags.s ?? ""}/${tags.u ?? ""}/${tags.q ?? ""}`;
+}
+
 async function startTrace(cdp) {
   const events = [];
   cdp.on("Tracing.dataCollected", (payload) => {
@@ -382,6 +457,26 @@ async function stopTrace(cdp) {
   });
 }
 
+function pageUrl(port) {
+  if (PAGE === "nonvoxel") {
+    const variantParams = getNonVoxelVariantParams(VARIANT);
+    if (!variantParams) {
+      throw new Error(`Unknown --variant "${VARIANT}". Known: ${knownNonVoxelVariantIds().join(", ")}`);
+    }
+    const params = new URLSearchParams({
+      mesh: MESH,
+      mode: MODE,
+      motion: MOTION,
+      ...variantParams,
+    });
+    return `http://127.0.0.1:${port}/nonvoxel-vanilla.html?${params.toString()}`;
+  }
+  if (PAGE !== "perf") {
+    throw new Error(`Unknown --page "${PAGE}". Expected "perf" or "nonvoxel".`);
+  }
+  return `http://127.0.0.1:${port}/perf-${RENDERER}.html?mesh=${encodeURIComponent(MESH)}&mode=${encodeURIComponent(MODE)}&motion=${encodeURIComponent(MOTION)}`;
+}
+
 async function runOnce(port, repeat) {
   const launchOptions = { headless: !HEADED, args: CHROMIUM_ARGS };
   if (BROWSER_EXECUTABLE) launchOptions.executablePath = BROWSER_EXECUTABLE;
@@ -389,40 +484,71 @@ async function runOnce(port, repeat) {
   try {
     const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
     const page = await ctx.newPage();
-    const cdp = await ctx.newCDPSession(page);
-    const url = `http://127.0.0.1:${port}/perf-${RENDERER}.html?mesh=${encodeURIComponent(MESH)}&mode=${encodeURIComponent(MODE)}&motion=${encodeURIComponent(MOTION)}`;
+    const pageDiagnostics = [];
+    page.on("console", (message) => {
+      if (message.type() === "error") pageDiagnostics.push(`[console:${message.type()}] ${message.text()}`);
+    });
+    page.on("pageerror", (error) => {
+      pageDiagnostics.push(`[pageerror] ${error?.stack || error?.message || error}`);
+    });
+    const cdp = TRACE ? await ctx.newCDPSession(page) : null;
+    const url = pageUrl(port);
     await page.goto(url, { waitUntil: "load" });
-    await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 30000 });
+    try {
+      await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 30000 });
+    } catch (error) {
+      const details = pageDiagnostics.length ? `\n${pageDiagnostics.join("\n")}` : "";
+      throw new Error(`Perf page did not become ready for ${url}.${details}`, { cause: error });
+    }
     await page.waitForTimeout(WARMUP_MS);
 
-    const events = await startTrace(cdp);
+    const events = TRACE ? await startTrace(cdp) : [];
     const startIdx = await page.evaluate(() => window.__perf__.samples.length);
-    if (DOM_SAMPLES) {
-      await page.evaluate(() => {
+    const startPerfNow = await page.evaluate(({ traceEnabled, domSamples }) => {
+      if (domSamples) {
         window.__polycssDomSamples = [];
         window.__polycssDomSampling = true;
         const tick = (now) => {
           const mesh = document.querySelector(".polycss-voxel-mesh");
+          const sceneRoot = document.querySelector(".polycss-scene");
+          const tags = { b: 0, i: 0, s: 0, u: 0, q: 0 };
+          let inlineStyleChars = 0;
+          if (sceneRoot) {
+            for (const tag of Object.keys(tags)) tags[tag] = sceneRoot.querySelectorAll(tag).length;
+            for (const el of sceneRoot.querySelectorAll("b,i,s,u,q")) {
+              inlineStyleChars += el.getAttribute("style")?.length ?? 0;
+            }
+          }
           window.__polycssDomSamples.push({
             t: now,
-            leaves: mesh?.childElementCount ?? 0,
+            leaves: mesh?.childElementCount ?? tags.b + tags.i + tags.s + tags.u,
+            tags,
+            bucketCount: sceneRoot?.querySelectorAll(".polycss-bucket").length ?? 0,
+            inlineStyleChars,
           });
           if (window.__polycssDomSampling) requestAnimationFrame(tick);
         };
         requestAnimationFrame(tick);
-      });
-    }
-    await page.evaluate(() => {
-      performance.mark("__polycss_frame_bucket_start__");
-      console.timeStamp("__polycss_frame_bucket_start__");
-    });
+      } else {
+        window.__polycssDomSamples = [];
+        window.__polycssDomSampling = false;
+      }
+      if (traceEnabled) {
+        performance.mark("__polycss_trace_analysis_start__");
+        console.timeStamp("__polycss_trace_analysis_start__");
+      }
+      return performance.now();
+    }, { traceEnabled: TRACE, domSamples: DOM_SAMPLES });
     await page.waitForTimeout(SAMPLE_MS);
-    await page.evaluate(() => {
-      performance.mark("__polycss_frame_bucket_end__");
-      console.timeStamp("__polycss_frame_bucket_end__");
+    const endPerfNow = await page.evaluate((traceEnabled) => {
+      if (traceEnabled) {
+        performance.mark("__polycss_trace_analysis_end__");
+        console.timeStamp("__polycss_trace_analysis_end__");
+      }
       window.__polycssDomSampling = false;
-    });
-    await stopTrace(cdp);
+      return performance.now();
+    }, TRACE);
+    if (TRACE) await stopTrace(cdp);
 
     const pageResult = await page.evaluate((from) => ({
       samples: window.__perf__.samples.slice(from),
@@ -432,26 +558,35 @@ async function runOnce(port, repeat) {
     }), startIdx);
     await ctx.close();
 
-    const startMark = findTraceMark(events, "__polycss_frame_bucket_start__");
-    const endMark = findTraceMark(events, "__polycss_frame_bucket_end__");
-    if (!startMark?.args?.data?.startTime || !endMark?.args?.data?.startTime) {
-      throw new Error("Trace markers were not captured; cannot align trace to rAF samples.");
+    let tracePerfOffsetMs = 0;
+    let alignedStartPerfNow = startPerfNow;
+    let alignedEndPerfNow = endPerfNow;
+    if (TRACE) {
+      const startMark = findTraceMark(events, "__polycss_trace_analysis_start__");
+      const endMark = findTraceMark(events, "__polycss_trace_analysis_end__");
+      if (!startMark?.args?.data?.startTime || !endMark?.args?.data?.startTime) {
+        throw new Error("Trace markers were not captured; cannot align trace to rAF samples.");
+      }
+      tracePerfOffsetMs = (startMark.ts / 1000) - startMark.args.data.startTime;
+      alignedStartPerfNow = startMark.args.data.startTime;
+      alignedEndPerfNow = endMark.args.data.startTime;
     }
-    const tracePerfOffsetMs = (startMark.ts / 1000) - startMark.args.data.startTime;
-    const startPerfNow = startMark.args.data.startTime;
-    const endPerfNow = endMark.args.data.startTime;
-    const { frames, baseFrameMs } = makeFrames(pageResult.samples, startPerfNow, endPerfNow);
+    const { frames, baseFrameMs } = makeFrames(pageResult.samples, alignedStartPerfNow, alignedEndPerfNow);
     attachDomSamples(frames, pageResult.domSamples);
     const frameStats = summarizeFrameTimes(frames);
-    const buckets = summarizeBuckets(events, frames, tracePerfOffsetMs);
-    const eventTotals = aggregateEventTotals(events, tracePerfOffsetMs, startPerfNow, endPerfNow);
+    const buckets = summarizeBuckets(events, frames, tracePerfOffsetMs, pageResult.renderStats);
+    const eventTotals = aggregateEventTotals(events, tracePerfOffsetMs, alignedStartPerfNow, alignedEndPerfNow);
 
     return {
       repeat,
+      page: PAGE,
       mesh: MESH,
       renderer: RENDERER,
+      ...(PAGE === "nonvoxel" ? { variant: VARIANT } : {}),
       mode: MODE,
       motion: MOTION,
+      trace: TRACE,
+      domSamples: DOM_SAMPLES,
       warmup_ms: WARMUP_MS,
       sample_ms: SAMPLE_MS,
       baseFrameMs: +baseFrameMs.toFixed(3),
@@ -473,10 +608,10 @@ function printRun(run) {
     .map((bucket) => `${bucket.bucket}:${bucket.frameCount}`)
     .join(" ");
   console.log(
-    `[trace-buckets] ${run.mesh} r${run.repeat} p50=${fmt(run.fps_p50, 1)} p95=${fmt(run.fps_p95, 1)} p99=${fmt(run.frame_time_p99_ms, 1)}ms base=${fmt(run.baseFrameMs, 3)}ms ${bucketText}`,
+    `[trace-analysis] ${run.mesh}${run.variant ? ` ${run.variant}` : ""} r${run.repeat} p50=${fmt(run.fps_p50, 1)} p95=${fmt(run.fps_p95, 1)} p99=${fmt(run.frame_time_p99_ms, 1)}ms base=${fmt(run.baseFrameMs, 3)}ms ${bucketText}`,
   );
-  console.log("| Bucket | Frames | Leaves p50 | dt p50 | dt p95 | style | prePaint | PAC | layerize | drawProps | visible | prepareDraw | draw | raster | script |");
-  console.log("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
+  console.log("| Bucket | Frames | Leaves p50 | Tags p50 | dt p50 | dt p95 | style | prePaint | PAC | layerize | drawProps | visible | prepareDraw | draw | raster | script |");
+  console.log("| --- | ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
   for (const bucket of run.buckets) {
     if (bucket.frameCount === 0) continue;
     const e = bucket.events_ms_per_frame;
@@ -485,6 +620,7 @@ function printRun(run) {
       `| ${bucket.bucket}`,
       bucket.frameCount,
       fmt(bucket.leaves_p50, 0),
+      tagText(bucket.tags_p50),
       fmt(bucket.frame_time_p50_ms),
       fmt(bucket.frame_time_p95_ms),
       fmt(g.style, 4),
@@ -501,11 +637,16 @@ function printRun(run) {
   }
 }
 
+if (HELP) {
+  printHelp();
+  process.exit(0);
+}
+
 const { server, port } = await startServer();
 try {
   if (!JSON_ONLY) {
-    console.log(`[trace-buckets] server :${port}`);
-    console.log(`[trace-buckets] mesh=${MESH} renderer=${RENDERER} mode=${MODE} motion=${MOTION} runs=${RUNS} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms`);
+    console.log(`[trace-analysis] server :${port}`);
+    console.log(`[trace-analysis] page=${PAGE} mesh=${MESH} renderer=${RENDERER} variant=${PAGE === "nonvoxel" ? VARIANT : "n/a"} mode=${MODE} motion=${MOTION} trace=${TRACE ? "on" : "off"} domSamples=${DOM_SAMPLES ? "on" : "off"} runs=${RUNS} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms`);
   }
   const runs = [];
   for (let repeat = 1; repeat <= RUNS; repeat += 1) {
@@ -514,10 +655,15 @@ try {
     if (!JSON_ONLY) printRun(run);
   }
   const out = {
+    kind: "trace-analysis",
+    page: PAGE,
     mesh: MESH,
     renderer: RENDERER,
+    ...(PAGE === "nonvoxel" ? { variant: VARIANT } : {}),
     mode: MODE,
     motion: MOTION,
+    trace: TRACE,
+    domSamples: DOM_SAMPLES,
     browserExecutable: BROWSER_EXECUTABLE || null,
     chromiumArgs: CHROMIUM_ARGS,
     softwareBackend: SOFTWARE_BACKEND,
@@ -530,7 +676,7 @@ try {
     mkdirSync(dir, { recursive: true });
     const file = resolve(dir, `${LABEL}.json`);
     writeFileSync(file, JSON.stringify(out, null, 2) + "\n");
-    if (!JSON_ONLY) console.log(`[trace-buckets] wrote ${file}`);
+    if (!JSON_ONLY) console.log(`[trace-analysis] wrote ${file}`);
   }
   if (JSON_ONLY) console.log(JSON.stringify(out, null, 2));
 } finally {
diff --git a/bench/trace-event-args.mjs b/bench/trace-event-args.mjs
deleted file mode 100644
index a04e933a..00000000
--- a/bench/trace-event-args.mjs
+++ /dev/null
@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-import { createServer } from "node:http";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { chromium } from "playwright";
-import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, "..");
-const benchDir = resolve(repoRoot, "bench");
-const galleryDir = resolve(repoRoot, "website/public/gallery");
-
-const args = new Map(process.argv.slice(2).map((arg) => {
-  const [key, ...rest] = arg.replace(/^--/, "").split("=");
-  return [key, rest.length ? rest.join("=") : "true"];
-}));
-
-const MESH = args.get("mesh") ?? "obj-house3";
-const RENDERER = args.get("renderer") ?? "vanilla";
-const MODE = args.get("mode") ?? "baked";
-const MOTION = args.get("motion") ?? "rot";
-const WARMUP_MS = Number(args.get("warmup") ?? 1200);
-const SAMPLE_MS = Number(args.get("sample") ?? 2500);
-const HEADED = args.has("headed");
-const SOFTWARE_BACKEND = args.has("software-backend");
-const CHROMIUM_ARGS = chromiumArgsWithGpuDefault((args.get("chromium-args") ?? "")
-  .split(/\s+/)
-  .map((value) => value.trim())
-  .filter(Boolean), { softwareBackend: SOFTWARE_BACKEND });
-const EVENT_NAMES = (args.get("events") ??
-  "SoftwareRenderer::DoDrawQuad,DirectRenderer::DrawRenderPass,MainFrame.Draw,LayerTreeHostImpl::PrepareToDraw")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-
-const MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".obj": "text/plain; charset=utf-8",
-  ".mtl": "text/plain; charset=utf-8",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gltf": "application/json; charset=utf-8",
-  ".glb": "model/gltf-binary",
-  ".vox": "application/octet-stream",
-};
-
-const TRACE_CATEGORIES = [
-  "devtools.timeline",
-  "disabled-by-default-devtools.timeline",
-  "blink",
-  "cc",
-  "disabled-by-default-cc.debug",
-  "gpu",
-  "viz",
-  "disabled-by-default-viz.debug",
-  "renderer.scheduler",
-].join(",");
-
-function startServer() {
-  return new Promise((resolveStart, rejectStart) => {
-    const server = createServer(async (req, res) => {
-      try {
-        const u = new URL(req.url, "http://localhost");
-        const safe = u.pathname.replace(/\/+/g, "/");
-        if (safe.includes("..")) {
-          res.writeHead(403);
-          res.end();
-          return;
-        }
-        const abs = safe === "/" || safe === ""
-          ? resolve(benchDir, "perf.html")
-          : safe.startsWith("/gallery/")
-            ? resolve(galleryDir, safe.slice("/gallery/".length))
-            : resolve(benchDir, safe.slice(1));
-        const data = await readFile(abs);
-        res.writeHead(200, {
-          "Content-Type": MIME[extname(abs).toLowerCase()] || "application/octet-stream",
-          "Cache-Control": "no-store",
-        });
-        res.end(data);
-      } catch (err) {
-        res.writeHead(404);
-        res.end(String(err?.message ?? err));
-      }
-    });
-    server.on("error", rejectStart);
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolveStart({ server, port: typeof addr === "object" ? addr.port : 0 });
-    });
-  });
-}
-
-function stopServer(server) {
-  return new Promise((resolveStop) => server.close(resolveStop));
-}
-
-function collectArgShape(value, depth = 0) {
-  if (value == null || depth > 2) return value;
-  if (typeof value !== "object") return typeof value;
-  if (Array.isArray(value)) return [`array(${value.length})`, collectArgShape(value[0], depth + 1)];
-  return Object.fromEntries(Object.entries(value).slice(0, 12).map(([key, item]) => [
-    key,
-    collectArgShape(item, depth + 1),
-  ]));
-}
-
-const { server, port } = await startServer();
-const browser = await chromium.launch({
-  headless: !HEADED,
-  args: [
-    "--disable-background-timer-throttling",
-    "--disable-renderer-backgrounding",
-    "--disable-backgrounding-occluded-windows",
-    ...CHROMIUM_ARGS,
-  ],
-});
-
-try {
-  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
-  const page = await ctx.newPage();
-  const cdp = await ctx.newCDPSession(page);
-  const events = [];
-  cdp.on("Tracing.dataCollected", (payload) => {
-    if (Array.isArray(payload.value)) events.push(...payload.value);
-  });
-  const url = `http://127.0.0.1:${port}/perf-${RENDERER}.html?mesh=${encodeURIComponent(MESH)}&mode=${encodeURIComponent(MODE)}&motion=${encodeURIComponent(MOTION)}`;
-  await page.goto(url, { waitUntil: "load" });
-  await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 30000 });
-  await page.waitForTimeout(WARMUP_MS);
-  await cdp.send("Tracing.start", {
-    transferMode: "ReportEvents",
-    categories: TRACE_CATEGORIES,
-  });
-  await page.waitForTimeout(SAMPLE_MS);
-  await new Promise(async (resolveStop) => {
-    cdp.once("Tracing.tracingComplete", resolveStop);
-    await cdp.send("Tracing.end");
-  });
-  for (const eventName of EVENT_NAMES) {
-    const matches = events.filter((event) => event.name === eventName);
-    console.log(`\n## ${eventName} (${matches.length})`);
-    const samples = matches.slice(0, 8).map((event) => ({
-      ph: event.ph,
-      dur_us: event.dur,
-      cat: event.cat,
-      argsShape: collectArgShape(event.args),
-      args: event.args,
-    }));
-    console.dir(samples, { depth: 8, colors: false, maxArrayLength: 20 });
-  }
-  await ctx.close();
-} finally {
-  await browser.close();
-  await stopServer(server);
-}
diff --git a/bench/trace-summary.mjs b/bench/trace-summary.mjs
deleted file mode 100644
index 072916d6..00000000
--- a/bench/trace-summary.mjs
+++ /dev/null
@@ -1,276 +0,0 @@
-#!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-import { basename } from "node:path";
-
-const args = process.argv.slice(2);
-const files = args.filter((arg) => !arg.startsWith("--"));
-const limitArg = args.find((arg) => arg.startsWith("--limit="));
-const LIMIT = Number(limitArg?.slice("--limit=".length) ?? 10);
-const jsonMode = args.includes("--json");
-
-if (files.length === 0) {
-  console.error("usage: node bench/trace-summary.mjs <result.json...> [--limit=10] [--json]");
-  process.exit(1);
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function eventMap(trace) {
-  const out = new Map();
-  for (const [name, entry] of Object.entries(trace?.eventTotals ?? {})) {
-    out.set(name, {
-      count: Number(entry?.count) || 0,
-      duration_ms: Number(entry?.duration_ms) || 0,
-    });
-  }
-  for (const event of trace?.topEvents ?? []) {
-    if (out.has(event.name)) continue;
-    out.set(event.name, {
-      count: Number(event.count) || 0,
-      duration_ms: Number(event.duration_ms) || 0,
-    });
-  }
-  return out;
-}
-
-function eventDurationMs(events, name) {
-  return events.get(name)?.duration_ms ?? 0;
-}
-
-function eventCount(events, name) {
-  return events.get(name)?.count ?? 0;
-}
-
-function groupDurationMs(trace, name) {
-  return trace?.groups?.[name]?.duration_ms ?? 0;
-}
-
-function groupCount(trace, name) {
-  return trace?.groups?.[name]?.count ?? 0;
-}
-
-function inferFrameCount(row) {
-  const events = eventMap(row.trace);
-  const candidates = [
-    eventCount(events, "ProxyMain::BeginMainFrame"),
-    eventCount(events, "WebFrameWidgetImpl::UpdateLifecycle"),
-    eventCount(events, "Layerize"),
-    groupCount(row.trace, "prePaint"),
-    groupCount(row.trace, "style"),
-    row.sample_count,
-  ].filter((value) => Number.isFinite(value) && value > 0);
-  return candidates.length ? Math.max(1, Math.round(median(candidates))) : 1;
-}
-
-function leafCount(run) {
-  if (Number.isFinite(run?.dom?.leaves)) return run.dom.leaves;
-  if (Number.isFinite(run?.dom?.brushes)) return run.dom.brushes;
-  if (Number.isFinite(run?.dom?.voxelBrushes)) return run.dom.voxelBrushes;
-  const tags = run?.dom?.tags ?? run?.renderStats?.dom?.tags;
-  if (tags) return ["b", "i", "s", "u"].reduce((sum, tag) => sum + (Number(tags[tag]) || 0), 0);
-  if (Number.isFinite(run?.renderStats?.dom?.leafCount)) return run.renderStats.dom.leafCount;
-  return null;
-}
-
-function nodeCount(run) {
-  return run?.performanceMetrics?.Nodes ?? null;
-}
-
-function pushBenchLeaf(rows, file, path, value) {
-  if (!value?.trace) return;
-  rows.push({
-    id: `${basename(file)}:${path.join(".")}`,
-    source: file,
-    path: path.join("."),
-    fps_p50: value.fps_p50,
-    fps_p95: value.fps_p95,
-    frame_time_p99_ms: value.frame_time_p99_ms,
-    sample_count: value.sample_count,
-    nodes: nodeCount(value),
-    leaves: leafCount(value),
-    trace: value.trace,
-    cadence: value.cadence,
-  });
-}
-
-function walkBenchObject(rows, file, path, value) {
-  if (!value || typeof value !== "object") return;
-  if (value.trace) {
-    pushBenchLeaf(rows, file, path, value);
-    return;
-  }
-  for (const [key, child] of Object.entries(value)) {
-    if (["trace", "renderStats", "performanceMetrics"].includes(key)) continue;
-    walkBenchObject(rows, file, [...path, key], child);
-  }
-}
-
-function extractRows(file, data) {
-  const rows = [];
-  if (data?.cases && typeof data.cases === "object") {
-    for (const [caseId, entry] of Object.entries(data.cases)) {
-      for (const run of entry?.runs ?? []) {
-        if (!run?.trace) continue;
-        rows.push({
-          id: `${basename(file)}:${caseId}`,
-          source: file,
-          path: caseId,
-          repeat: run.repeat,
-          fps_p50: run.fps_p50,
-          fps_p95: run.fps_p95,
-          frame_time_p99_ms: run.frame_time_p99_ms,
-          sample_count: run.sample_count,
-          nodes: nodeCount(run),
-          leaves: leafCount(run),
-          trace: run.trace,
-          cadence: run.cadence,
-        });
-      }
-    }
-    return rows;
-  }
-  walkBenchObject(rows, file, [], data);
-  return rows;
-}
-
-function aggregateRows(rows) {
-  const byId = new Map();
-  for (const row of rows) {
-    const bucket = byId.get(row.id) ?? [];
-    bucket.push(row);
-    byId.set(row.id, bucket);
-  }
-
-  return [...byId.entries()].map(([id, runs]) => {
-    const frameCounts = runs.map(inferFrameCount);
-    const frames = median(frameCounts) ?? 1;
-    const valuesForEvent = (name) =>
-      runs.map((row) => eventDurationMs(eventMap(row.trace), name) / inferFrameCount(row));
-    const valuesForGroup = (name) =>
-      runs.map((row) => groupDurationMs(row.trace, name) / inferFrameCount(row));
-    const topEvents = new Map();
-    for (const row of runs) {
-      const framesForRun = inferFrameCount(row);
-      for (const event of row.trace?.topEvents ?? []) {
-        const list = topEvents.get(event.name) ?? [];
-        list.push((Number(event.duration_ms) || 0) / framesForRun);
-        topEvents.set(event.name, list);
-      }
-    }
-    const top = [...topEvents.entries()]
-      .map(([name, values]) => ({ name, ms_per_frame: median(values) ?? 0 }))
-      .sort((a, b) => b.ms_per_frame - a.ms_per_frame)
-      .slice(0, LIMIT);
-
-    return {
-      id,
-      runs: runs.length,
-      fps_p50: median(runs.map((run) => run.fps_p50)),
-      fps_p95: median(runs.map((run) => run.fps_p95)),
-      p99_ms: median(runs.map((run) => run.frame_time_p99_ms)),
-      frames,
-      nodes: median(runs.map((run) => run.nodes)),
-      leaves: median(runs.map((run) => run.leaves)),
-      ms_per_frame: {
-        style: median(valuesForGroup("style")),
-        layout: median(valuesForGroup("layout")),
-        prePaint: median(valuesForGroup("prePaint")),
-        paint: median(valuesForGroup("paint")),
-        raster: median(valuesForGroup("raster")),
-        script: median(valuesForGroup("script")),
-        beginMainFrame: median(valuesForEvent("ProxyMain::BeginMainFrame")),
-        updateLifecycle: median(valuesForEvent("WebFrameWidgetImpl::UpdateLifecycle")),
-        paintArtifactCompositor: median(valuesForEvent("PaintArtifactCompositor::Update")),
-        layerize: median(valuesForEvent("Layerize")),
-        readyToCommit: median(valuesForEvent("ProxyImpl::ReadyToCommit")),
-        drawProperties: median(valuesForEvent("LayerTreeImpl::UpdateDrawProperties")),
-        calculateDrawProperties: median(valuesForEvent("LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties")),
-        prepareToDraw: median(valuesForEvent("LayerTreeHostImpl::PrepareToDraw")),
-        mainFrameDraw: median(valuesForEvent("MainFrame.Draw")),
-        commit: median(valuesForEvent("Commit")),
-      },
-      cadence_pct: {
-        x1: median(runs.map((run) => run.cadence?.vsync_pct?.x1)),
-        x2: median(runs.map((run) => run.cadence?.vsync_pct?.x2)),
-        x3: median(runs.map((run) => run.cadence?.vsync_pct?.x3)),
-        x4_plus: median(runs.map((run) => run.cadence
-          ? (run.cadence?.vsync_pct?.x4 ?? 0) +
-            (run.cadence?.vsync_pct?.x5 ?? 0) +
-            (run.cadence?.vsync_pct?.x6_plus ?? 0)
-          : undefined,
-        )),
-      },
-      topEvents: top,
-    };
-  });
-}
-
-function fmt(value, digits = 2) {
-  return Number.isFinite(value) ? Number(value).toFixed(digits) : "";
-}
-
-function usPerLeaf(row, key) {
-  const leaves = Number(row.leaves);
-  const ms = Number(row.ms_per_frame[key]);
-  if (!Number.isFinite(leaves) || leaves <= 0 || !Number.isFinite(ms)) return null;
-  return (ms * 1000) / leaves;
-}
-
-const allRows = [];
-for (const file of files) {
-  const data = JSON.parse(await readFile(file, "utf8"));
-  allRows.push(...extractRows(file, data));
-}
-
-const summary = aggregateRows(allRows).sort((a, b) => a.id.localeCompare(b.id));
-
-if (jsonMode) {
-  console.log(JSON.stringify(summary, null, 2));
-} else {
-  console.log("| Case | Runs | FPS p95 | P99 ms | 1x vsync | 2x vsync | 3x vsync | 4x+ vsync | Frames | Nodes | Leaves | PAC ms/f | PAC us/leaf | DrawProps ms/f | DrawProps us/leaf | Draw ms/f | Draw us/leaf | Paint ms/f | Raster ms/f | Script ms/f |");
-  console.log("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-  for (const row of summary) {
-    console.log([
-      `| ${row.id}`,
-      row.runs,
-      fmt(row.fps_p95, 1),
-      fmt(row.p99_ms, 2),
-      fmt(row.cadence_pct.x1, 1),
-      fmt(row.cadence_pct.x2, 1),
-      fmt(row.cadence_pct.x3, 1),
-      fmt(row.cadence_pct.x4_plus, 1),
-      fmt(row.frames, 0),
-      fmt(row.nodes, 0),
-      fmt(row.leaves, 0),
-      fmt(row.ms_per_frame.paintArtifactCompositor),
-      fmt(usPerLeaf(row, "paintArtifactCompositor"), 3),
-      fmt(row.ms_per_frame.drawProperties),
-      fmt(usPerLeaf(row, "drawProperties"), 3),
-      fmt(row.ms_per_frame.mainFrameDraw),
-      fmt(usPerLeaf(row, "mainFrameDraw"), 3),
-      fmt(row.ms_per_frame.paint),
-      fmt(row.ms_per_frame.raster),
-      `${fmt(row.ms_per_frame.script)} |`,
-    ].join(" | "));
-  }
-
-  console.log("\nTop event medians are per inferred frame. Trace events are nested, so columns are diagnostic, not additive.");
-  for (const row of summary) {
-    console.log(`\n${row.id}`);
-    for (const event of row.topEvents) {
-      console.log(`- ${event.name}: ${fmt(event.ms_per_frame)} ms/f`);
-    }
-  }
-}
diff --git a/bench/voxel-browser-summary.mjs b/bench/voxel-browser-summary.mjs
deleted file mode 100644
index 5e2c74ac..00000000
--- a/bench/voxel-browser-summary.mjs
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const resultDir = process.argv[2] ?? "bench/results";
-const prefixes = process.argv.slice(3);
-const selectedPrefixes = prefixes.length
-  ? prefixes
-  : ["browser-chrome", "browser-canary", "browser-chrome-headed"];
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function winnerFor(deltaP95, deltaP99) {
-  if (Math.abs(deltaP95) >= 8) return deltaP95 > 0 ? "matrix" : "slice";
-  if (Math.abs(deltaP99) >= 8) return deltaP99 > 0 ? "matrix-p99" : "slice-p99";
-  return "flat";
-}
-
-const files = await readdir(resultDir);
-
-function matchesPrefix(file, prefix) {
-  if (!file.startsWith(`${prefix}-`) || !file.endsWith("-rotation-compare.json")) return false;
-  return !selectedPrefixes.some((other) =>
-    other !== prefix &&
-    other.startsWith(`${prefix}-`) &&
-    file.startsWith(`${other}-`)
-  );
-}
-
-for (const prefix of selectedPrefixes) {
-  const rows = [];
-  for (const file of files) {
-    if (!matchesPrefix(file, prefix)) continue;
-    const data = JSON.parse(await readFile(join(resultDir, file), "utf8"));
-    const matrixRuns = data.cases?.["polycss-matrix"]?.runs ?? [];
-    const sliceRuns = data.cases?.["polycss-baked-voxzoom"]?.runs ?? [];
-    if (matrixRuns.length === 0 || sliceRuns.length === 0) continue;
-    const matrixP95 = median(matrixRuns.map((run) => run.fps_p95));
-    const sliceP95 = median(sliceRuns.map((run) => run.fps_p95));
-    const matrixP99 = median(matrixRuns.map((run) => run.frame_time_p99_ms));
-    const sliceP99 = median(sliceRuns.map((run) => run.frame_time_p99_ms));
-    rows.push({
-      model: String(data.model ?? file).replace(/\.vox$/, ""),
-      runs: Math.min(matrixRuns.length, sliceRuns.length),
-      winner: winnerFor(matrixP95 - sliceP95, sliceP99 - matrixP99),
-      matrixP95,
-      sliceP95,
-      matrixP99,
-      sliceP99,
-      browser: matrixRuns[0]?.browserVersion ?? "",
-    });
-  }
-
-  rows.sort((a, b) => a.model.localeCompare(b.model));
-  console.log(`\n## ${prefix}${rows[0]?.browser ? ` (${rows[0].browser})` : ""}\n`);
-  console.log("| Model | Winner | Runs | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 |");
-  console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: |");
-  for (const row of rows) {
-    console.log([
-      `| ${row.model}`,
-      row.winner,
-      row.runs,
-      fmt(row.matrixP95),
-      fmt(row.sliceP95),
-      fmt(row.matrixP99),
-      `${fmt(row.sliceP99)} |`,
-    ].join(" | "));
-  }
-}
diff --git a/bench/voxel-cadence-summary.mjs b/bench/voxel-cadence-summary.mjs
deleted file mode 100644
index ea6955b7..00000000
--- a/bench/voxel-cadence-summary.mjs
+++ /dev/null
@@ -1,184 +0,0 @@
-#!/usr/bin/env node
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, join } from "node:path";
-
-const resultDir = process.argv[2] ?? "bench/results";
-
-const FILE_PATTERNS = [
-  [/^cadence-clean-(.*)-rotation-compare\.json$/, 1, "clean"],
-  [/^cadence-wide-(.*)-rotation-compare\.json$/, 2, "wide"],
-  [/^cadence-extended-(.*)-rotation-compare\.json$/, 3, "extended"],
-  [/^cadence-validate-(.*)-rotation-compare\.json$/, 4, "validated"],
-];
-
-function matchFile(file) {
-  for (const [pattern, priority, label] of FILE_PATTERNS) {
-    const match = pattern.exec(file);
-    if (match) return { key: match[1], priority, label };
-  }
-  return null;
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function cadence4Plus(run) {
-  const pct = run.cadence?.vsync_pct;
-  if (!pct) return null;
-  return (pct.x4 ?? 0) + (pct.x5 ?? 0) + (pct.x6_plus ?? 0);
-}
-
-function winnerFor(deltaP95, deltaP99) {
-  if (Math.abs(deltaP95) >= 8) return deltaP95 > 0 ? "matrix" : "slice";
-  if (Math.abs(deltaP99) >= 8) return deltaP99 > 0 ? "matrix-p99" : "slice-p99";
-  return "flat";
-}
-
-async function loadRows() {
-  const selected = new Map();
-  for (const file of await readdir(resultDir)) {
-    const match = matchFile(file);
-    if (!match) continue;
-    const path = join(resultDir, file);
-    const mtime = (await stat(path)).mtimeMs;
-    const current = selected.get(match.key);
-    if (
-      !current ||
-      match.priority > current.priority ||
-      (match.priority === current.priority && mtime > current.mtime)
-    ) {
-      selected.set(match.key, { ...match, path, mtime });
-    }
-  }
-
-  const rows = [];
-  for (const entry of selected.values()) {
-    const data = JSON.parse(await readFile(entry.path, "utf8"));
-    const matrixRuns = data.cases?.["polycss-matrix"]?.runs ?? [];
-    const sliceRuns = data.cases?.["polycss-baked-voxzoom"]?.runs ?? [];
-    if (matrixRuns.length === 0 || sliceRuns.length === 0) continue;
-
-    const slice = sliceRuns[0];
-    const meta = slice.metadata ?? {};
-    const brush = slice.brushMetrics ?? {};
-    const matrixP95 = median(matrixRuns.map((run) => run.fps_p95));
-    const sliceP95 = median(sliceRuns.map((run) => run.fps_p95));
-    const matrixP50 = median(matrixRuns.map((run) => run.fps_p50));
-    const sliceP50 = median(sliceRuns.map((run) => run.fps_p50));
-    const matrixP99 = median(matrixRuns.map((run) => run.frame_time_p99_ms));
-    const sliceP99 = median(sliceRuns.map((run) => run.frame_time_p99_ms));
-    const deltaP95 = matrixP95 - sliceP95;
-    const deltaP99 = sliceP99 - matrixP99;
-
-    rows.push({
-      model: String(data.model ?? basename(entry.path)).replace(/\.vox$/, ""),
-      source: entry.label,
-      runs: Math.min(matrixRuns.length, sliceRuns.length),
-      winner: winnerFor(deltaP95, deltaP99),
-      matrixP50,
-      sliceP50,
-      matrixP95,
-      sliceP95,
-      matrixP99,
-      sliceP99,
-      deltaP95,
-      deltaP99,
-      matrix4Plus: median(matrixRuns.map(cadence4Plus)),
-      slice4Plus: median(sliceRuns.map(cadence4Plus)),
-      activeLeaves: slice.dom?.leaves ?? null,
-      matrixNodes: median(matrixRuns.map((run) => run.performanceMetrics?.Nodes)),
-      sliceNodes: median(sliceRuns.map((run) => run.performanceMetrics?.Nodes)),
-      planes: brush.depthPlaneCount ?? null,
-      colors: brush.colorCount ?? null,
-      areaK: Number.isFinite(brush.localAreaTotal) ? Math.round(brush.localAreaTotal / 1000) : null,
-      fill: brush.localPlaneFillRatio ?? null,
-      screenFill: brush.screenFillRatio ?? null,
-      dimensions: [meta.rows, meta.cols, meta.depth].every(Number.isFinite)
-        ? `${meta.rows}x${meta.cols}x${meta.depth}`
-        : "",
-    });
-  }
-  return rows.sort((a, b) => a.model.localeCompare(b.model));
-}
-
-const rows = await loadRows();
-const groups = new Map();
-for (const row of rows) {
-  const list = groups.get(row.winner) ?? [];
-  list.push(row);
-  groups.set(row.winner, list);
-}
-
-console.log(`# Voxel Cadence Corpus\n`);
-console.log(`Models: ${rows.length}\n`);
-for (const key of ["matrix", "slice", "matrix-p99", "slice-p99", "flat"]) {
-  const list = groups.get(key) ?? [];
-  console.log(`- ${key}: ${list.length}${list.length ? ` (${list.map((row) => row.model).join(", ")})` : ""}`);
-}
-
-console.log("\n## Strong Winners\n");
-console.log("| Model | Winner | Source | Runs | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 | Matrix 4x+ | Slice 4x+ | Leaves | Nodes M/S | Planes | Colors | AreaK | Fill | Screen | Dims |");
-console.log("| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: | --- |");
-for (const row of rows
-  .filter((candidate) => candidate.winner === "matrix" || candidate.winner === "slice")
-  .sort((a, b) => Math.abs(b.deltaP95) - Math.abs(a.deltaP95))) {
-  console.log([
-    `| ${row.model}`,
-    row.winner,
-    row.source,
-    row.runs,
-    fmt(row.matrixP95),
-    fmt(row.sliceP95),
-    fmt(row.matrixP99),
-    fmt(row.sliceP99),
-    fmt(row.matrix4Plus),
-    fmt(row.slice4Plus),
-    row.activeLeaves ?? "",
-    `${fmt(row.matrixNodes, 0)}/${fmt(row.sliceNodes, 0)}`,
-    row.planes ?? "",
-    row.colors ?? "",
-    row.areaK ?? "",
-    fmt(row.fill, 3),
-    fmt(row.screenFill, 3),
-    `${row.dimensions} |`,
-  ].join(" | "));
-}
-
-console.log("\n## P50/P99 Splits Within Flat p95\n");
-console.log("| Model | Source | Runs | Matrix p50 | Slice p50 | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 | Leaves | Screen |");
-console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-for (const row of rows
-  .filter((candidate) =>
-    candidate.winner === "flat" &&
-    (Math.abs(candidate.matrixP50 - candidate.sliceP50) >= 20 || Math.abs(candidate.deltaP99) >= 5)
-  )
-  .sort((a, b) => Math.abs(b.deltaP99) - Math.abs(a.deltaP99))) {
-  console.log([
-    `| ${row.model}`,
-    row.source,
-    row.runs,
-    fmt(row.matrixP50),
-    fmt(row.sliceP50),
-    fmt(row.matrixP95),
-    fmt(row.sliceP95),
-    fmt(row.matrixP99),
-    fmt(row.sliceP99),
-    row.activeLeaves ?? "",
-    `${fmt(row.screenFill, 3)} |`,
-  ].join(" | "));
-}
diff --git a/bench/voxel-depth-quantization-error.mjs b/bench/voxel-depth-quantization-error.mjs
deleted file mode 100644
index 0e954373..00000000
--- a/bench/voxel-depth-quantization-error.mjs
+++ /dev/null
@@ -1,290 +0,0 @@
-#!/usr/bin/env node
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { basename, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const galleryVoxDir = resolve(repoRoot, "website/public/gallery/vox");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const DEFAULT_MODELS = [
-  "AncientCrashSite.vox",
-  "desert2.vox",
-  "Treasure.vox",
-  "obj_house3.vox",
-  "scene_mechanic2.vox",
-  "scene_house.vox",
-  "scene_sidewalk.vox",
-];
-
-const args = parseArgs(process.argv.slice(2));
-const models = args.models.length ? args.models : DEFAULT_MODELS;
-const bucketCounts = args.buckets.length ? args.buckets : [2, 4, 8, 12, 16];
-const rotation = {
-  rotX: Number(args.rotX ?? 65),
-  rotY: Number(args.rotY ?? 45),
-};
-const targetSize = Number(args.targetSize ?? 70);
-const outPath = args.out ?? resolve(resultDir, "a150-depth-quantization-error.md");
-const jsonPath = args.json ?? resolve(resultDir, "a150-depth-quantization-error.json");
-
-function parseArgs(argv) {
-  const parsed = {
-    buckets: [],
-    models: [],
-  };
-  for (const arg of argv) {
-    if (arg.startsWith("--buckets=")) {
-      parsed.buckets = arg.slice("--buckets=".length).split(",").map(Number).filter(Number.isFinite);
-    } else if (arg.startsWith("--models=")) {
-      parsed.models = arg.slice("--models=".length).split(",").filter(Boolean);
-    } else if (arg.startsWith("--rotX=")) {
-      parsed.rotX = arg.slice("--rotX=".length);
-    } else if (arg.startsWith("--rotY=")) {
-      parsed.rotY = arg.slice("--rotY=".length);
-    } else if (arg.startsWith("--targetSize=")) {
-      parsed.targetSize = arg.slice("--targetSize=".length);
-    } else if (arg.startsWith("--out=")) {
-      parsed.out = resolve(arg.slice("--out=".length));
-    } else if (arg.startsWith("--json=")) {
-      parsed.json = resolve(arg.slice("--json=".length));
-    } else if (!arg.startsWith("--")) {
-      parsed.models.push(arg);
-    }
-  }
-  return parsed;
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function polygonItem(polygon, sourceIndex) {
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const base = { face, sourceIndex };
-  const eps = 1e-6;
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function project(point) {
-  const [x, y] = rotateVec3(point, rotation.rotX, 0, rotation.rotY);
-  return { x, y };
-}
-
-function quantile(values, q) {
-  const sorted = [...values].sort((a, b) => a - b);
-  if (sorted.length === 0) return 0;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function quantizedZ(item, axisStats, bucketCount) {
-  if (bucketCount <= 1) return axisStats.min;
-  const span = axisStats.max - axisStats.min;
-  if (Math.abs(span) <= 1e-9) return axisStats.min;
-  const unit = span / bucketCount;
-  const bucket = Math.max(0, Math.min(bucketCount - 1, Math.floor((item.z - axisStats.min) / unit)));
-  return axisStats.min + (bucket + 0.5) * unit;
-}
-
-function errorForBuckets(items, bucketCount) {
-  const statsByAxis = new Map();
-  for (const axis of ["x", "y", "z"]) {
-    const axisItems = items.filter((item) => item.axis === axis);
-    statsByAxis.set(axis, {
-      min: Math.min(...axisItems.map((item) => item.z)),
-      max: Math.max(...axisItems.map((item) => item.z)),
-    });
-  }
-
-  const errors = items.map((item) => {
-    const exact = project(itemCenter(item));
-    const q = project(itemCenter({ ...item, z: quantizedZ(item, statsByAxis.get(item.axis), bucketCount) }));
-    return Math.hypot(exact.x - q.x, exact.y - q.y);
-  });
-
-  return {
-    bucketCount,
-    wrappers: bucketCount * 3,
-    p50: quantile(errors, 0.5),
-    p95: quantile(errors, 0.95),
-    max: Math.max(...errors),
-  };
-}
-
-async function analyzeModel(model) {
-  const file = model.endsWith(".vox") ? model : `${model}.vox`;
-  const path = resolve(galleryVoxDir, file);
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize, gridShift: 0 },
-  );
-  const items = parsed.polygons
-    .map((polygon, sourceIndex) => polygonItem(polygon, sourceIndex))
-    .filter(Boolean)
-    .filter((item) => item.width > 0 && item.height > 0);
-  const visibleFaces = new Set(
-    Object.entries(FACE_NORMALS)
-      .filter(([, normal]) => normalFacesCamera(normal, rotation))
-      .map(([face]) => face),
-  );
-  const active = items.filter((item) => visibleFaces.has(item.face));
-  const exactPlanes = new Set(active.map((item) => `${item.axis}:${item.z.toFixed(3)}`));
-  return {
-    model: file,
-    active: active.length,
-    exactPlanes: exactPlanes.size,
-    rows: bucketCounts.map((bucketCount) => errorForBuckets(active, bucketCount)),
-  };
-}
-
-function fmt(value) {
-  return value.toFixed(1);
-}
-
-const results = [];
-for (const model of models) {
-  results.push(await analyzeModel(model));
-}
-
-const lines = [
-  "# Depth Quantization Error",
-  "",
-  `Rotation: rotX=${rotation.rotX}, rotY=${rotation.rotY}`,
-  `Target size: ${targetSize}`,
-  "",
-  "| Model | Active | Exact planes | Buckets/axis | Total wrappers | p50 err | p95 err | max err |",
-  "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
-];
-
-for (const result of results) {
-  for (const row of result.rows) {
-    lines.push([
-      `| ${basename(result.model, ".vox")}`,
-      result.active,
-      result.exactPlanes,
-      row.bucketCount,
-      row.wrappers,
-      fmt(row.p50),
-      fmt(row.p95),
-      `${fmt(row.max)} |`,
-    ].join(" | "));
-  }
-}
-
-await mkdir(resultDir, { recursive: true });
-await writeFile(outPath, `${lines.join("\n")}\n`);
-await writeFile(jsonPath, `${JSON.stringify({ rotation, targetSize, results }, null, 2)}\n`);
-console.log(lines.join("\n"));
-console.log(`\nWrote ${outPath}`);
-console.log(`Wrote ${jsonPath}`);
diff --git a/bench/voxel-dom-order-probe.mjs b/bench/voxel-dom-order-probe.mjs
deleted file mode 100644
index d7d24732..00000000
--- a/bench/voxel-dom-order-probe.mjs
+++ /dev/null
@@ -1,996 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import { chromium } from "playwright";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
-import { PRESETS } from "./perf-shared.mjs";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const galleryDir = resolve(repoRoot, "website/public");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const args = new Map(process.argv.slice(2).map((arg) => {
-  const [key, ...rest] = arg.replace(/^--/, "").split("=");
-  return [key, rest.length ? rest.join("=") : "true"];
-}));
-
-const MESHES = (args.get("meshes") ?? "obj-house3,ancient-crash-site,scene-mechanic2")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const STRATEGIES = (args.get("strategies") ?? "tile4-source,tile4-depth-front,tile4-depth-back,tile4-face,tile4-top-first,tile4-top-last")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const PAINTS = (args.get("paints") ?? "current-color")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const LEAF_TRANSFORM_STYLES = (args.get("leaf-transform-styles") ?? "preserve-3d")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const LEAF_BACKFACES = (args.get("leaf-backfaces") ?? "visible")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const TRANSFORM_SHAPES = (args.get("transform-shapes") ?? "matrix-scale")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const LEAF_CONTAINS = (args.get("leaf-contains") ?? "none")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const OCCLUSIONS = (args.get("occlusions") ?? "none")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const OCCLUSION_GRID_W = Number(args.get("occlusion-grid-w") ?? 240);
-const OCCLUSION_GRID_H = Number(args.get("occlusion-grid-h") ?? 160);
-const OCCLUSION_MIN_CELLS = Number(args.get("occlusion-min-cells") ?? 1);
-const OCCLUSION_INTERIOR_RADIUS = Number(args.get("occlusion-interior-radius") ?? 0);
-const OCCLUSION_DEPTH_BUFFER = args.has("occlusion-depth-buffer");
-const OCCLUSION_DEPTH_EPS = Number(args.get("occlusion-depth-eps") ?? 0.01);
-const OCCLUSION_PRESERVE_ORDER = args.has("occlusion-preserve-order");
-const OCCLUSION_INTERVAL_SAMPLES = Math.max(1, Math.floor(Number(args.get("occlusion-interval-samples") ?? 1)));
-const WARMUP_MS = Number(args.get("warmup") ?? 1000);
-const SAMPLE_MS = Number(args.get("sample") ?? 5000);
-const RUNS = Number(args.get("runs") ?? 1);
-const HEADED = args.has("headed");
-const BROWSER_EXECUTABLE = args.get("browser-executable") ?? args.get("browser") ?? "";
-const SOFTWARE_BACKEND = args.has("software-backend");
-const CHROMIUM_ARGS = chromiumArgsWithGpuDefault((args.get("chromium-args") ?? "")
-  .split(/\s+/)
-  .map((value) => value.trim())
-  .filter(Boolean), { softwareBackend: SOFTWARE_BACKEND });
-const LABEL = args.get("label") ?? "";
-const VISUAL_DIFF = args.has("visual-diff");
-const VISUAL_TOLERANCE = Number(args.get("visual-tolerance") ?? 0.005);
-const VISUAL_OFFSETS = (args.get("visual-offsets") ?? "0,45,90,135,180,225,270,315")
-  .split(",")
-  .map((value) => Number(value.trim()))
-  .filter(Number.isFinite);
-const VISUAL_SAVE = args.has("visual-save");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_INDEX = Object.fromEntries(FACE_ORDER.map((face, index) => [face, index]));
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (!sorted.length) return 0;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function summarizeDts(dts) {
-  const sorted = dts.filter((value) => value > 0 && value < 2000).sort((a, b) => a - b);
-  const p50 = quantile(sorted, 0.5);
-  const p95 = quantile(sorted, 0.95);
-  const p99 = quantile(sorted, 0.99);
-  return {
-    frames: sorted.length,
-    fps_p50: 1000 / p50,
-    fps_p95: 1000 / p95,
-    frame_time_p99_ms: p99,
-    buckets: {
-      x1: sorted.filter((value) => value < 10).length,
-      x2: sorted.filter((value) => value >= 10 && value < 18).length,
-      x3: sorted.filter((value) => value >= 18 && value < 26).length,
-      x4_plus: sorted.filter((value) => value >= 26).length,
-    },
-  };
-}
-
-function visibleFaceSignature(rotation) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], rotation)) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function itemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const eps = 1e-6;
-  const base = { face, sourceIndex, color: polygon.color || "#cccccc" };
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function projectedCenter(item, rotation) {
-  const [x, y, z] = rotateVec3(itemCenter(item), rotation.rotX, 0, rotation.rotY);
-  return { x, y, z };
-}
-
-function directMatrix(item, transformShape = "matrix-scale") {
-  const { axis, left, top, width, height, z } = item;
-  const sx = transformShape === "css-size-unit-matrix" ? 1 : width;
-  const sy = transformShape === "css-size-unit-matrix" ? 1 : height;
-  const values = axis === "x"
-    ? [
-        sx, 0, 0, 0,
-        0, 0, sy, 0,
-        0, -1, 0, 0,
-        left, -z, top, 1,
-      ]
-    : axis === "y"
-      ? [
-          0, 0, sx, 0,
-          0, sy, 0, 0,
-          -1, 0, 0, 0,
-          -z, top, left, 1,
-        ]
-      : [
-          sx, 0, 0, 0,
-          0, sy, 0, 0,
-          0, 0, 1, 0,
-          left, top, z, 1,
-        ];
-  return `matrix3d(${values.map((value) => Number(value.toFixed(6))).join(",")})`;
-}
-
-function sceneCenter(items) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const item of items) {
-    for (const [x, y, z] of itemCorners(item)) {
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      minZ = Math.min(minZ, z);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      maxZ = Math.max(maxZ, z);
-    }
-  }
-  return {
-    x: (minX + maxX) / 2,
-    y: (minY + maxY) / 2,
-    z: (minZ + maxZ) / 2,
-  };
-}
-
-function orderedItems(items, signature, rotation, strategy) {
-  const faces = new Set(signature.split("|").filter(Boolean));
-  const entries = items
-    .filter((item) => faces.has(item.face))
-    .map((item) => ({ item, ...projectedCenter(item, rotation) }));
-  if (!entries.length) return [];
-
-  const minX = Math.min(...entries.map((entry) => entry.x));
-  const maxX = Math.max(...entries.map((entry) => entry.x));
-  const minY = Math.min(...entries.map((entry) => entry.y));
-  const maxY = Math.max(...entries.map((entry) => entry.y));
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(3, Math.max(0, Math.floor(((entry.x - minX) / spanX) * 4)));
-    const ty = Math.min(3, Math.max(0, Math.floor(((entry.y - minY) / spanY) * 4)));
-    const key = `${tx}:${ty}`;
-    const tile = tiles.get(key) ?? { tx, ty, sourceIndex: entry.item.sourceIndex, entries: [] };
-    tile.entries.push(entry);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-    tiles.set(key, tile);
-  }
-
-  const tileEntries = [...tiles.values()].sort((a, b) =>
-    (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex
-  );
-
-  return tileEntries.flatMap((tile) => {
-    const local = [...tile.entries];
-    if (strategy === "tile4-depth-front") {
-      local.sort((a, b) => b.z - a.z || a.item.sourceIndex - b.item.sourceIndex);
-    } else if (strategy === "tile4-depth-back") {
-      local.sort((a, b) => a.z - b.z || a.item.sourceIndex - b.item.sourceIndex);
-    } else if (strategy === "tile4-face") {
-      local.sort((a, b) => FACE_INDEX[a.item.face] - FACE_INDEX[b.item.face] || a.item.sourceIndex - b.item.sourceIndex);
-    } else if (strategy === "tile4-top-first") {
-      local.sort((a, b) =>
-        Number(a.item.face !== "t") - Number(b.item.face !== "t") ||
-        a.item.sourceIndex - b.item.sourceIndex
-      );
-    } else if (strategy === "tile4-top-last") {
-      local.sort((a, b) =>
-        Number(a.item.face === "t") - Number(b.item.face === "t") ||
-        a.item.sourceIndex - b.item.sourceIndex
-      );
-    }
-    return local.map((entry) => entry.item);
-  });
-}
-
-async function loadItems(meshId) {
-  const preset = PRESETS[meshId];
-  if (!preset) throw new Error(`Unknown preset ${meshId}`);
-  const path = resolve(galleryDir, preset.url.replace(/^\//, ""));
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize: preset.options?.targetSize ?? 70, gridShift: 0 },
-  );
-  const items = parsed.polygons
-    .map((polygon, sourceIndex) => itemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-  if (items.length !== parsed.polygons.length) throw new Error(`${meshId} has non-exact voxel polygons`);
-  return { preset, items };
-}
-
-function buildHtml({ items, preset, strategy, paint, leafTransformStyle, leafBackface, transformShape, leafContain, occlusion, staticRotY = null }) {
-  const center = sceneCenter(items);
-  const itemData = JSON.stringify(items.map((item) => ({
-    ...item,
-    transform: directMatrix(item, transformShape),
-    cssWidth: transformShape === "css-size-unit-matrix" ? item.width : 1,
-    cssHeight: transformShape === "css-size-unit-matrix" ? item.height : 1,
-  })));
-  const backgroundRule = paint === "current-color" ? "background:currentColor;" : "";
-  const containRule = leafContain === "none" ? "" : `contain:${leafContain};`;
-  return `<!doctype html><meta charset="utf-8"><style>
-body{margin:0;background:#111;overflow:hidden}
-#host{position:relative;width:1280px;height:800px;transform-style:preserve-3d}
-.scene{position:absolute;left:50%;top:50%;width:0;height:0;transform-style:preserve-3d;perspective:8000px;will-change:transform}
-.mesh{position:absolute;left:0;top:0;width:0;height:0;transform-style:preserve-3d;transform-origin:var(--origin)}
-b{position:absolute;display:block;top:0;left:0;width:1px;height:1px;${backgroundRule}transform-origin:0 0;transform-style:${leafTransformStyle};${containRule}margin:0;padding:0;font:inherit;font-weight:normal;font-style:normal;line-height:0;text-decoration:none;backface-visibility:${leafBackface};background-repeat:no-repeat;pointer-events:none}
-</style><div id="host"><div class="scene"><div class="mesh"></div></div></div><script>
-const items=${itemData};
-const strategy=${JSON.stringify(strategy)};
-const paint=${JSON.stringify(paint)};
-const transformShape=${JSON.stringify(transformShape)};
-const occlusion=${JSON.stringify(occlusion)};
-const occlusionGridW=${OCCLUSION_GRID_W};
-const occlusionGridH=${OCCLUSION_GRID_H};
-const occlusionMinCells=${OCCLUSION_MIN_CELLS};
-const occlusionInteriorRadius=${OCCLUSION_INTERIOR_RADIUS};
-const occlusionDepthBuffer=${JSON.stringify(OCCLUSION_DEPTH_BUFFER)};
-const occlusionDepthEps=${OCCLUSION_DEPTH_EPS};
-const occlusionPreserveOrder=${JSON.stringify(OCCLUSION_PRESERVE_ORDER)};
-const occlusionIntervalSamples=${OCCLUSION_INTERVAL_SAMPLES};
-const staticRotY=${staticRotY == null ? "null" : JSON.stringify(staticRotY)};
-const faceNormals=${JSON.stringify(FACE_NORMALS)};
-const faceOrder=${JSON.stringify(FACE_ORDER)};
-const preset=${JSON.stringify({ rotX: preset.rotX, rotY: preset.rotY, zoom: preset.zoom })};
-const center=${JSON.stringify(center)};
-const els=new Map();
-const samples=[];
-const frames=[];
-let frame=0;
-let last=performance.now();
-let lastSignature="";
-const scene=document.querySelector(".scene");
-const mesh=document.querySelector(".mesh");
-const intervalCullCache=new Map();
-function normalFacesCamera(normal, rotX, rotY){
-  const rz=rotY*Math.PI/180;
-  const rx=rotX*Math.PI/180;
-  const cosZ=Math.cos(rz), sinZ=Math.sin(rz);
-  const cosX=Math.cos(rx), sinX=Math.sin(rx);
-  const x1=normal[0]*cosZ-normal[1]*sinZ;
-  const y1=normal[0]*sinZ+normal[1]*cosZ;
-  const z2=y1*sinX+normal[2]*cosX;
-  return z2>0.001;
-}
-function signature(rotX, rotY){
-  const faces=[];
-  for(const face of faceOrder) if(normalFacesCamera(faceNormals[face],rotX,rotY)) faces.push(face);
-  return faces.join("|");
-}
-function rotatePoint(point, rotX, rotY){
-  const rz=rotY*Math.PI/180;
-  const rx=rotX*Math.PI/180;
-  const cosZ=Math.cos(rz), sinZ=Math.sin(rz);
-  const cosX=Math.cos(rx), sinX=Math.sin(rx);
-  const x1=point[0]*cosZ-point[1]*sinZ;
-  const y1=point[0]*sinZ+point[1]*cosZ;
-  return {x:x1,y:y1*cosX-point[2]*sinX,z:y1*sinX+point[2]*cosX};
-}
-function itemCenter(item){
-  if(item.axis==="x") return [item.left+item.width/2,-item.z,item.top+item.height/2];
-  if(item.axis==="y") return [-item.z,item.top+item.height/2,item.left+item.width/2];
-  return [item.left+item.width/2,item.top+item.height/2,item.z];
-}
-function itemCorners(item){
-  if(item.axis==="x") return [[item.left,-item.z,item.top],[item.left+item.width,-item.z,item.top],[item.left+item.width,-item.z,item.top+item.height],[item.left,-item.z,item.top+item.height]];
-  if(item.axis==="y") return [[-item.z,item.top,item.left],[-item.z,item.top,item.left+item.width],[-item.z,item.top+item.height,item.left+item.width],[-item.z,item.top+item.height,item.left]];
-  return [[item.left,item.top,item.z],[item.left+item.width,item.top,item.z],[item.left+item.width,item.top+item.height,item.z],[item.left,item.top+item.height,item.z]];
-}
-function pointInConvex(point, poly){
-  let sign=0;
-  for(let i=0;i<poly.length;i++){
-    const a=poly[i], b=poly[(i+1)%poly.length];
-    const cross=(b.x-a.x)*(point.y-a.y)-(b.y-a.y)*(point.x-a.x);
-    const next=Math.sign(cross);
-    if(next===0) continue;
-    if(sign===0) sign=next;
-    else if(sign!==next) return false;
-  }
-  return true;
-}
-function occlusionCullSingle(entries, rotX, rotY){
-  if(occlusion!=="grid"||entries.length===0) return entries;
-  function depthAt(points,x,y){
-    const p0=points[0], p1=points[1], p2=points[2];
-    const ux=p1.x-p0.x, uy=p1.y-p0.y, uz=p1.z-p0.z;
-    const vx=p2.x-p0.x, vy=p2.y-p0.y, vz=p2.z-p0.z;
-    const nx=uy*vz-uz*vy;
-    const ny=uz*vx-ux*vz;
-    const nz=ux*vy-uy*vx;
-    if(Math.abs(nz)<1e-9) return points.reduce((sum,point)=>sum+point.z,0)/points.length;
-    return p0.z-(nx*(x-p0.x)+ny*(y-p0.y))/nz;
-  }
-  const projected=entries.map((entry)=>{
-    const points=itemCorners(entry.item).map((point)=>rotatePoint(point,rotX,rotY));
-    return {
-      ...entry,
-      points,
-      depth:points.reduce((sum,point)=>sum+point.z,0)/points.length,
-      minX:Math.min(...points.map((point)=>point.x)),
-      maxX:Math.max(...points.map((point)=>point.x)),
-      minY:Math.min(...points.map((point)=>point.y)),
-      maxY:Math.max(...points.map((point)=>point.y)),
-    };
-  });
-  const minX=Math.min(...projected.map((entry)=>entry.minX));
-  const maxX=Math.max(...projected.map((entry)=>entry.maxX));
-  const minY=Math.min(...projected.map((entry)=>entry.minY));
-  const maxY=Math.max(...projected.map((entry)=>entry.maxY));
-  const spanX=Math.max(1e-6,maxX-minX), spanY=Math.max(1e-6,maxY-minY);
-  const occupied=new Uint8Array(occlusionGridW*occlusionGridH);
-  const depths=new Float64Array(occlusionGridW*occlusionGridH);
-  depths.fill(-Infinity);
-  const kept=[];
-  const keptSourceIndexes=new Set();
-  for(const entry of projected.sort((a,b)=>b.depth-a.depth||a.item.sourceIndex-b.item.sourceIndex)){
-    const gx0=Math.max(0,Math.floor(((entry.minX-minX)/spanX)*occlusionGridW));
-    const gx1=Math.min(occlusionGridW-1,Math.ceil(((entry.maxX-minX)/spanX)*occlusionGridW));
-    const gy0=Math.max(0,Math.floor(((entry.minY-minY)/spanY)*occlusionGridH));
-    const gy1=Math.min(occlusionGridH-1,Math.ceil(((entry.maxY-minY)/spanY)*occlusionGridH));
-    let hasPixel=false;
-    const cells=[];
-    for(let gy=gy0;gy<=gy1;gy++){
-      const y=minY+((gy+0.5)/occlusionGridH)*spanY;
-      for(let gx=gx0;gx<=gx1;gx++){
-        const x=minX+((gx+0.5)/occlusionGridW)*spanX;
-        if(!pointInConvex({x,y},entry.points)) continue;
-        const index=gy*occlusionGridW+gx;
-        const z=depthAt(entry.points,x,y);
-        cells.push([index,z]);
-        const covered=occupied[index]&&(!occlusionDepthBuffer||depths[index]>z+occlusionDepthEps);
-        if(!covered) hasPixel=true;
-      }
-    }
-    let hasOpenNeighbor=false;
-    if(!hasPixel&&occlusionInteriorRadius>0){
-      for(const [index] of cells){
-        const cx=index%occlusionGridW;
-        const cy=Math.floor(index/occlusionGridW);
-        for(let dy=-occlusionInteriorRadius;dy<=occlusionInteriorRadius&&!hasOpenNeighbor;dy++){
-          for(let dx=-occlusionInteriorRadius;dx<=occlusionInteriorRadius;dx++){
-            const nx=cx+dx, ny=cy+dy;
-            if(nx<0||nx>=occlusionGridW||ny<0||ny>=occlusionGridH||!occupied[ny*occlusionGridW+nx]){
-              hasOpenNeighbor=true;
-              break;
-            }
-          }
-        }
-        if(hasOpenNeighbor) break;
-      }
-    }
-    if(cells.length===0||cells.length<occlusionMinCells||hasPixel||hasOpenNeighbor){
-      kept.push(entry);
-      keptSourceIndexes.add(entry.item.sourceIndex);
-      for(const [index,z] of cells){
-        occupied[index]=1;
-        if(z>depths[index]) depths[index]=z;
-      }
-    }
-  }
-  return occlusionPreserveOrder
-    ? entries.filter((entry)=>keptSourceIndexes.has(entry.item.sourceIndex))
-    : kept;
-}
-function occlusionIntervalAngles(rotX, rotY, sig){
-  if(occlusionIntervalSamples<=1) return [rotY];
-  const step=0.5;
-  let start=rotY;
-  let end=rotY;
-  for(let i=0;i<720&&signature(rotX,start-step)===sig;i++) start-=step;
-  for(let i=0;i<720&&signature(rotX,end+step)===sig;i++) end+=step;
-  if(occlusionIntervalSamples===1||Math.abs(end-start)<1e-6) return [rotY];
-  const angles=[rotY];
-  for(let i=0;i<occlusionIntervalSamples;i++){
-    angles.push(start+((end-start)*i)/(occlusionIntervalSamples-1));
-  }
-  return [...new Set(angles.map((angle)=>Math.round(angle*1000)/1000))];
-}
-function occlusionCull(entries, rotX, rotY, sig){
-  if(occlusion!=="grid"||entries.length===0||occlusionIntervalSamples<=1){
-    return occlusionCullSingle(entries,rotX,rotY);
-  }
-  let keep=intervalCullCache.get(sig);
-  if(!keep){
-    keep=new Set();
-    for(const angle of occlusionIntervalAngles(rotX,rotY,sig)){
-      const sampleEntries=entries.map((entry)=>{
-        const projected=rotatePoint(itemCenter(entry.item),rotX,angle);
-        return {item:entry.item,...projected};
-      });
-      for(const entry of occlusionCullSingle(sampleEntries,rotX,angle)){
-        keep.add(entry.item.sourceIndex);
-      }
-    }
-    intervalCullCache.set(sig,keep);
-  }
-  return entries.filter((entry)=>keep.has(entry.item.sourceIndex));
-}
-function order(rotX, rotY, sig){
-  const faces=new Set(sig.split("|").filter(Boolean));
-  let entries=items.filter((item)=>faces.has(item.face)).map((item)=>{
-    const projected=rotatePoint(itemCenter(item),rotX,rotY);
-    return {item,...projected};
-  });
-  entries=occlusionCull(entries,rotX,rotY,sig);
-  if(!entries.length) return [];
-  let minX=Infinity,maxX=-Infinity,minY=Infinity,maxY=-Infinity;
-  for(const entry of entries){minX=Math.min(minX,entry.x);maxX=Math.max(maxX,entry.x);minY=Math.min(minY,entry.y);maxY=Math.max(maxY,entry.y);}
-  const spanX=Math.max(1e-6,maxX-minX), spanY=Math.max(1e-6,maxY-minY);
-  const tiles=new Map();
-  for(const entry of entries){
-    const tx=Math.min(3,Math.max(0,Math.floor(((entry.x-minX)/spanX)*4)));
-    const ty=Math.min(3,Math.max(0,Math.floor(((entry.y-minY)/spanY)*4)));
-    const key=tx+":"+ty;
-    let tile=tiles.get(key);
-    if(!tile){tile={tx,ty,sourceIndex:entry.item.sourceIndex,entries:[]};tiles.set(key,tile);}
-    tile.entries.push(entry);
-    tile.sourceIndex=Math.min(tile.sourceIndex,entry.item.sourceIndex);
-  }
-  const faceIndex=Object.fromEntries(faceOrder.map((face,index)=>[face,index]));
-  function projectedBounds(item){
-    const points=itemCorners(item).map((point)=>rotatePoint(point,rotX,rotY));
-    const minX=Math.min(...points.map((point)=>point.x));
-    const maxX=Math.max(...points.map((point)=>point.x));
-    const minY=Math.min(...points.map((point)=>point.y));
-    const maxY=Math.max(...points.map((point)=>point.y));
-    return {minX,maxX,minY,maxY,area:Math.max(0,maxX-minX)*Math.max(0,maxY-minY)};
-  }
-  function tileFill(entries){
-    if(!entries.length) return 0;
-    const rects=entries.map((entry)=>projectedBounds(entry.item));
-    const minX=Math.min(...rects.map((rect)=>rect.minX));
-    const maxX=Math.max(...rects.map((rect)=>rect.maxX));
-    const minY=Math.min(...rects.map((rect)=>rect.minY));
-    const maxY=Math.max(...rects.map((rect)=>rect.maxY));
-    const area=Math.max(1e-6,(maxX-minX)*(maxY-minY));
-    return rects.reduce((sum,rect)=>sum+rect.area,0)/area;
-  }
-  return [...tiles.values()].sort((a,b)=>a.ty-b.ty||a.tx-b.tx||a.sourceIndex-b.sourceIndex).flatMap((tile)=>{
-    const local=[...tile.entries];
-    const dense4=tileFill(local)>=4;
-    const dense8=tileFill(local)>=8;
-    const useDense4=strategy.startsWith("tile4-dense4-")&&dense4;
-    const useDense8=strategy.startsWith("tile4-dense8-")&&dense8;
-    const effective=(useDense4||useDense8)?strategy.replace(/^tile4-dense[48]-/,"tile4-"):strategy;
-    if(effective==="tile4-depth-front") local.sort((a,b)=>b.z-a.z||a.item.sourceIndex-b.item.sourceIndex);
-    else if(effective==="tile4-depth-back") local.sort((a,b)=>a.z-b.z||a.item.sourceIndex-b.item.sourceIndex);
-    else if(effective==="tile4-face") local.sort((a,b)=>faceIndex[a.item.face]-faceIndex[b.item.face]||a.item.sourceIndex-b.item.sourceIndex);
-    else if(effective==="tile4-top-first") local.sort((a,b)=>Number(a.item.face!=="t")-Number(b.item.face!=="t")||a.item.sourceIndex-b.item.sourceIndex);
-    else if(effective==="tile4-top-last") local.sort((a,b)=>Number(a.item.face==="t")-Number(b.item.face==="t")||a.item.sourceIndex-b.item.sourceIndex);
-    return local.map((entry)=>entry.item);
-  });
-}
-function remount(ordered){
-  const fragment=document.createDocumentFragment();
-  for(const item of ordered){
-    let el=els.get(item.sourceIndex);
-    if(!el){
-      el=document.createElement("b");
-      if(paint==="inline-background") el.style.backgroundColor=item.color;
-      else if(paint==="inline-background-shorthand") el.style.background=item.color;
-      else el.style.color=item.color;
-      if(transformShape==="css-size-unit-matrix"){
-        el.style.width=item.cssWidth+"px";
-        el.style.height=item.cssHeight+"px";
-      }
-      el.style.transform=item.transform;
-      els.set(item.sourceIndex,el);
-    }
-    fragment.appendChild(el);
-  }
-  mesh.replaceChildren(fragment);
-}
-function tick(now){
-  samples.push(now-last);
-  last=now;
-  frame++;
-  const rotY=(preset.rotY+frame*0.5)%360;
-  const rotX=preset.rotX;
-  scene.style.transform="scale("+preset.zoom+") rotateX("+rotX+"deg) rotate("+rotY+"deg) translate3d("+(-center.x)+"px,"+(-center.y)+"px,"+(-center.z)+"px)";
-  const sig=signature(rotX,rotY);
-  if(sig!==lastSignature){
-    remount(order(rotX,rotY,sig));
-    lastSignature=sig;
-  }
-  frames.push({index:frame,rotY,signature:sig,dt:samples[samples.length-1],leaves:mesh.childElementCount});
-  requestAnimationFrame(tick);
-}
-window.__probe={samples,frames,ready:true};
-if(staticRotY===null){
-  requestAnimationFrame(tick);
-}else{
-  const rotX=preset.rotX;
-  const rotY=staticRotY;
-  scene.style.transform="scale("+preset.zoom+") rotateX("+rotX+"deg) rotate("+rotY+"deg) translate3d("+(-center.x)+"px,"+(-center.y)+"px,"+(-center.z)+"px)";
-  const sig=signature(rotX,rotY);
-  remount(order(rotX,rotY,sig));
-  lastSignature=sig;
-  frames.push({index:0,rotY,signature:sig,dt:0,leaves:mesh.childElementCount});
-}
-</script>`;
-}
-
-function segmentFrames(frames) {
-  const segments = [];
-  let current = null;
-  for (const frame of frames) {
-    if (!current || current.signature !== frame.signature) {
-      current = { signature: frame.signature, startRotY: frame.rotY, endRotY: frame.rotY, frames: [] };
-      segments.push(current);
-    }
-    current.frames.push(frame);
-    current.endRotY = frame.rotY;
-  }
-  return segments.map((segment) => ({
-    signature: segment.signature,
-    startRotY: segment.startRotY,
-    endRotY: segment.endRotY,
-    leaves: median(segment.frames.map((frame) => frame.leaves)),
-    ...summarizeDts(segment.frames.map((frame) => frame.dt)),
-  }));
-}
-
-async function runCase(browser, meshId, strategy, paint, leafTransformStyle, leafBackface, transformShape, leafContain, occlusion, repeat) {
-  const { preset, items } = await loadItems(meshId);
-  const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
-  await page.setContent(buildHtml({ items, preset, strategy, paint, leafTransformStyle, leafBackface, transformShape, leafContain, occlusion }), { waitUntil: "load" });
-  await page.waitForFunction(() => window.__probe?.ready === true, null, { timeout: 30000 });
-  await page.waitForTimeout(WARMUP_MS);
-  const start = await page.evaluate(() => window.__probe.samples.length);
-  await page.waitForTimeout(SAMPLE_MS);
-  const result = await page.evaluate((from) => ({
-    samples: window.__probe.samples.slice(from),
-    frames: window.__probe.frames.slice(from),
-  }), start);
-  await page.close();
-  return {
-    mesh: meshId,
-    strategy,
-    paint,
-    leafTransformStyle,
-    leafBackface,
-    transformShape,
-    leafContain,
-    occlusion,
-    repeat,
-    warmup_ms: WARMUP_MS,
-    sample_ms: SAMPLE_MS,
-    leaves_p50: median(result.frames.map((frame) => frame.leaves)),
-    ...summarizeDts(result.samples),
-    segments: segmentFrames(result.frames),
-  };
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function printRows(rows) {
-  console.log("| Mesh | Strategy | Paint | Leaf transform-style | Backface | Transform shape | Contain | Occlusion | Leaves p50 | p50 FPS | p95 FPS | p99 ms | Frames | x1 | x2 | x3 | x4+ |");
-  console.log("| --- | --- | --- | --- | --- | --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-  for (const row of rows) {
-    console.log([
-      `| ${row.mesh}`,
-      row.strategy,
-      row.paint,
-      row.leafTransformStyle,
-      row.leafBackface,
-      row.transformShape,
-      row.leafContain,
-      row.occlusion,
-      fmt(row.leaves_p50, 0),
-      fmt(row.fps_p50),
-      fmt(row.fps_p95),
-      fmt(row.frame_time_p99_ms),
-      row.frames,
-      row.buckets.x1,
-      row.buckets.x2,
-      row.buckets.x3,
-      `${row.buckets.x4_plus} |`,
-    ].join(" | "));
-  }
-}
-
-async function compareScreenshots(page, baseline, candidate) {
-  return await page.evaluate(async ({ baselineB64, candidateB64 }) => {
-    async function loadPng(b64) {
-      const img = new Image();
-      img.src = `data:image/png;base64,${b64}`;
-      await img.decode();
-      const canvas = document.createElement("canvas");
-      canvas.width = img.naturalWidth;
-      canvas.height = img.naturalHeight;
-      const ctx = canvas.getContext("2d");
-      ctx.drawImage(img, 0, 0);
-      return ctx.getImageData(0, 0, canvas.width, canvas.height);
-    }
-    const [a, b] = await Promise.all([loadPng(baselineB64), loadPng(candidateB64)]);
-    if (a.width !== b.width || a.height !== b.height) {
-      return { ok: false, reason: "size", a: [a.width, a.height], b: [b.width, b.height] };
-    }
-    let sum = 0;
-    let maxPixelDelta = 0;
-    let changedPixels = 0;
-    const pixels = a.width * a.height;
-    for (let i = 0; i < a.data.length; i += 4) {
-      const dr = Math.abs(a.data[i] - b.data[i]);
-      const dg = Math.abs(a.data[i + 1] - b.data[i + 1]);
-      const db = Math.abs(a.data[i + 2] - b.data[i + 2]);
-      const pixelDelta = (dr + dg + db) / (3 * 255);
-      sum += dr + dg + db;
-      maxPixelDelta = Math.max(maxPixelDelta, pixelDelta);
-      if (pixelDelta > 8 / 255) changedPixels += 1;
-    }
-    return {
-      ok: true,
-      mean_delta: sum / (pixels * 3 * 255),
-      max_pixel_delta: maxPixelDelta,
-      changed_ratio: changedPixels / pixels,
-    };
-  }, {
-    baselineB64: baseline.toString("base64"),
-    candidateB64: candidate.toString("base64"),
-  });
-}
-
-async function captureStatic(browser, config) {
-  const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
-  try {
-    await page.setContent(buildHtml(config), { waitUntil: "load" });
-    await page.waitForFunction(() => window.__probe?.ready === true, null, { timeout: 30000 });
-    await page.waitForTimeout(150);
-    const meta = await page.evaluate(() => ({
-      leaves: document.querySelector(".mesh")?.childElementCount ?? 0,
-      frame: window.__probe?.frames?.[0] ?? null,
-    }));
-    const screenshot = await page.screenshot({ fullPage: false });
-    return { screenshot, meta };
-  } finally {
-    await page.close();
-  }
-}
-
-async function runVisualDiff(browser) {
-  const rows = [];
-  const screenshotDir = join(resultDir, "occlusion-visual");
-  if (VISUAL_SAVE) await mkdir(screenshotDir, { recursive: true });
-  const comparePage = await browser.newPage({ viewport: { width: 1280, height: 800 } });
-  try {
-    for (const mesh of MESHES) {
-      const { preset, items } = await loadItems(mesh);
-      for (const offset of VISUAL_OFFSETS) {
-        const rotY = (preset.rotY + offset + 360) % 360;
-        const baseConfig = {
-          items,
-          preset,
-          strategy: STRATEGIES[0] ?? "tile4-source",
-          paint: PAINTS[0] ?? "current-color",
-          leafTransformStyle: LEAF_TRANSFORM_STYLES[0] ?? "preserve-3d",
-          leafBackface: LEAF_BACKFACES[0] ?? "visible",
-          transformShape: TRANSFORM_SHAPES[0] ?? "matrix-scale",
-          leafContain: LEAF_CONTAINS[0] ?? "none",
-          occlusion: "none",
-          staticRotY: rotY,
-        };
-        const candidateConfig = { ...baseConfig, occlusion: "grid" };
-        const baseline = await captureStatic(browser, baseConfig);
-        const candidate = await captureStatic(browser, candidateConfig);
-        const cmp = await compareScreenshots(comparePage, baseline.screenshot, candidate.screenshot);
-        const row = {
-          mesh,
-          offset,
-          rotY,
-          baselineLeaves: baseline.meta.leaves,
-          candidateLeaves: candidate.meta.leaves,
-          removedLeaves: baseline.meta.leaves - candidate.meta.leaves,
-          removedRatio: baseline.meta.leaves ? (baseline.meta.leaves - candidate.meta.leaves) / baseline.meta.leaves : 0,
-          ...cmp,
-          pass: Boolean(cmp.ok && cmp.mean_delta <= VISUAL_TOLERANCE),
-        };
-        rows.push(row);
-        if (VISUAL_SAVE) {
-          await writeFile(join(screenshotDir, `${mesh}-${offset}-none.png`), baseline.screenshot);
-          await writeFile(join(screenshotDir, `${mesh}-${offset}-grid.png`), candidate.screenshot);
-        }
-      }
-    }
-  } finally {
-    await comparePage.close();
-  }
-
-  console.log("| Mesh | Offset | Removed | Mean Δ | Changed | Max pixel Δ | Pass |");
-  console.log("| --- | ---: | ---: | ---: | ---: | ---: | --- |");
-  for (const row of rows) {
-    console.log([
-      `| ${row.mesh}`,
-      row.offset,
-      `${row.removedLeaves} (${(row.removedRatio * 100).toFixed(1)}%)`,
-      row.ok ? row.mean_delta.toFixed(5) : row.reason,
-      row.ok ? `${(row.changed_ratio * 100).toFixed(2)}%` : "",
-      row.ok ? row.max_pixel_delta.toFixed(3) : "",
-      `${row.pass ? "yes" : "no"} |`,
-    ].join(" | "));
-  }
-  const pass = rows.every((row) => row.pass);
-  if (LABEL) {
-    await mkdir(resultDir, { recursive: true });
-    const path = join(resultDir, `${LABEL}.json`);
-      await writeFile(path, `${JSON.stringify({
-        generatedAt: new Date().toISOString(),
-        tolerance: VISUAL_TOLERANCE,
-        browserExecutable: BROWSER_EXECUTABLE || null,
-        chromiumArgs: CHROMIUM_ARGS,
-        softwareBackend: SOFTWARE_BACKEND,
-        visualOffsets: VISUAL_OFFSETS,
-      occlusionGrid: [OCCLUSION_GRID_W, OCCLUSION_GRID_H],
-      occlusionMinCells: OCCLUSION_MIN_CELLS,
-      occlusionInteriorRadius: OCCLUSION_INTERIOR_RADIUS,
-      occlusionDepthBuffer: OCCLUSION_DEPTH_BUFFER,
-      occlusionDepthEps: OCCLUSION_DEPTH_EPS,
-      occlusionPreserveOrder: OCCLUSION_PRESERVE_ORDER,
-      occlusionIntervalSamples: OCCLUSION_INTERVAL_SAMPLES,
-      pass,
-      rows,
-    }, null, 2)}\n`);
-    console.log(`Wrote ${path}`);
-  }
-  return pass;
-}
-
-const browser = await chromium.launch({
-  headless: !HEADED,
-  args: [
-    "--disable-background-timer-throttling",
-    "--disable-renderer-backgrounding",
-    "--disable-backgrounding-occluded-windows",
-    ...CHROMIUM_ARGS,
-  ],
-  ...(BROWSER_EXECUTABLE ? { executablePath: BROWSER_EXECUTABLE } : {}),
-});
-
-try {
-  if (VISUAL_DIFF) {
-    const pass = await runVisualDiff(browser);
-    if (!pass) process.exitCode = 1;
-  } else {
-    const rows = [];
-    for (const mesh of MESHES) {
-      for (const strategy of STRATEGIES) {
-        for (const paint of PAINTS) {
-          for (const leafTransformStyle of LEAF_TRANSFORM_STYLES) {
-            for (const leafBackface of LEAF_BACKFACES) {
-              for (const transformShape of TRANSFORM_SHAPES) {
-                for (const leafContain of LEAF_CONTAINS) {
-                  for (const occlusion of OCCLUSIONS) {
-                    for (let repeat = 1; repeat <= RUNS; repeat += 1) {
-                      rows.push(await runCase(browser, mesh, strategy, paint, leafTransformStyle, leafBackface, transformShape, leafContain, occlusion, repeat));
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    printRows(rows);
-
-    if (LABEL) {
-      await mkdir(resultDir, { recursive: true });
-      const path = join(resultDir, `${LABEL}.json`);
-      await writeFile(path, `${JSON.stringify({
-        generatedAt: new Date().toISOString(),
-        browserExecutable: BROWSER_EXECUTABLE || null,
-        chromiumArgs: CHROMIUM_ARGS,
-        softwareBackend: SOFTWARE_BACKEND,
-        meshes: MESHES,
-        strategies: STRATEGIES,
-        paints: PAINTS,
-        leafTransformStyles: LEAF_TRANSFORM_STYLES,
-        leafBackfaces: LEAF_BACKFACES,
-        transformShapes: TRANSFORM_SHAPES,
-        leafContains: LEAF_CONTAINS,
-        occlusions: OCCLUSIONS,
-        occlusionGrid: [OCCLUSION_GRID_W, OCCLUSION_GRID_H],
-        occlusionMinCells: OCCLUSION_MIN_CELLS,
-        occlusionInteriorRadius: OCCLUSION_INTERIOR_RADIUS,
-        occlusionDepthBuffer: OCCLUSION_DEPTH_BUFFER,
-        occlusionDepthEps: OCCLUSION_DEPTH_EPS,
-        occlusionPreserveOrder: OCCLUSION_PRESERVE_ORDER,
-        occlusionIntervalSamples: OCCLUSION_INTERVAL_SAMPLES,
-        warmup_ms: WARMUP_MS,
-        sample_ms: SAMPLE_MS,
-        runs: rows,
-      }, null, 2)}\n`);
-      console.log(`Wrote ${path}`);
-    }
-  }
-} finally {
-  await browser.close();
-}
diff --git a/bench/voxel-interval-geometry-correlation.mjs b/bench/voxel-interval-geometry-correlation.mjs
deleted file mode 100644
index 2ae83afe..00000000
--- a/bench/voxel-interval-geometry-correlation.mjs
+++ /dev/null
@@ -1,611 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-import { PRESETS } from "./perf-shared.mjs";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const DEFAULT_MODELS = [
-  "ancient-crash-site",
-  "garden",
-  "scene-mechanic2",
-  "obj-house3",
-  "treasure",
-];
-
-const args = parseArgs(process.argv.slice(2));
-const models = args.models.length ? args.models : DEFAULT_MODELS;
-const baselinePrefix = args.baselinePrefix ?? "a87-interval-baseline";
-const candidatePrefix = args.candidatePrefix ?? "a87-interval-auto";
-const angleStep = Number(args.angleStep ?? 5);
-const outLabel = args.label ?? "a88-interval-geometry-correlation";
-const maxOverlapItems = Number(args.maxOverlapItems ?? 1200);
-
-function parseArgs(argv) {
-  const out = { models: [] };
-  for (const arg of argv) {
-    if (arg.startsWith("--models=")) {
-      out.models.push(...arg.slice("--models=".length).split(",").map((value) => value.trim()).filter(Boolean));
-    } else if (arg.startsWith("--baseline-prefix=")) out.baselinePrefix = arg.slice("--baseline-prefix=".length);
-    else if (arg.startsWith("--candidate-prefix=")) out.candidatePrefix = arg.slice("--candidate-prefix=".length);
-    else if (arg.startsWith("--angle-step=")) out.angleStep = arg.slice("--angle-step=".length);
-    else if (arg.startsWith("--label=")) out.label = arg.slice("--label=".length);
-    else if (arg.startsWith("--max-overlap-items=")) out.maxOverlapItems = arg.slice("--max-overlap-items=".length);
-    else if (!arg.startsWith("--")) out.models.push(arg);
-  }
-  return out;
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 2) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function visibleFaceSignature(rotation) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], rotation)) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-function intervalPhase(rotation, signature, fraction = 0.5) {
-  const matches = [];
-  for (let offset = -180; offset <= 180; offset += 1) {
-    const candidate = { ...rotation, rotY: rotation.rotY + offset };
-    if (visibleFaceSignature(candidate) === signature) matches.push(offset);
-  }
-  const zeroIndex = matches.indexOf(0);
-  if (zeroIndex < 0) return rotation;
-  let start = zeroIndex;
-  let end = zeroIndex;
-  while (start > 0 && matches[start] - matches[start - 1] === 1) start -= 1;
-  while (end + 1 < matches.length && matches[end + 1] - matches[end] === 1) end += 1;
-  const offset = matches[start] + (matches[end] - matches[start]) * fraction;
-  return { ...rotation, rotY: rotation.rotY + offset };
-}
-
-function rotationsForSignature(signature) {
-  const rotations = [];
-  for (let rotY = 0; rotY < 360; rotY += angleStep) {
-    const rotation = { rotX: 65, rotY };
-    if (visibleFaceSignature(rotation) === signature) rotations.push(rotation);
-  }
-  return rotations.length ? rotations : [{ rotX: 65, rotY: 45 }];
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function matrixItemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const base = { face, sourceIndex };
-  const eps = 1e-6;
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function projectPoint(point, rotation) {
-  const [x, y, z] = rotateVec3(point, rotation.rotX, 0, rotation.rotY);
-  return { x, y, z };
-}
-
-function projectedPoint(item, rotation) {
-  const [x, y] = rotateVec3(itemCenter(item), rotation.rotX, 0, rotation.rotY);
-  return { x, y };
-}
-
-function projectedBounds(item, rotation) {
-  const points = itemCorners(item).map((point) => projectPoint(point, rotation));
-  return {
-    minX: Math.min(...points.map((point) => point.x)),
-    maxX: Math.max(...points.map((point) => point.x)),
-    minY: Math.min(...points.map((point) => point.y)),
-    maxY: Math.max(...points.map((point) => point.y)),
-    depth: points.reduce((sum, point) => sum + point.z, 0) / points.length,
-    area: Math.abs(item.width * item.height),
-    primitive: Math.max(item.width, item.height),
-  };
-}
-
-function visibleItems(items, signature) {
-  const faces = new Set(signature.split("|").filter(Boolean));
-  return items.filter((item) => faces.has(item.face));
-}
-
-function sceneBounds(projected) {
-  return {
-    minX: Math.min(...projected.map((item) => item.minX)),
-    maxX: Math.max(...projected.map((item) => item.maxX)),
-    minY: Math.min(...projected.map((item) => item.minY)),
-    maxY: Math.max(...projected.map((item) => item.maxY)),
-  };
-}
-
-function tileSpanScore(item, rotation, bounds, tileCount) {
-  const projected = projectedBounds(item, rotation);
-  const tileW = Math.max(1e-6, (bounds.maxX - bounds.minX) / tileCount);
-  const tileH = Math.max(1e-6, (bounds.maxY - bounds.minY) / tileCount);
-  return Math.max(
-    (projected.maxX - projected.minX) / tileW,
-    (projected.maxY - projected.minY) / tileH,
-  );
-}
-
-function tileOrder(items, orderRotation, tileCount) {
-  const entries = items.map((item) => ({ item, ...projectedPoint(item, orderRotation) }));
-  if (entries.length === 0) return [];
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const entry of entries) {
-    minX = Math.min(minX, entry.x);
-    maxX = Math.max(maxX, entry.x);
-    minY = Math.min(minY, entry.y);
-    maxY = Math.max(maxY, entry.y);
-  }
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.x - minX) / spanX) * tileCount)));
-    const ty = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.y - minY) / spanY) * tileCount)));
-    const key = `${tx}:${ty}`;
-    let tile = tiles.get(key);
-    if (!tile) {
-      tile = { tx, ty, sourceIndex: entry.item.sourceIndex, items: [] };
-      tiles.set(key, tile);
-    }
-    tile.items.push(entry.item);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-  }
-  return [...tiles.values()]
-    .sort((a, b) => (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex)
-    .flatMap((tile) => tile.items);
-}
-
-function ranksForOrder(ordered) {
-  const ranks = new Map();
-  ordered.forEach((item, index) => ranks.set(item.sourceIndex, index));
-  return ranks;
-}
-
-function overlapSummary(items, rotation, baselineRanks, candidateRanks) {
-  const sampledItems = sampleItems(items, maxOverlapItems);
-  const projected = sampledItems.map((item) => ({ item, ...projectedBounds(item, rotation) }));
-  const sorted = projected
-    .map((entry, index) => ({ ...entry, index }))
-    .sort((a, b) => a.minX - b.minX);
-  const active = [];
-  let pairs = 0;
-  let overlapArea = 0;
-  let changedPairs = 0;
-  let changedArea = 0;
-  let sameFacePairs = 0;
-  let sameFaceArea = 0;
-  const pairAreas = new Map();
-  const changedPairAreas = new Map();
-  for (const current of sorted) {
-    for (let i = active.length - 1; i >= 0; i -= 1) {
-      if (active[i].maxX <= current.minX) active.splice(i, 1);
-    }
-    for (const other of active) {
-      if (other.maxY <= current.minY || other.minY >= current.maxY) continue;
-      const x0 = Math.max(current.minX, other.minX);
-      const x1 = Math.min(current.maxX, other.maxX);
-      const y0 = Math.max(current.minY, other.minY);
-      const y1 = Math.min(current.maxY, other.maxY);
-      if (x1 <= x0 || y1 <= y0) continue;
-      const area = (x1 - x0) * (y1 - y0);
-      pairs += 1;
-      overlapArea += area;
-      if (current.item.face === other.item.face) {
-        sameFacePairs += 1;
-        sameFaceArea += area;
-      }
-      const pairKey = facePairKey(current.item.face, other.item.face);
-      pairAreas.set(pairKey, (pairAreas.get(pairKey) ?? 0) + area);
-      const aBase = baselineRanks.get(current.item.sourceIndex);
-      const bBase = baselineRanks.get(other.item.sourceIndex);
-      const aCand = candidateRanks.get(current.item.sourceIndex);
-      const bCand = candidateRanks.get(other.item.sourceIndex);
-      if (
-        Number.isFinite(aBase) &&
-        Number.isFinite(bBase) &&
-        Number.isFinite(aCand) &&
-        Number.isFinite(bCand) &&
-        Math.sign(aBase - bBase) !== Math.sign(aCand - bCand)
-      ) {
-        changedPairs += 1;
-        changedArea += area;
-        changedPairAreas.set(pairKey, (changedPairAreas.get(pairKey) ?? 0) + area);
-      }
-    }
-    active.push(current);
-  }
-  return {
-    pairs,
-    sampledLeaves: sampledItems.length,
-    overlapArea,
-    overlapPairsPerLeaf: sampledItems.length ? pairs / sampledItems.length : 0,
-    changedPairRate: pairs ? changedPairs / pairs : 0,
-    changedAreaRate: overlapArea ? changedArea / overlapArea : 0,
-    sameFacePairRate: pairs ? sameFacePairs / pairs : 0,
-    sameFaceAreaRate: overlapArea ? sameFaceArea / overlapArea : 0,
-    topOverlapPair: topPair(pairAreas, overlapArea),
-    topChangedPair: topPair(changedPairAreas, changedArea),
-  };
-}
-
-function facePairKey(a, b) {
-  return FACE_ORDER.indexOf(a) <= FACE_ORDER.indexOf(b) ? `${a}/${b}` : `${b}/${a}`;
-}
-
-function topPair(map, totalArea) {
-  let bestPair = "";
-  let bestArea = 0;
-  for (const [pair, area] of map) {
-    if (area > bestArea) {
-      bestPair = pair;
-      bestArea = area;
-    }
-  }
-  return {
-    pair: bestPair,
-    areaRate: totalArea ? bestArea / totalArea : 0,
-  };
-}
-
-function sampleItems(items, maxItems) {
-  if (!Number.isFinite(maxItems) || maxItems <= 0 || items.length <= maxItems) return items;
-  const sampled = [];
-  const stride = items.length / maxItems;
-  for (let i = 0; i < maxItems; i += 1) {
-    sampled.push(items[Math.floor(i * stride)]);
-  }
-  return sampled;
-}
-
-function summarizeValues(values) {
-  return {
-    median: median(values),
-    p95: quantile(values, 0.95),
-    p99: quantile(values, 0.99),
-    max: values.length ? Math.max(...values) : null,
-  };
-}
-
-function mergeRows(rows) {
-  const numberKeys = Object.keys(rows[0] ?? {}).filter((key) => typeof rows[0][key] === "number");
-  const merged = {};
-  for (const key of numberKeys) merged[key] = median(rows.map((row) => row[key]));
-  const pairKeys = ["topOverlapPair", "topChangedPair"];
-  for (const key of pairKeys) merged[key] = mostCommonPair(rows.map((row) => row[key]));
-  return merged;
-}
-
-function mostCommonPair(pairs) {
-  const counts = new Map();
-  for (const pair of pairs) {
-    if (!pair?.pair) continue;
-    const current = counts.get(pair.pair) ?? { pair: pair.pair, count: 0, rates: [] };
-    current.count += 1;
-    current.rates.push(pair.areaRate);
-    counts.set(pair.pair, current);
-  }
-  const best = [...counts.values()].sort((a, b) => b.count - a.count || (median(b.rates) ?? 0) - (median(a.rates) ?? 0))[0];
-  return best ? { pair: best.pair, areaRate: median(best.rates) ?? 0 } : { pair: "", areaRate: 0 };
-}
-
-async function loadItems(model) {
-  const preset = PRESETS[model];
-  if (!preset) throw new Error(`Unknown preset ${model}`);
-  const path = resolve(repoRoot, "website/public", preset.url.replace(/^\/gallery\//, "gallery/"));
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    preset.options,
-  );
-  return parsed.polygons
-    .map((polygon, sourceIndex) => matrixItemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-}
-
-function readProfilerRun(prefix, model) {
-  return readFile(join(resultDir, `${prefix}-${model}.json`), "utf8")
-    .then((text) => JSON.parse(text).runs[0]);
-}
-
-function signatureMap(run) {
-  const map = new Map();
-  for (const row of run.signatures) map.set(row.signature, row);
-  return map;
-}
-
-function intervalDelta(baseline, candidate, signature) {
-  const base = signatureMap(baseline).get(signature);
-  const cand = signatureMap(candidate).get(signature);
-  if (!base || !cand || base.frames < 16 || cand.frames < 16) return null;
-  return {
-    signature,
-    baseFrames: base.frames,
-    candidateFrames: cand.frames,
-    baseP95: base.fps_p95,
-    candidateP95: cand.fps_p95,
-    deltaP95: cand.fps_p95 - base.fps_p95,
-    baseP99: base.frame_time_p99_ms,
-    candidateP99: cand.frame_time_p99_ms,
-    deltaP99: cand.frame_time_p99_ms - base.frame_time_p99_ms,
-    baseX4: base.buckets.x4_plus,
-    candidateX4: cand.buckets.x4_plus,
-  };
-}
-
-function analyzeSignature(items, signature) {
-  const visible = visibleItems(items, signature);
-  const rows = [];
-  for (const rotation of rotationsForSignature(signature)) {
-    const centered = intervalPhase(rotation, signature, 0.5);
-    const projected = visible.map((item) => projectedBounds(item, rotation));
-    const centeredProjected = visible.map((item) => projectedBounds(item, centered));
-    const bounds = sceneBounds(projected);
-    const centeredBounds = sceneBounds(centeredProjected);
-    const screenArea = Math.max(1e-6, (bounds.maxX - bounds.minX) * (bounds.maxY - bounds.minY));
-    const projectedAreas = projected.map((item) => Math.max(0, item.maxX - item.minX) * Math.max(0, item.maxY - item.minY));
-    const tile3Scores = visible.map((item) => Math.max(
-      tileSpanScore(item, rotation, bounds, 3),
-      tileSpanScore(item, centered, centeredBounds, 3),
-    ));
-    const tile5Scores = visible.map((item) => Math.max(
-      tileSpanScore(item, rotation, bounds, 5),
-      tileSpanScore(item, centered, centeredBounds, 5),
-    ));
-    const localPrimitives = visible.map((item) => Math.max(item.width, item.height));
-    const baselineOrder = tileOrder(visible, rotation, 4);
-    const candidateTileCount = quantile(tile3Scores, 0.95) > 1 ? 5 : 3;
-    const candidateOrder = tileOrder(visible, centered, candidateTileCount);
-    const overlap = overlapSummary(
-      visible,
-      rotation,
-      ranksForOrder(baselineOrder),
-      ranksForOrder(candidateOrder),
-    );
-    const faceCounts = Object.fromEntries(FACE_ORDER.map((face) => [face, visible.filter((item) => item.face === face).length]));
-    rows.push({
-      leaves: visible.length,
-      topShare: visible.length ? faceCounts.t / visible.length : 0,
-      sideBalance: visible.length
-        ? Math.max(faceCounts.fl, faceCounts.br, faceCounts.fr, faceCounts.bl) / visible.length
-        : 0,
-      projectedAreaOverScreen: projectedAreas.reduce((sum, area) => sum + area, 0) / screenArea,
-      localPrimitiveP95: quantile(localPrimitives, 0.95) ?? 0,
-      localPrimitiveP99: quantile(localPrimitives, 0.99) ?? 0,
-      tile3SpanP95: quantile(tile3Scores, 0.95) ?? 0,
-      tile3SpanP99: quantile(tile3Scores, 0.99) ?? 0,
-      tile3SpanGt1Rate: visible.length ? tile3Scores.filter((score) => score > 1).length / visible.length : 0,
-      tile5SpanP95: quantile(tile5Scores, 0.95) ?? 0,
-      tile5SpanGt1Rate: visible.length ? tile5Scores.filter((score) => score > 1).length / visible.length : 0,
-      candidateTileCount,
-      ...overlap,
-    });
-  }
-  return mergeRows(rows);
-}
-
-function renderMarkdown(rows) {
-  const lines = [];
-  lines.push("# Voxel Interval Geometry Correlation");
-  lines.push("");
-  lines.push(`Baseline prefix: \`${baselinePrefix}\``);
-  lines.push(`Candidate prefix: \`${candidatePrefix}\``);
-  lines.push(`Angle step: ${angleStep}`);
-  lines.push(`Max overlap items: ${maxOverlapItems}`);
-  lines.push("");
-  lines.push("| Model | Signature | Delta p95 | Delta p99 ms | Leaves | Tile3 span p95 | Tile3 >1 % | Overlap/leaf | Changed overlap % | Top overlap pair | Top changed pair | Area/screen | Top % | Candidate tiles |");
-  lines.push("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | ---: | ---: | ---: |");
-  for (const row of rows) {
-    lines.push([
-      `| ${row.model}`,
-      row.signature,
-      fmt(row.deltaP95, 1),
-      fmt(row.deltaP99, 1),
-      fmt(row.geometry.leaves, 0),
-      fmt(row.geometry.tile3SpanP95, 2),
-      fmt(row.geometry.tile3SpanGt1Rate * 100, 1),
-      fmt(row.geometry.overlapPairsPerLeaf, 2),
-      fmt(row.geometry.changedAreaRate * 100, 1),
-      `${row.geometry.topOverlapPair?.pair ?? ""} ${fmt((row.geometry.topOverlapPair?.areaRate ?? 0) * 100, 0)}%`,
-      `${row.geometry.topChangedPair?.pair ?? ""} ${fmt((row.geometry.topChangedPair?.areaRate ?? 0) * 100, 0)}%`,
-      fmt(row.geometry.projectedAreaOverScreen, 2),
-      fmt(row.geometry.topShare * 100, 1),
-      `${fmt(row.geometry.candidateTileCount, 0)} |`,
-    ].join(" | "));
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-const rows = [];
-for (const model of models) {
-  console.log(`[interval-geometry] ${model}`);
-  const items = await loadItems(model);
-  const baseline = await readProfilerRun(baselinePrefix, model);
-  const candidate = await readProfilerRun(candidatePrefix, model);
-  const signatures = new Set([
-    ...baseline.signatures.map((row) => row.signature),
-    ...candidate.signatures.map((row) => row.signature),
-  ]);
-  for (const signature of [...signatures].sort()) {
-    const delta = intervalDelta(baseline, candidate, signature);
-    if (!delta) continue;
-    rows.push({
-      model,
-      ...delta,
-      geometry: analyzeSignature(items, signature),
-    });
-  }
-}
-
-const output = {
-  generatedAt: new Date().toISOString(),
-  baselinePrefix,
-  candidatePrefix,
-  angleStep,
-  rows,
-};
-const jsonPath = join(resultDir, `${outLabel}.json`);
-const mdPath = join(resultDir, `${outLabel}.md`);
-await writeFile(jsonPath, JSON.stringify(output, null, 2));
-await writeFile(mdPath, renderMarkdown(rows));
-
-console.log(`[interval-geometry] wrote ${jsonPath}`);
-console.log(`[interval-geometry] wrote ${mdPath}`);
-console.log(renderMarkdown(rows));
diff --git a/bench/voxel-interval-order-diff.mjs b/bench/voxel-interval-order-diff.mjs
deleted file mode 100644
index 05387fcd..00000000
--- a/bench/voxel-interval-order-diff.mjs
+++ /dev/null
@@ -1,646 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-import { PRESETS } from "./perf-shared.mjs";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const DEFAULT_TARGETS = [
-  "garden:t|br|fr",
-  "treasure:t|br|fr",
-  "ancient-crash-site:t|bl|br",
-  "obj-house3:t|br|fr",
-];
-
-const args = parseArgs(process.argv.slice(2));
-const targets = args.targets.length ? args.targets : DEFAULT_TARGETS;
-const outLabel = args.label ?? "a92-interval-order-diff";
-const maxOverlapItems = Number(args.maxOverlapItems ?? 1800);
-
-function parseArgs(argv) {
-  const out = { targets: [] };
-  for (const arg of argv) {
-    if (arg.startsWith("--targets=")) {
-      out.targets.push(...arg.slice("--targets=".length).split(",").map((value) => value.trim()).filter(Boolean));
-    } else if (arg.startsWith("--label=")) out.label = arg.slice("--label=".length);
-    else if (arg.startsWith("--max-overlap-items=")) out.maxOverlapItems = arg.slice("--max-overlap-items=".length);
-    else if (!arg.startsWith("--")) out.targets.push(arg);
-  }
-  return out;
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function fmt(value, digits = 2) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function visibleFaceSignature(rotation) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], rotation)) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-function signatureRanges(signature) {
-  const ranges = [];
-  let current = null;
-  for (let halfStep = 0; halfStep < 720; halfStep += 1) {
-    const rotY = halfStep * 0.5;
-    if (visibleFaceSignature({ rotX: 65, rotY }) === signature) {
-      if (!current) current = { start: rotY, end: rotY, count: 0 };
-      current.end = rotY;
-      current.count += 1;
-    } else if (current) {
-      ranges.push(current);
-      current = null;
-    }
-  }
-  if (current) ranges.push(current);
-  return ranges.sort((a, b) => b.count - a.count);
-}
-
-function representativeInterval(signature) {
-  const range = signatureRanges(signature)[0];
-  if (!range) throw new Error(`No camera interval for signature ${signature}`);
-  return {
-    start: { rotX: 65, rotY: range.start },
-    midpoint: { rotX: 65, rotY: (range.start + range.end) / 2 },
-    end: { rotX: 65, rotY: range.end },
-  };
-}
-
-function intervalCenterRotation(rotation, signature) {
-  const matches = [];
-  for (let offset = -180; offset <= 180; offset += 1) {
-    const candidate = { ...rotation, rotY: rotation.rotY + offset };
-    if (visibleFaceSignature(candidate) === signature) matches.push(offset);
-  }
-  const zeroIndex = matches.indexOf(0);
-  if (zeroIndex < 0) return rotation;
-  let start = zeroIndex;
-  let end = zeroIndex;
-  while (start > 0 && matches[start] - matches[start - 1] === 1) start -= 1;
-  while (end + 1 < matches.length && matches[end + 1] - matches[end] === 1) end += 1;
-  const offset = (matches[start] + matches[end]) / 2;
-  return { ...rotation, rotY: rotation.rotY + offset };
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function matrixItemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const base = { face, sourceIndex };
-  const eps = 1e-6;
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function projectPoint(point, rotation) {
-  const [x, y, z] = rotateVec3(point, rotation.rotX, 0, rotation.rotY);
-  return { x, y, z };
-}
-
-function projectedPoint(item, rotation) {
-  const [x, y] = rotateVec3(itemCenter(item), rotation.rotX, 0, rotation.rotY);
-  return { x, y };
-}
-
-function projectedBounds(item, rotation) {
-  const points = itemCorners(item).map((point) => projectPoint(point, rotation));
-  return {
-    minX: Math.min(...points.map((point) => point.x)),
-    maxX: Math.max(...points.map((point) => point.x)),
-    minY: Math.min(...points.map((point) => point.y)),
-    maxY: Math.max(...points.map((point) => point.y)),
-    depth: points.reduce((sum, point) => sum + point.z, 0) / points.length,
-    projectedArea: Math.max(0, Math.max(...points.map((point) => point.x)) - Math.min(...points.map((point) => point.x))) *
-      Math.max(0, Math.max(...points.map((point) => point.y)) - Math.min(...points.map((point) => point.y))),
-    localArea: Math.abs(item.width * item.height),
-    primitive: Math.max(item.width, item.height),
-  };
-}
-
-function visibleItems(items, signature) {
-  const faces = new Set(signature.split("|").filter(Boolean));
-  return items.filter((item) => faces.has(item.face));
-}
-
-function sceneBounds(projected) {
-  return {
-    minX: Math.min(...projected.map((item) => item.minX)),
-    maxX: Math.max(...projected.map((item) => item.maxX)),
-    minY: Math.min(...projected.map((item) => item.minY)),
-    maxY: Math.max(...projected.map((item) => item.maxY)),
-  };
-}
-
-function tileSpanScore(item, rotation, bounds, tileCount) {
-  const projected = projectedBounds(item, rotation);
-  const tileW = Math.max(1e-6, (bounds.maxX - bounds.minX) / tileCount);
-  const tileH = Math.max(1e-6, (bounds.maxY - bounds.minY) / tileCount);
-  return Math.max(
-    (projected.maxX - projected.minX) / tileW,
-    (projected.maxY - projected.minY) / tileH,
-  );
-}
-
-function tileOrder(items, orderRotation, tileCount) {
-  const entries = items.map((item) => ({ item, ...projectedPoint(item, orderRotation) }));
-  if (entries.length === 0) return [];
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const entry of entries) {
-    minX = Math.min(minX, entry.x);
-    maxX = Math.max(maxX, entry.x);
-    minY = Math.min(minY, entry.y);
-    maxY = Math.max(maxY, entry.y);
-  }
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.x - minX) / spanX) * tileCount)));
-    const ty = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.y - minY) / spanY) * tileCount)));
-    const key = `${tx}:${ty}`;
-    let tile = tiles.get(key);
-    if (!tile) {
-      tile = { tx, ty, sourceIndex: entry.item.sourceIndex, items: [] };
-      tiles.set(key, tile);
-    }
-    tile.items.push(entry.item);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-  }
-  return [...tiles.values()]
-    .sort((a, b) => (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex)
-    .flatMap((tile) => tile.items);
-}
-
-function ranksForOrder(ordered) {
-  const ranks = new Map();
-  ordered.forEach((item, index) => ranks.set(item.sourceIndex, index));
-  return ranks;
-}
-
-function adaptiveScreenOrder(visible, rotation, signature) {
-  const centered = intervalCenterRotation(rotation, signature);
-  const currentProjected = visible.map((item) => projectedBounds(item, rotation));
-  const centeredProjected = visible.map((item) => projectedBounds(item, centered));
-  const currentBounds = sceneBounds(currentProjected);
-  const centeredBounds = sceneBounds(centeredProjected);
-  const tile3Scores = visible.map((item) => Math.max(
-    tileSpanScore(item, rotation, currentBounds, 3),
-    tileSpanScore(item, centered, centeredBounds, 3),
-  ));
-  const tileCount = (quantile(tile3Scores, 0.95) ?? 0) > 1 ? 5 : 3;
-  const baselineSlots = tileOrder(visible, rotation, tileCount);
-  const phaseOrder = tileOrder(visible, centered, tileCount);
-  const scoreBySource = new Map();
-  visible.forEach((item, index) => scoreBySource.set(item.sourceIndex, tile3Scores[index] ?? 0));
-  const isAnchor = (item) => (scoreBySource.get(item.sourceIndex) ?? 0) > 1;
-  const movablePhase = phaseOrder.filter((item) => !isAnchor(item));
-  let next = 0;
-  return {
-    order: baselineSlots.map((item) => {
-      if (isAnchor(item)) return item;
-      return movablePhase[next++] ?? item;
-    }),
-    tileCount,
-    centeredRotY: centered.rotY,
-    anchoredCount: visible.filter(isAnchor).length,
-    scoreBySource,
-  };
-}
-
-function sampleItemsByProjectedArea(items, rotation, maxItems) {
-  if (!Number.isFinite(maxItems) || maxItems <= 0 || items.length <= maxItems) return items;
-  return items
-    .map((item) => ({ item, area: projectedBounds(item, rotation).projectedArea }))
-    .sort((a, b) => b.area - a.area || a.item.sourceIndex - b.item.sourceIndex)
-    .slice(0, maxItems)
-    .map((entry) => entry.item)
-    .sort((a, b) => a.sourceIndex - b.sourceIndex);
-}
-
-function facePairKey(a, b) {
-  return FACE_ORDER.indexOf(a) <= FACE_ORDER.indexOf(b) ? `${a}/${b}` : `${b}/${a}`;
-}
-
-function signForPair(pair, ranks) {
-  const a = ranks.get(pair.a.item.sourceIndex);
-  const b = ranks.get(pair.b.item.sourceIndex);
-  if (!Number.isFinite(a) || !Number.isFinite(b) || a === b) return 0;
-  return a < b ? -1 : 1;
-}
-
-function addMetric(map, key, value) {
-  map.set(key, (map.get(key) ?? 0) + value);
-}
-
-function changedOverlapDiff(items, rotation, baselineRanks, candidateRanks, candidateScoreBySource) {
-  const sampled = sampleItemsByProjectedArea(items, rotation, maxOverlapItems);
-  const projected = sampled
-    .map((item) => ({ item, ...projectedBounds(item, rotation) }))
-    .sort((a, b) => a.minX - b.minX);
-  const active = [];
-  const pairArea = new Map();
-  const changedPairArea = new Map();
-  const changedDepthArea = new Map();
-  const itemChangedArea = new Map();
-  let pairs = 0;
-  let changedPairs = 0;
-  let overlapArea = 0;
-  let changedArea = 0;
-
-  for (const current of projected) {
-    for (let i = active.length - 1; i >= 0; i -= 1) {
-      if (active[i].maxX <= current.minX) active.splice(i, 1);
-    }
-    for (const other of active) {
-      if (other.maxY <= current.minY || other.minY >= current.maxY) continue;
-      const x0 = Math.max(current.minX, other.minX);
-      const x1 = Math.min(current.maxX, other.maxX);
-      const y0 = Math.max(current.minY, other.minY);
-      const y1 = Math.min(current.maxY, other.maxY);
-      if (x1 <= x0 || y1 <= y0) continue;
-      const area = (x1 - x0) * (y1 - y0);
-      pairs += 1;
-      overlapArea += area;
-      const key = facePairKey(current.item.face, other.item.face);
-      addMetric(pairArea, key, area);
-
-      const pair = { a: current, b: other };
-      const baseSign = signForPair(pair, baselineRanks);
-      const candidateSign = signForPair(pair, candidateRanks);
-      if (baseSign === candidateSign || candidateSign === 0 || baseSign === 0) continue;
-
-      changedPairs += 1;
-      changedArea += area;
-      addMetric(changedPairArea, key, area);
-      const depthKey = Math.abs(current.depth - other.depth) < 1e-6
-        ? "same-depth"
-        : candidateSign < 0 === current.depth < other.depth
-          ? "candidate-low-depth-first"
-          : "candidate-high-depth-first";
-      addMetric(changedDepthArea, depthKey, area);
-      addChangedItem(itemChangedArea, current.item, area, baselineRanks, candidateRanks, candidateScoreBySource);
-      addChangedItem(itemChangedArea, other.item, area, baselineRanks, candidateRanks, candidateScoreBySource);
-    }
-    active.push(current);
-  }
-
-  return {
-    sampledLeaves: sampled.length,
-    pairs,
-    changedPairs,
-    overlapArea,
-    changedArea,
-    changedPairRate: pairs ? changedPairs / pairs : 0,
-    changedAreaRate: overlapArea ? changedArea / overlapArea : 0,
-    topPairAreas: topEntries(pairArea, overlapArea, 8),
-    topChangedPairAreas: topEntries(changedPairArea, changedArea, 8),
-    changedDepthAreas: topEntries(changedDepthArea, changedArea, 4),
-    topChangedItems: [...itemChangedArea.values()]
-      .sort((a, b) => b.changedArea - a.changedArea)
-      .slice(0, 10),
-  };
-}
-
-function addChangedItem(map, item, area, baselineRanks, candidateRanks, candidateScoreBySource) {
-  const entry = map.get(item.sourceIndex) ?? {
-    sourceIndex: item.sourceIndex,
-    face: item.face,
-    primitive: Math.max(item.width, item.height),
-    localArea: item.width * item.height,
-    baselineRank: baselineRanks.get(item.sourceIndex),
-    candidateRank: candidateRanks.get(item.sourceIndex),
-    movedDistance: Math.abs((candidateRanks.get(item.sourceIndex) ?? 0) - (baselineRanks.get(item.sourceIndex) ?? 0)),
-    tile3SpanScore: candidateScoreBySource.get(item.sourceIndex) ?? 0,
-    changedArea: 0,
-  };
-  entry.changedArea += area;
-  map.set(item.sourceIndex, entry);
-}
-
-function topEntries(map, denominator, count) {
-  return [...map.entries()]
-    .map(([key, value]) => ({
-      key,
-      value,
-      rate: denominator ? value / denominator : 0,
-    }))
-    .sort((a, b) => b.value - a.value)
-    .slice(0, count);
-}
-
-async function loadItems(model) {
-  const preset = PRESETS[model];
-  if (!preset) throw new Error(`Unknown preset ${model}`);
-  const path = resolve(repoRoot, "website/public", preset.url.replace(/^\/gallery\//, "gallery/"));
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    preset.options,
-  );
-  return parsed.polygons
-    .map((polygon, sourceIndex) => matrixItemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-}
-
-function movedSummary(visible, baselineRanks, candidateRanks) {
-  const byFace = new Map();
-  const distances = [];
-  for (const item of visible) {
-    const baselineRank = baselineRanks.get(item.sourceIndex);
-    const candidateRank = candidateRanks.get(item.sourceIndex);
-    if (!Number.isFinite(baselineRank) || !Number.isFinite(candidateRank)) continue;
-    const distance = Math.abs(candidateRank - baselineRank);
-    if (distance === 0) continue;
-    distances.push(distance);
-    const current = byFace.get(item.face) ?? { face: item.face, count: 0, totalDistance: 0 };
-    current.count += 1;
-    current.totalDistance += distance;
-    byFace.set(item.face, current);
-  }
-  return {
-    movedCount: distances.length,
-    movedRate: visible.length ? distances.length / visible.length : 0,
-    movedDistanceP50: quantile(distances, 0.5) ?? 0,
-    movedDistanceP95: quantile(distances, 0.95) ?? 0,
-    movedByFace: [...byFace.values()]
-      .map((entry) => ({
-        ...entry,
-        averageDistance: entry.count ? entry.totalDistance / entry.count : 0,
-      }))
-      .sort((a, b) => b.count - a.count),
-  };
-}
-
-function analyzeTarget(target) {
-  const splitAt = target.indexOf(":");
-  if (splitAt < 0) throw new Error(`Target must be model:signature, got ${target}`);
-  return {
-    model: target.slice(0, splitAt),
-    signature: target.slice(splitAt + 1),
-  };
-}
-
-async function analyze({ model, signature }) {
-  const items = await loadItems(model);
-  const visible = visibleItems(items, signature);
-  const interval = representativeInterval(signature);
-  const orderRotation = interval.start;
-  const overlapRotation = interval.midpoint;
-  const baselineOrder = tileOrder(visible, orderRotation, 4);
-  const candidate = adaptiveScreenOrder(visible, orderRotation, signature);
-  const baselineRanks = ranksForOrder(baselineOrder);
-  const candidateRanks = ranksForOrder(candidate.order);
-  const moved = movedSummary(visible, baselineRanks, candidateRanks);
-  const changed = changedOverlapDiff(visible, overlapRotation, baselineRanks, candidateRanks, candidate.scoreBySource);
-  return {
-    model,
-    signature,
-    orderRotation,
-    overlapRotation,
-    visibleLeaves: visible.length,
-    candidateTileCount: candidate.tileCount,
-    candidateCenteredRotY: candidate.centeredRotY,
-    candidateAnchoredCount: candidate.anchoredCount,
-    candidateAnchoredRate: visible.length ? candidate.anchoredCount / visible.length : 0,
-    ...moved,
-    changedOverlap: changed,
-  };
-}
-
-function renderMarkdown(rows) {
-  const lines = [];
-  lines.push("# Voxel Interval Order Diff");
-  lines.push("");
-  lines.push("Baseline: current tile4 row-major order. Candidate: adaptive screen-span phase order from A85/A87.");
-  lines.push("Orders are computed at the interval entry boundary; overlap contribution is measured at the interval midpoint.");
-  lines.push(`Max overlap items: ${maxOverlapItems}`);
-  lines.push("");
-  lines.push("| Model | Signature | RotY | Leaves | Cand tiles | Anchored % | Moved % | Moved p95 | Changed overlap % | Top changed pairs |");
-  lines.push("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |");
-  for (const row of rows) {
-    lines.push([
-      `| ${row.model}`,
-      row.signature,
-      fmt(row.orderRotation.rotY, 1),
-      row.visibleLeaves,
-      row.candidateTileCount,
-      fmt(row.candidateAnchoredRate * 100, 1),
-      fmt(row.movedRate * 100, 1),
-      fmt(row.movedDistanceP95, 0),
-      fmt(row.changedOverlap.changedAreaRate * 100, 1),
-      `${row.changedOverlap.topChangedPairAreas.slice(0, 3).map((entry) => `${entry.key} ${fmt(entry.rate * 100, 0)}%`).join(", ")} |`,
-    ].join(" | "));
-  }
-
-  for (const row of rows) {
-    lines.push("");
-    lines.push(`## ${row.model} ${row.signature}`);
-    lines.push("");
-    lines.push(`Order rotation: rotX=${fmt(row.orderRotation.rotX, 1)}, rotY=${fmt(row.orderRotation.rotY, 1)}; overlap rotation: rotY=${fmt(row.overlapRotation.rotY, 1)}; candidate centered rotY=${fmt(row.candidateCenteredRotY, 1)}.`);
-    lines.push("");
-    lines.push("Moved by face:");
-    lines.push("");
-    lines.push("| Face | Count | Avg distance |");
-    lines.push("| --- | ---: | ---: |");
-    for (const face of row.movedByFace) {
-      lines.push(`| ${face.face} | ${face.count} | ${fmt(face.averageDistance, 1)} |`);
-    }
-    lines.push("");
-    lines.push("Changed depth area:");
-    lines.push("");
-    lines.push("| Direction | Area share |");
-    lines.push("| --- | ---: |");
-    for (const entry of row.changedOverlap.changedDepthAreas) {
-      lines.push(`| ${entry.key} | ${fmt(entry.rate * 100, 1)}% |`);
-    }
-    lines.push("");
-    lines.push("Top changed leaves:");
-    lines.push("");
-    lines.push("| Source | Face | Primitive | Move | Tile span | Changed area |");
-    lines.push("| ---: | --- | ---: | ---: | ---: | ---: |");
-    for (const item of row.changedOverlap.topChangedItems) {
-      lines.push([
-        `| ${item.sourceIndex}`,
-        item.face,
-        fmt(item.primitive, 0),
-        fmt(item.movedDistance, 0),
-        fmt(item.tile3SpanScore, 2),
-        `${fmt(item.changedArea, 0)} |`,
-      ].join(" | "));
-    }
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-const rows = [];
-for (const target of targets.map(analyzeTarget)) {
-  console.log(`[order-diff] ${target.model} ${target.signature}`);
-  rows.push(await analyze(target));
-}
-
-const output = {
-  generatedAt: new Date().toISOString(),
-  maxOverlapItems,
-  targets,
-  rows,
-};
-const jsonPath = join(resultDir, `${outLabel}.json`);
-const mdPath = join(resultDir, `${outLabel}.md`);
-await writeFile(jsonPath, JSON.stringify(output, null, 2));
-await writeFile(mdPath, renderMarkdown(rows));
-
-console.log(`[order-diff] wrote ${jsonPath}`);
-console.log(`[order-diff] wrote ${mdPath}`);
-console.log(renderMarkdown(rows));
diff --git a/bench/voxel-interval-profiler.mjs b/bench/voxel-interval-profiler.mjs
deleted file mode 100644
index 4000d61a..00000000
--- a/bench/voxel-interval-profiler.mjs
+++ /dev/null
@@ -1,374 +0,0 @@
-#!/usr/bin/env node
-import { createServer } from "node:http";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { chromium } from "playwright";
-import { normalFacesCamera } from "../packages/core/dist/index.js";
-import { PRESETS } from "./perf-shared.mjs";
-import { chromiumArgsWithGpuDefault } from "./chromium-defaults.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, "..");
-const benchDir = resolve(repoRoot, "bench");
-const galleryDir = resolve(repoRoot, "website/public/gallery");
-
-const argv = process.argv.slice(2);
-const flag = (name) => argv.indexOf(`--${name}`);
-const optStr = (name, dflt = "") => {
-  const i = flag(name);
-  return i >= 0 ? argv[i + 1] : dflt;
-};
-const optAll = (name) => {
-  const values = [];
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === `--${name}` && argv[i + 1]) {
-      values.push(argv[i + 1]);
-      i += 1;
-    } else if (arg.startsWith(`--${name}=`)) {
-      values.push(arg.slice(name.length + 3));
-    }
-  }
-  return values;
-};
-const optNum = (name, dflt) => {
-  const v = optStr(name);
-  return v ? Number(v) : dflt;
-};
-const hasFlag = (name) => flag(name) >= 0;
-
-const MESH = optStr("mesh", "garden");
-const MODE = optStr("mode", "baked");
-const MOTION = optStr("motion", "rot");
-const RENDERER = optStr("renderer", "vanilla");
-const WARMUP_MS = optNum("warmup", 1500);
-const SAMPLE_MS = optNum("sample", 8000);
-const RUNS = optNum("runs", 1);
-const LABEL = optStr("label");
-const PAGE_QUERY = optStr("page-query");
-const STRATEGY = optStr("strategy", PAGE_QUERY ? "candidate" : "baseline");
-const HEADED = hasFlag("headed");
-const JSON_ONLY = hasFlag("json");
-const BROWSER_EXECUTABLE = optStr("browser-executable");
-const SOFTWARE_BACKEND = hasFlag("software-backend");
-const CHROMIUM_ARGS = chromiumArgsWithGpuDefault([
-  ...optAll("chromium-arg"),
-  ...optAll("chromium-args").flatMap((value) => value.split(/\s+/).filter(Boolean)),
-], { softwareBackend: SOFTWARE_BACKEND });
-
-const MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".obj": "text/plain; charset=utf-8",
-  ".mtl": "text/plain; charset=utf-8",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gltf": "application/json; charset=utf-8",
-  ".glb": "model/gltf-binary",
-  ".vox": "application/octet-stream",
-};
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-
-function startServer() {
-  return new Promise((resolveStart, rejectStart) => {
-    const server = createServer(async (req, res) => {
-      try {
-        const u = new URL(req.url, "http://localhost");
-        const safe = u.pathname.replace(/\/+/g, "/");
-        if (safe.includes("..")) {
-          res.writeHead(403);
-          res.end();
-          return;
-        }
-        const abs = safe === "/" || safe === ""
-          ? resolve(benchDir, "perf.html")
-          : safe.startsWith("/gallery/")
-            ? resolve(galleryDir, safe.slice("/gallery/".length))
-            : resolve(benchDir, safe.slice(1));
-        const data = await readFile(abs);
-        res.writeHead(200, {
-          "Content-Type": MIME[extname(abs).toLowerCase()] || "application/octet-stream",
-          "Cache-Control": "no-store",
-        });
-        res.end(data);
-      } catch (err) {
-        res.writeHead(404);
-        res.end(String(err?.message ?? err));
-      }
-    });
-    server.on("error", rejectStart);
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolveStart({ server, port: typeof addr === "object" ? addr.port : 0 });
-    });
-  });
-}
-
-function stopServer(server) {
-  return new Promise((resolveStop) => server.close(resolveStop));
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function visibleFaceSignature(rotX, rotY) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], { rotX, rotY })) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-function bucketName(dt, baseFrameMs) {
-  const ratio = Math.max(1, Math.round(dt / baseFrameMs));
-  return ratio >= 4 ? "x4_plus" : `x${ratio}`;
-}
-
-function estimateBaseFrameMs(dts) {
-  const p10 = quantile(dts, 0.1) ?? 16.667;
-  return p10 < 12 ? 8.333 : 16.667;
-}
-
-function summarizeFrames(frames) {
-  const dts = frames.map((frame) => frame.dt);
-  const p50 = median(dts) ?? 0;
-  const p95 = quantile(dts, 0.95) ?? 0;
-  const p99 = quantile(dts, 0.99) ?? 0;
-  const buckets = { x1: 0, x2: 0, x3: 0, x4_plus: 0 };
-  for (const frame of frames) buckets[frame.bucket] = (buckets[frame.bucket] ?? 0) + 1;
-  return {
-    frames: frames.length,
-    fps_p50: p50 > 0 ? +(1000 / p50).toFixed(2) : 0,
-    fps_p95: p95 > 0 ? +(1000 / p95).toFixed(2) : 0,
-    frame_time_p50_ms: +p50.toFixed(3),
-    frame_time_p95_ms: +p95.toFixed(3),
-    frame_time_p99_ms: +p99.toFixed(3),
-    buckets,
-  };
-}
-
-function normalizeRotY(rotY) {
-  const normalized = rotY % 360;
-  return normalized < 0 ? normalized + 360 : normalized;
-}
-
-function frameRotation(preset, absoluteSampleIndex) {
-  if (MOTION !== "rot") return { rotX: preset.rotX, rotY: preset.rotY };
-  return {
-    rotX: preset.rotX,
-    rotY: normalizeRotY(preset.rotY + absoluteSampleIndex * 0.5),
-  };
-}
-
-function frameRows(samples, startIdx, preset) {
-  const raw = samples
-    .map((sample, index) => ({ sample, absoluteSampleIndex: startIdx + index }))
-    .filter(({ sample }) => Number.isFinite(sample?.dt) && sample.dt > 0 && sample.dt < 2000);
-  const baseFrameMs = estimateBaseFrameMs(raw.map(({ sample }) => sample.dt));
-  return {
-    baseFrameMs,
-    frames: raw.map(({ sample, absoluteSampleIndex }, index) => {
-      const rotation = frameRotation(preset, absoluteSampleIndex);
-      return {
-        index,
-        absoluteSampleIndex,
-        t: sample.t,
-        dt: sample.dt,
-        bucket: bucketName(sample.dt, baseFrameMs),
-        rotX: rotation.rotX,
-        rotY: rotation.rotY,
-        signature: visibleFaceSignature(rotation.rotX, rotation.rotY),
-      };
-    }),
-  };
-}
-
-function segmentFrames(frames) {
-  const segments = [];
-  let current = null;
-  for (const frame of frames) {
-    if (!current || current.signature !== frame.signature) {
-      current = {
-        id: segments.length,
-        signature: frame.signature,
-        startFrame: frame.index,
-        endFrame: frame.index,
-        startRotY: frame.rotY,
-        endRotY: frame.rotY,
-        frames: [],
-      };
-      segments.push(current);
-    }
-    current.frames.push(frame);
-    current.endFrame = frame.index;
-    current.endRotY = frame.rotY;
-  }
-  return segments.map((segment) => ({
-    id: segment.id,
-    signature: segment.signature,
-    startFrame: segment.startFrame,
-    endFrame: segment.endFrame,
-    startRotY: +segment.startRotY.toFixed(3),
-    endRotY: +segment.endRotY.toFixed(3),
-    ...summarizeFrames(segment.frames),
-  }));
-}
-
-function groupBySignature(frames) {
-  const groups = new Map();
-  for (const frame of frames) {
-    const group = groups.get(frame.signature) ?? [];
-    group.push(frame);
-    groups.set(frame.signature, group);
-  }
-  return [...groups.entries()]
-    .map(([signature, group]) => ({ signature, ...summarizeFrames(group) }))
-    .sort((a, b) => FACE_ORDER.indexOf(a.signature) - FACE_ORDER.indexOf(b.signature));
-}
-
-function buildUrl(port) {
-  const params = new URLSearchParams({
-    mesh: MESH,
-    mode: MODE,
-    motion: MOTION,
-  });
-  const extra = PAGE_QUERY ? `&${PAGE_QUERY.replace(/^\?/, "")}` : "";
-  return `http://127.0.0.1:${port}/perf-${RENDERER}.html?${params.toString()}${extra}`;
-}
-
-async function runOnce(port, repeat) {
-  const preset = PRESETS[MESH];
-  if (!preset) throw new Error(`Unknown bench preset: ${MESH}`);
-
-  const launchOptions = { headless: !HEADED, args: CHROMIUM_ARGS };
-  if (BROWSER_EXECUTABLE) launchOptions.executablePath = BROWSER_EXECUTABLE;
-  const browser = await chromium.launch(launchOptions);
-  try {
-    const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
-    const page = await ctx.newPage();
-    await page.goto(buildUrl(port), { waitUntil: "load" });
-    await page.waitForFunction(() => window.__perf__?.ready === true, null, { timeout: 30000 });
-    await page.waitForTimeout(WARMUP_MS);
-    const startIdx = await page.evaluate(() => window.__perf__.samples.length);
-    await page.waitForTimeout(SAMPLE_MS);
-    const pageResult = await page.evaluate((from) => ({
-      samples: window.__perf__.samples.slice(from),
-      polyCount: window.__perf__.polyCount,
-      renderStats: window.__perf__.renderStats ?? null,
-    }), startIdx);
-    await ctx.close();
-
-    const { frames, baseFrameMs } = frameRows(pageResult.samples, startIdx, preset);
-    return {
-      repeat,
-      strategy: STRATEGY,
-      mesh: MESH,
-      renderer: RENDERER,
-      mode: MODE,
-      motion: MOTION,
-      pageQuery: PAGE_QUERY || null,
-      warmup_ms: WARMUP_MS,
-      sample_ms: SAMPLE_MS,
-      baseFrameMs: +baseFrameMs.toFixed(3),
-      ...summarizeFrames(frames),
-      polyCount: pageResult.polyCount,
-      renderStats: pageResult.renderStats,
-      segments: segmentFrames(frames),
-      signatures: groupBySignature(frames),
-    };
-  } finally {
-    await browser.close();
-  }
-}
-
-function printRun(run) {
-  console.log(
-    `[intervals] ${run.strategy} ${run.mesh} r${run.repeat} p50=${fmt(run.fps_p50)} p95=${fmt(run.fps_p95)} p99=${fmt(run.frame_time_p99_ms)}ms base=${fmt(run.baseFrameMs, 3)}ms`,
-  );
-  console.log("| Segment | Signature | RotY | Frames | p95 FPS | p99 ms | x1 | x2 | x3 | x4+ |");
-  console.log("| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-  for (const segment of run.segments) {
-    if (segment.frames < 8) continue;
-    console.log([
-      `| ${segment.id}`,
-      segment.signature,
-      `${fmt(segment.startRotY)}-${fmt(segment.endRotY)}`,
-      segment.frames,
-      fmt(segment.fps_p95),
-      fmt(segment.frame_time_p99_ms),
-      segment.buckets.x1,
-      segment.buckets.x2,
-      segment.buckets.x3,
-      `${segment.buckets.x4_plus} |`,
-    ].join(" | "));
-  }
-}
-
-const { server, port } = await startServer();
-try {
-  if (!JSON_ONLY) {
-    console.log(`[intervals] server :${port}`);
-    console.log(`[intervals] mesh=${MESH} renderer=${RENDERER} mode=${MODE} motion=${MOTION} strategy=${STRATEGY} runs=${RUNS} warmup=${WARMUP_MS}ms sample=${SAMPLE_MS}ms`);
-  }
-  const runs = [];
-  for (let repeat = 1; repeat <= RUNS; repeat += 1) {
-    const run = await runOnce(port, repeat);
-    runs.push(run);
-    if (!JSON_ONLY) printRun(run);
-  }
-  const out = {
-    mesh: MESH,
-    strategy: STRATEGY,
-    renderer: RENDERER,
-    mode: MODE,
-    motion: MOTION,
-    pageQuery: PAGE_QUERY || null,
-    browserExecutable: BROWSER_EXECUTABLE || null,
-    chromiumArgs: CHROMIUM_ARGS,
-    softwareBackend: SOFTWARE_BACKEND,
-    warmup_ms: WARMUP_MS,
-    sample_ms: SAMPLE_MS,
-    runs,
-  };
-  if (LABEL) {
-    const dir = resolve(repoRoot, "bench/results");
-    mkdirSync(dir, { recursive: true });
-    const file = resolve(dir, `${LABEL}.json`);
-    writeFileSync(file, JSON.stringify(out, null, 2) + "\n");
-    if (!JSON_ONLY) console.log(`[intervals] wrote ${file}`);
-  }
-  if (JSON_ONLY) console.log(JSON.stringify(out, null, 2));
-} finally {
-  await stopServer(server);
-}
diff --git a/bench/voxel-interval-screen-metrics.mjs b/bench/voxel-interval-screen-metrics.mjs
deleted file mode 100644
index ddf8be5c..00000000
--- a/bench/voxel-interval-screen-metrics.mjs
+++ /dev/null
@@ -1,452 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-import { PRESETS } from "./perf-shared.mjs";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const resultDir = resolve(repoRoot, "bench/results");
-const galleryDir = resolve(repoRoot, "website/public");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const args = parseArgs(process.argv.slice(2));
-const labels = args.labels.length ? args.labels : [
-  "a155-interval-current-ancient-crash-site",
-  "a155-interval-current-obj-house3",
-  "a155-interval-current-scene-mechanic2",
-];
-const angleStep = Number(args.angleStep ?? 5);
-const outLabel = args.out ?? "a155-interval-screen-metrics";
-
-function parseArgs(argv) {
-  const out = { labels: [] };
-  for (const arg of argv) {
-    if (arg.startsWith("--labels=")) {
-      out.labels.push(...arg.slice("--labels=".length).split(",").map((value) => value.trim()).filter(Boolean));
-    } else if (arg.startsWith("--angle-step=")) {
-      out.angleStep = arg.slice("--angle-step=".length);
-    } else if (arg.startsWith("--out=")) {
-      out.out = arg.slice("--out=".length);
-    } else if (!arg.startsWith("--")) {
-      out.labels.push(arg);
-    }
-  }
-  return out;
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (!sorted.length) return 0;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function itemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const base = { face, sourceIndex };
-  const eps = 1e-6;
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function projectedCenter(item, rotation) {
-  const [x, y] = rotateVec3(itemCenter(item), rotation.rotX, 0, rotation.rotY);
-  return { x, y };
-}
-
-function tileScanlineOrder(items, rotation) {
-  const entries = items.map((item) => ({ item, ...projectedCenter(item, rotation) }));
-  if (!entries.length) return [];
-  const minX = Math.min(...entries.map((entry) => entry.x));
-  const maxX = Math.max(...entries.map((entry) => entry.x));
-  const minY = Math.min(...entries.map((entry) => entry.y));
-  const maxY = Math.max(...entries.map((entry) => entry.y));
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(3, Math.max(0, Math.floor(((entry.x - minX) / spanX) * 4)));
-    const ty = Math.min(3, Math.max(0, Math.floor(((entry.y - minY) / spanY) * 4)));
-    const key = `${tx}:${ty}`;
-    const tile = tiles.get(key) ?? { tx, ty, sourceIndex: entry.item.sourceIndex, items: [] };
-    tile.items.push(entry.item);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-    tiles.set(key, tile);
-  }
-  return [...tiles.values()]
-    .sort((a, b) => (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex)
-    .flatMap((tile) => tile.items);
-}
-
-function polygonArea(points) {
-  let sum = 0;
-  for (let i = 0; i < points.length; i += 1) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    sum += a.x * b.y - b.x * a.y;
-  }
-  return Math.abs(sum) / 2;
-}
-
-function projectedBounds(item, rotation, order) {
-  const points = itemCorners(item).map((point) => {
-    const [x, y, z] = rotateVec3(point, rotation.rotX, 0, rotation.rotY);
-    return { x, y, z };
-  });
-  const minX = Math.min(...points.map((point) => point.x));
-  const maxX = Math.max(...points.map((point) => point.x));
-  const minY = Math.min(...points.map((point) => point.y));
-  const maxY = Math.max(...points.map((point) => point.y));
-  return {
-    face: item.face,
-    order,
-    minX,
-    maxX,
-    minY,
-    maxY,
-    depth: points.reduce((sum, point) => sum + point.z, 0) / points.length,
-    boundsArea: Math.max(0, maxX - minX) * Math.max(0, maxY - minY),
-    quadArea: polygonArea(points),
-  };
-}
-
-function visibleFaceSignature(rotation) {
-  return Object.entries(FACE_NORMALS)
-    .filter(([, normal]) => normalFacesCamera(normal, rotation))
-    .map(([face]) => face)
-    .join("|");
-}
-
-function rotationsForSignature(signature) {
-  const rotations = [];
-  for (let rotY = 0; rotY < 360; rotY += angleStep) {
-    const rotation = { rotX: 65, rotY };
-    if (visibleFaceSignature(rotation) === signature) rotations.push(rotation);
-  }
-  return rotations.length ? rotations : [{ rotX: 65, rotY: 45 }];
-}
-
-function overlapMetrics(projected) {
-  const sorted = projected.map((rect, index) => ({ ...rect, index })).sort((a, b) => a.minX - b.minX);
-  const active = [];
-  let pairs = 0;
-  let area = 0;
-  let invAsc = 0;
-  let invDesc = 0;
-  let ties = 0;
-  const facePairAreas = new Map();
-  for (const current of sorted) {
-    for (let i = active.length - 1; i >= 0; i -= 1) {
-      if (active[i].maxX <= current.minX) active.splice(i, 1);
-    }
-    for (const other of active) {
-      if (other.maxY <= current.minY || other.minY >= current.maxY) continue;
-      const x0 = Math.max(current.minX, other.minX);
-      const x1 = Math.min(current.maxX, other.maxX);
-      const y0 = Math.max(current.minY, other.minY);
-      const y1 = Math.min(current.maxY, other.maxY);
-      if (x1 <= x0 || y1 <= y0) continue;
-      const overlapArea = (x1 - x0) * (y1 - y0);
-      pairs += 1;
-      area += overlapArea;
-      const pair = [current.face, other.face].sort().join("+");
-      facePairAreas.set(pair, (facePairAreas.get(pair) ?? 0) + overlapArea);
-      const orderDelta = current.order - other.order;
-      const depthDelta = current.depth - other.depth;
-      if (Math.abs(depthDelta) <= 0.5) {
-        ties += 1;
-      } else {
-        if ((orderDelta < 0) !== (depthDelta < 0)) invAsc += 1;
-        if ((orderDelta < 0) !== (depthDelta > 0)) invDesc += 1;
-      }
-    }
-    active.push(current);
-  }
-  const topPair = [...facePairAreas.entries()].sort((a, b) => b[1] - a[1])[0] ?? null;
-  return {
-    pairs,
-    area,
-    invAsc,
-    invDesc,
-    ties,
-    topPair: topPair ? { pair: topPair[0], areaRate: area ? topPair[1] / area : 0 } : null,
-  };
-}
-
-function mergeRows(rows) {
-  return {
-    active: median(rows.map((row) => row.active)),
-    boundsFill: median(rows.map((row) => row.boundsFill)),
-    quadFill: median(rows.map((row) => row.quadFill)),
-    overlapPairsPerLeaf: median(rows.map((row) => row.overlapPairsPerLeaf)),
-    overlapAreaPerLeaf: median(rows.map((row) => row.overlapAreaPerLeaf)),
-    invAscRate: median(rows.map((row) => row.invAscRate)),
-    invDescRate: median(rows.map((row) => row.invDescRate)),
-    minInvRate: median(rows.map((row) => Math.min(row.invAscRate, row.invDescRate))),
-    screenArea: median(rows.map((row) => row.screenArea)),
-    topPair: topPair(rows.map((row) => row.topPair)),
-  };
-}
-
-function topPair(pairs) {
-  const scores = new Map();
-  for (const pair of pairs) {
-    if (!pair) continue;
-    scores.set(pair.pair, (scores.get(pair.pair) ?? 0) + pair.areaRate);
-  }
-  const best = [...scores.entries()].sort((a, b) => b[1] - a[1])[0];
-  return best ? { pair: best[0], areaRate: best[1] / Math.max(1, pairs.filter(Boolean).length) } : null;
-}
-
-function geometryForSignature(items, signature) {
-  const faces = new Set(signature.split("|").filter(Boolean));
-  const visible = items.filter((item) => faces.has(item.face));
-  const rows = rotationsForSignature(signature).map((rotation) => {
-    const ordered = tileScanlineOrder(visible, rotation);
-    const ranks = new Map(ordered.map((item, index) => [item.sourceIndex, index]));
-    const projected = visible.map((item) => projectedBounds(item, rotation, ranks.get(item.sourceIndex) ?? item.sourceIndex));
-    const minX = Math.min(...projected.map((rect) => rect.minX));
-    const maxX = Math.max(...projected.map((rect) => rect.maxX));
-    const minY = Math.min(...projected.map((rect) => rect.minY));
-    const maxY = Math.max(...projected.map((rect) => rect.maxY));
-    const screenArea = Math.max(1e-6, (maxX - minX) * (maxY - minY));
-    const boundsArea = projected.reduce((sum, rect) => sum + rect.boundsArea, 0);
-    const quadArea = projected.reduce((sum, rect) => sum + rect.quadArea, 0);
-    const overlap = overlapMetrics(projected);
-    return {
-      active: visible.length,
-      screenArea,
-      boundsFill: boundsArea / screenArea,
-      quadFill: quadArea / screenArea,
-      overlapPairsPerLeaf: visible.length ? overlap.pairs / visible.length : 0,
-      overlapAreaPerLeaf: visible.length ? overlap.area / visible.length : 0,
-      invAscRate: overlap.pairs ? overlap.invAsc / overlap.pairs : 0,
-      invDescRate: overlap.pairs ? overlap.invDesc / overlap.pairs : 0,
-      topPair: overlap.topPair,
-    };
-  });
-  return mergeRows(rows);
-}
-
-async function loadItems(mesh) {
-  const preset = PRESETS[mesh];
-  if (!preset) throw new Error(`No preset for ${mesh}`);
-  const path = resolve(galleryDir, preset.url.replace(/^\//, ""));
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize: preset.options?.targetSize ?? 70, gridShift: 0 },
-  );
-  return parsed.polygons
-    .map((polygon, sourceIndex) => itemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-}
-
-async function analyzeLabel(label) {
-  const data = JSON.parse(await readFile(resolve(resultDir, `${label}.json`), "utf8"));
-  const items = await loadItems(data.mesh);
-  const run = data.runs[0];
-  return run.signatures.map((signatureRow) => ({
-    label,
-    mesh: data.mesh,
-    signature: signatureRow.signature,
-    fpsP95: signatureRow.fps_p95,
-    p99: signatureRow.frame_time_p99_ms,
-    x1: signatureRow.buckets.x1,
-    x2: signatureRow.buckets.x2,
-    x3: signatureRow.buckets.x3,
-    x4Plus: signatureRow.buckets.x4_plus,
-    geometry: geometryForSignature(items, signatureRow.signature),
-  }));
-}
-
-function renderMarkdown(rows) {
-  const lines = [
-    "# Voxel Interval Screen Metrics",
-    "",
-    `Angle step: ${angleStep}`,
-    "",
-    "| Mesh | Signature | p95 FPS | p99 ms | Active | Bounds fill | Overlap/leaf | Asc inv % | Desc inv % | Top pair | Pair % | x1 | x2 | x3 | x4+ |",
-    "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: |",
-  ];
-  for (const row of rows) {
-    lines.push([
-      `| ${row.mesh}`,
-      row.signature,
-      fmt(row.fpsP95),
-      fmt(row.p99),
-      fmt(row.geometry.active, 0),
-      fmt(row.geometry.boundsFill, 2),
-      fmt(row.geometry.overlapPairsPerLeaf, 2),
-      fmt(row.geometry.invAscRate * 100, 1),
-      fmt(row.geometry.invDescRate * 100, 1),
-      row.geometry.topPair?.pair ?? "",
-      fmt((row.geometry.topPair?.areaRate ?? 0) * 100, 0),
-      row.x1,
-      row.x2,
-      row.x3,
-      `${row.x4Plus} |`,
-    ].join(" | "));
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-const rows = (await Promise.all(labels.map((label) => analyzeLabel(label)))).flat();
-const output = {
-  generatedAt: new Date().toISOString(),
-  labels,
-  angleStep,
-  rows,
-};
-const jsonPath = join(resultDir, `${outLabel}.json`);
-const mdPath = join(resultDir, `${outLabel}.md`);
-await writeFile(jsonPath, JSON.stringify(output, null, 2));
-await writeFile(mdPath, renderMarkdown(rows));
-console.log(renderMarkdown(rows));
-console.log(`Wrote ${jsonPath}`);
-console.log(`Wrote ${mdPath}`);
diff --git a/bench/voxel-occlusion-potential.mjs b/bench/voxel-occlusion-potential.mjs
deleted file mode 100644
index 796f9042..00000000
--- a/bench/voxel-occlusion-potential.mjs
+++ /dev/null
@@ -1,333 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-import { PRESETS } from "./perf-shared.mjs";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const galleryDir = resolve(repoRoot, "website/public");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const args = new Map(process.argv.slice(2).map((arg) => {
-  const [key, ...rest] = arg.replace(/^--/, "").split("=");
-  return [key, rest.length ? rest.join("=") : "true"];
-}));
-
-const MESHES = (args.get("meshes") ?? "obj-house3,ancient-crash-site,scene-mechanic2,Treasure,army,skyscraper")
-  .split(",")
-  .map((value) => value.trim())
-  .filter(Boolean);
-const ANGLE_STEP = Number(args.get("angle-step") ?? 10);
-const GRID_W = Number(args.get("grid-w") ?? 240);
-const GRID_H = Number(args.get("grid-h") ?? 160);
-const LABEL = args.get("label") ?? "";
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (!sorted.length) return 0;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function itemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const eps = 1e-6;
-  const base = { face, sourceIndex };
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function visibleFaceSignature(rotX, rotY) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], { rotX, rotY })) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-async function loadItems(meshId) {
-  const preset = PRESETS[meshId];
-  if (!preset) throw new Error(`Unknown preset ${meshId}`);
-  const path = resolve(galleryDir, preset.url.replace(/^\//, ""));
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize: preset.options?.targetSize ?? 70, gridShift: 0 },
-  );
-  const items = parsed.polygons
-    .map((polygon, sourceIndex) => itemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-  if (items.length !== parsed.polygons.length) throw new Error(`${meshId} has non-exact voxel polygons`);
-  return { preset, items };
-}
-
-function pointInConvex(point, poly) {
-  let sign = 0;
-  for (let i = 0; i < poly.length; i += 1) {
-    const a = poly[i];
-    const b = poly[(i + 1) % poly.length];
-    const cross = (b.x - a.x) * (point.y - a.y) - (b.y - a.y) * (point.x - a.x);
-    const nextSign = Math.sign(cross);
-    if (nextSign === 0) continue;
-    if (sign === 0) sign = nextSign;
-    else if (sign !== nextSign) return false;
-  }
-  return true;
-}
-
-function estimateAtAngle(items, rotX, rotY) {
-  const signature = visibleFaceSignature(rotX, rotY);
-  const visibleFaces = new Set(signature.split("|").filter(Boolean));
-  const projected = items
-    .filter((item) => visibleFaces.has(item.face))
-    .map((item) => {
-      const points = itemCorners(item).map((corner) => {
-        const [x, y, z] = rotateVec3(corner, rotX, 0, rotY);
-        return { x, y, z };
-      });
-      return {
-        item,
-        points,
-        depth: points.reduce((sum, point) => sum + point.z, 0) / points.length,
-        minX: Math.min(...points.map((point) => point.x)),
-        maxX: Math.max(...points.map((point) => point.x)),
-        minY: Math.min(...points.map((point) => point.y)),
-        maxY: Math.max(...points.map((point) => point.y)),
-      };
-    });
-  if (!projected.length) return { signature, active: 0, kept: 0, culled: 0, cullRatio: 0 };
-
-  const minX = Math.min(...projected.map((entry) => entry.minX));
-  const maxX = Math.max(...projected.map((entry) => entry.maxX));
-  const minY = Math.min(...projected.map((entry) => entry.minY));
-  const maxY = Math.max(...projected.map((entry) => entry.maxY));
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const occupied = new Uint8Array(GRID_W * GRID_H);
-  let kept = 0;
-  let culled = 0;
-
-  const sorted = projected.sort((a, b) => b.depth - a.depth || a.item.sourceIndex - b.item.sourceIndex);
-  for (const entry of sorted) {
-    const gx0 = Math.max(0, Math.floor(((entry.minX - minX) / spanX) * GRID_W));
-    const gx1 = Math.min(GRID_W - 1, Math.ceil(((entry.maxX - minX) / spanX) * GRID_W));
-    const gy0 = Math.max(0, Math.floor(((entry.minY - minY) / spanY) * GRID_H));
-    const gy1 = Math.min(GRID_H - 1, Math.ceil(((entry.maxY - minY) / spanY) * GRID_H));
-    let hasPixel = false;
-    const cells = [];
-    for (let gy = gy0; gy <= gy1; gy += 1) {
-      const y = minY + ((gy + 0.5) / GRID_H) * spanY;
-      for (let gx = gx0; gx <= gx1; gx += 1) {
-        const x = minX + ((gx + 0.5) / GRID_W) * spanX;
-        if (!pointInConvex({ x, y }, entry.points)) continue;
-        const index = gy * GRID_W + gx;
-        cells.push(index);
-        if (!occupied[index]) hasPixel = true;
-      }
-    }
-    if (!hasPixel) {
-      culled += 1;
-      continue;
-    }
-    kept += 1;
-    for (const index of cells) occupied[index] = 1;
-  }
-
-  return {
-    signature,
-    active: projected.length,
-    kept,
-    culled,
-    cullRatio: projected.length ? culled / projected.length : 0,
-  };
-}
-
-function summarize(rows) {
-  const active = rows.map((row) => row.active);
-  const kept = rows.map((row) => row.kept);
-  const culled = rows.map((row) => row.culled);
-  const ratios = rows.map((row) => row.cullRatio);
-  return {
-    active_p50: quantile(active, 0.5),
-    kept_p50: quantile(kept, 0.5),
-    culled_p50: quantile(culled, 0.5),
-    cullRatio_p50: quantile(ratios, 0.5),
-    cullRatio_p95: quantile(ratios, 0.95),
-  };
-}
-
-const results = [];
-for (const mesh of MESHES) {
-  const { preset, items } = await loadItems(mesh);
-  const angles = [];
-  for (let offset = 0; offset < 360; offset += ANGLE_STEP) {
-    angles.push((preset.rotY + offset) % 360);
-  }
-  const rows = angles.map((rotY) => ({
-    mesh,
-    rotX: preset.rotX,
-    rotY,
-    ...estimateAtAngle(items, preset.rotX, rotY),
-  }));
-  const summary = summarize(rows);
-  results.push({ mesh, grid: [GRID_W, GRID_H], angleStep: ANGLE_STEP, summary, rows });
-}
-
-console.log("| Mesh | Active p50 | Kept p50 | Culled p50 | Cull p50 | Cull p95 |");
-console.log("| --- | ---: | ---: | ---: | ---: | ---: |");
-for (const result of results) {
-  console.log([
-    `| ${result.mesh}`,
-    result.summary.active_p50.toFixed(0),
-    result.summary.kept_p50.toFixed(0),
-    result.summary.culled_p50.toFixed(0),
-    `${(result.summary.cullRatio_p50 * 100).toFixed(1)}%`,
-    `${(result.summary.cullRatio_p95 * 100).toFixed(1)}% |`,
-  ].join(" | "));
-}
-
-if (LABEL) {
-  await mkdir(resultDir, { recursive: true });
-  const path = join(resultDir, `${LABEL}.json`);
-  await writeFile(path, `${JSON.stringify({
-    generatedAt: new Date().toISOString(),
-    meshes: MESHES,
-    angleStep: ANGLE_STEP,
-    grid: [GRID_W, GRID_H],
-    results,
-  }, null, 2)}\n`);
-  console.log(`Wrote ${path}`);
-}
diff --git a/bench/voxel-order-metrics.mjs b/bench/voxel-order-metrics.mjs
deleted file mode 100644
index 35baca38..00000000
--- a/bench/voxel-order-metrics.mjs
+++ /dev/null
@@ -1,767 +0,0 @@
-#!/usr/bin/env node
-import { readFile, readdir, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-} from "../packages/core/dist/index.js";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const galleryVoxDir = resolve(repoRoot, "website/public/gallery/vox");
-const resultDir = resolve(repoRoot, "bench/results");
-const benchResultPrefix = process.env.BENCH_RESULT_PREFIX ?? "";
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_ORDER_INDEX = Object.fromEntries(FACE_ORDER.map((face, index) => [face, index]));
-const TOP_REVERSE_ORDER = ["t", "b", "fl", "fr", "br", "bl"];
-
-function sourceBlockDepthOrder(items, rotY, blockSize, front) {
-  const blocks = new Map();
-  for (const item of items) {
-    const blockIndex = Math.floor(item.sourceIndex / blockSize);
-    const block = blocks.get(blockIndex) ?? { blockIndex, items: [], depthSum: 0 };
-    block.items.push(item);
-    block.depthSum += itemViewDepth(item, rotY);
-    blocks.set(blockIndex, block);
-  }
-  return [...blocks.values()]
-    .map((block) => ({ ...block, avgDepth: block.depthSum / block.items.length }))
-    .sort((a, b) => {
-      const delta = a.avgDepth - b.avgDepth;
-      return (front ? delta : -delta) || a.blockIndex - b.blockIndex;
-    })
-    .flatMap((block) => block.items);
-}
-
-function projectedCenter(item, rotY) {
-  const point = projectPoint(itemCenter(item), rotY);
-  return { x: point.x, y: point.y };
-}
-
-function tileScanlineOrder(items, rotY, tileCount) {
-  const entries = items.map((item) => ({ item, ...projectedCenter(item, rotY) }));
-  if (entries.length === 0) return [];
-  const minX = Math.min(...entries.map((entry) => entry.x));
-  const maxX = Math.max(...entries.map((entry) => entry.x));
-  const minY = Math.min(...entries.map((entry) => entry.y));
-  const maxY = Math.max(...entries.map((entry) => entry.y));
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.x - minX) / spanX) * tileCount)));
-    const ty = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.y - minY) / spanY) * tileCount)));
-    const key = `${tx}:${ty}`;
-    const tile = tiles.get(key) ?? { tx, ty, sourceIndex: entry.item.sourceIndex, items: [] };
-    tile.items.push(entry.item);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-    tiles.set(key, tile);
-  }
-  return [...tiles.values()]
-    .sort((a, b) => (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex)
-    .flatMap((tile) => tile.items);
-}
-
-const STRATEGIES = [
-  {
-    key: "tile4",
-    caseId: "polycss-voxlocal-direct-matrix-tile4-scanline-forward",
-    label: "Tile4 scanline",
-    order(items, rotY) {
-      return tileScanlineOrder(items, rotY, 4);
-    },
-  },
-  {
-    key: "exact",
-    caseId: "polycss-voxlocal-direct-matrix-exact",
-    label: "Exact parsed",
-    order(items) {
-      return items;
-    },
-  },
-  {
-    key: "face",
-    caseId: "polycss-voxlocal-direct-matrix-face-order",
-    label: "Face order",
-    order(items) {
-      return [...items].sort((a, b) =>
-        FACE_ORDER_INDEX[a.face] - FACE_ORDER_INDEX[b.face] || a.sourceIndex - b.sourceIndex
-      );
-    },
-  },
-  {
-    key: "topRev",
-    caseId: "polycss-voxlocal-direct-matrix-face-order-top-reverse",
-    label: "Top reverse",
-    order(items) {
-      const index = Object.fromEntries(TOP_REVERSE_ORDER.map((face, i) => [face, i]));
-      return [...items].sort((a, b) => index[a.face] - index[b.face] || a.sourceIndex - b.sourceIndex);
-    },
-  },
-  {
-    key: "normalF",
-    caseId: "polycss-voxlocal-direct-matrix-face-normal-front",
-    label: "Normal front",
-    order(items, rotY) {
-      const faces = [...new Set(items.map((item) => item.face))]
-        .sort((a, b) => faceCameraDepth(a, rotY) - faceCameraDepth(b, rotY));
-      const index = Object.fromEntries(faces.map((face, i) => [face, i]));
-      return [...items].sort((a, b) => index[a.face] - index[b.face] || a.sourceIndex - b.sourceIndex);
-    },
-  },
-  {
-    key: "normalB",
-    caseId: "polycss-voxlocal-direct-matrix-face-normal-back",
-    label: "Normal back",
-    order(items, rotY) {
-      const faces = [...new Set(items.map((item) => item.face))]
-        .sort((a, b) => faceCameraDepth(b, rotY) - faceCameraDepth(a, rotY));
-      const index = Object.fromEntries(faces.map((face, i) => [face, i]));
-      return [...items].sort((a, b) => index[a.face] - index[b.face] || a.sourceIndex - b.sourceIndex);
-    },
-  },
-  {
-    key: "depthF",
-    caseId: "polycss-voxlocal-direct-matrix-depth-front",
-    label: "Depth front",
-    order(items, rotY) {
-      return [...items].sort((a, b) => itemViewDepth(a, rotY) - itemViewDepth(b, rotY));
-    },
-  },
-  {
-    key: "depthB",
-    caseId: "polycss-voxlocal-direct-matrix-depth-back",
-    label: "Depth back",
-    order(items, rotY) {
-      return [...items].sort((a, b) => itemViewDepth(b, rotY) - itemViewDepth(a, rotY));
-    },
-  },
-  ...[32, 64, 128, 256].flatMap((blockSize) => [
-    {
-      key: `block${blockSize}F`,
-      caseId: `polycss-voxlocal-direct-matrix-source-block${blockSize}-depth-front`,
-      label: `Block ${blockSize} front`,
-      order(items, rotY) {
-        return sourceBlockDepthOrder(items, rotY, blockSize, true);
-      },
-    },
-    {
-      key: `block${blockSize}B`,
-      caseId: `polycss-voxlocal-direct-matrix-source-block${blockSize}-depth-back`,
-      label: `Block ${blockSize} back`,
-      order(items, rotY) {
-        return sourceBlockDepthOrder(items, rotY, blockSize, false);
-      },
-    },
-  ]),
-];
-
-const HARD_SPLIT_MODELS = [
-  "obj_house3.vox",
-  "obj_house5.vox",
-  "desert2.vox",
-  "house.vox",
-  "scene_mechanic2.vox",
-  "Treasure.vox",
-  "army.vox",
-  "AncientCrashSite.vox",
-  "skyscraper.vox",
-];
-
-const args = parseArgs(process.argv.slice(2));
-const angleStep = Number(args.angleStep ?? process.env.ANGLE_STEP ?? 15);
-const targetSize = Number(args.targetSize ?? process.env.POLY_TARGET_SIZE ?? 70);
-const models = args.models.length ? args.models : HARD_SPLIT_MODELS;
-const selectedStrategies = args.strategies.length
-  ? STRATEGIES.filter((strategy) => args.strategies.includes(strategy.key))
-  : STRATEGIES;
-
-function parseArgs(argv) {
-  const out = {
-    models: [],
-    strategies: [],
-    angleStep: null,
-    targetSize: null,
-  };
-  for (const arg of argv) {
-    if (arg.startsWith("--angle-step=")) {
-      out.angleStep = arg.slice("--angle-step=".length);
-    } else if (arg.startsWith("--target-size=")) {
-      out.targetSize = arg.slice("--target-size=".length);
-    } else if (arg.startsWith("--strategies=")) {
-      out.strategies = arg.slice("--strategies=".length).split(",").map((value) => value.trim()).filter(Boolean);
-    } else if (arg.startsWith("--models=")) {
-      out.models.push(...arg.slice("--models=".length).split(",").map((value) => value.trim()).filter(Boolean));
-    } else if (!arg.startsWith("--")) {
-      out.models.push(arg);
-    }
-  }
-  return out;
-}
-
-function canonicalModelKey(file) {
-  return basename(file, ".vox").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-function benchmarkResultSlug(file) {
-  return basename(file).replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function exactMatrixItemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const eps = 1e-6;
-  const base = { face, sourceIndex };
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function projectPoint(point, rotY) {
-  const rz = (rotY * Math.PI) / 180;
-  const rx = (65 * Math.PI) / 180;
-  const cosZ = Math.cos(rz);
-  const sinZ = Math.sin(rz);
-  const cosX = Math.cos(rx);
-  const sinX = Math.sin(rx);
-  const [x, y, z] = point;
-  const x1 = x * cosZ - y * sinZ;
-  const y1 = x * sinZ + y * cosZ;
-  return {
-    x: x1,
-    y: y1 * cosX - z * sinX,
-    z: y1 * sinX + z * cosX,
-  };
-}
-
-function itemViewDepth(item, rotY) {
-  return projectPoint(itemCenter(item), rotY).z;
-}
-
-function faceCameraDepth(face, rotY) {
-  const normal = FACE_NORMALS[face];
-  return projectPoint(normal, rotY).z;
-}
-
-function polygonArea2(points) {
-  let sum = 0;
-  for (let i = 0; i < points.length; i += 1) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    sum += a.x * b.y - b.x * a.y;
-  }
-  return Math.abs(sum) / 2;
-}
-
-function planeFromProjected(points) {
-  const [a, b, c] = points;
-  const ux = b.x - a.x;
-  const uy = b.y - a.y;
-  const uz = b.z - a.z;
-  const vx = c.x - a.x;
-  const vy = c.y - a.y;
-  const vz = c.z - a.z;
-  const nx = uy * vz - uz * vy;
-  const ny = uz * vx - ux * vz;
-  const nz = ux * vy - uy * vx;
-  if (Math.abs(nz) <= 1e-9) return null;
-  return {
-    a: -nx / nz,
-    b: -ny / nz,
-    c: (nx * a.x + ny * a.y + nz * a.z) / nz,
-  };
-}
-
-function planeZ(plane, x, y, fallback) {
-  return plane ? plane.a * x + plane.b * y + plane.c : fallback;
-}
-
-function projectedItem(item, order, rotY) {
-  const points = itemCorners(item).map((point) => projectPoint(point, rotY));
-  const minX = Math.min(...points.map((point) => point.x));
-  const maxX = Math.max(...points.map((point) => point.x));
-  const minY = Math.min(...points.map((point) => point.y));
-  const maxY = Math.max(...points.map((point) => point.y));
-  const depth = points.reduce((sum, point) => sum + point.z, 0) / points.length;
-  return {
-    item,
-    order,
-    points,
-    minX,
-    maxX,
-    minY,
-    maxY,
-    depth,
-    area2d: polygonArea2(points),
-    boundsArea2d: Math.max(0, maxX - minX) * Math.max(0, maxY - minY),
-    plane: planeFromProjected(points),
-  };
-}
-
-class DisjointSet {
-  constructor(size) {
-    this.parent = Array.from({ length: size }, (_, index) => index);
-    this.size = Array.from({ length: size }, () => 1);
-  }
-
-  find(index) {
-    let root = index;
-    while (this.parent[root] !== root) root = this.parent[root];
-    while (this.parent[index] !== index) {
-      const parent = this.parent[index];
-      this.parent[index] = root;
-      index = parent;
-    }
-    return root;
-  }
-
-  union(a, b) {
-    let rootA = this.find(a);
-    let rootB = this.find(b);
-    if (rootA === rootB) return;
-    if (this.size[rootA] < this.size[rootB]) [rootA, rootB] = [rootB, rootA];
-    this.parent[rootB] = rootA;
-    this.size[rootA] += this.size[rootB];
-  }
-}
-
-function analyzeProjected(projected) {
-  const sorted = projected
-    .map((item, index) => ({ ...item, index }))
-    .sort((a, b) => a.minX - b.minX);
-  const dsu = new DisjointSet(projected.length);
-  const active = [];
-  let overlapPairs = 0;
-  let overlapArea = 0;
-  let invAsc = 0;
-  let invDesc = 0;
-  let depthTies = 0;
-  let crossings = 0;
-
-  for (const current of sorted) {
-    for (let i = active.length - 1; i >= 0; i -= 1) {
-      if (active[i].maxX <= current.minX) active.splice(i, 1);
-    }
-    for (const other of active) {
-      if (other.maxY <= current.minY || other.minY >= current.maxY) continue;
-      const x0 = Math.max(current.minX, other.minX);
-      const x1 = Math.min(current.maxX, other.maxX);
-      const y0 = Math.max(current.minY, other.minY);
-      const y1 = Math.min(current.maxY, other.maxY);
-      if (x1 <= x0 || y1 <= y0) continue;
-      overlapPairs += 1;
-      overlapArea += (x1 - x0) * (y1 - y0);
-      dsu.union(current.index, other.index);
-
-      const orderDelta = current.order - other.order;
-      const depthDelta = current.depth - other.depth;
-      if (Math.abs(depthDelta) <= 0.5) {
-        depthTies += 1;
-      } else {
-        if ((orderDelta < 0) !== (depthDelta < 0)) invAsc += 1;
-        if ((orderDelta < 0) !== (depthDelta > 0)) invDesc += 1;
-      }
-
-      const samples = [
-        [(x0 + x1) / 2, (y0 + y1) / 2],
-        [x0, y0],
-        [x1, y0],
-        [x1, y1],
-        [x0, y1],
-      ];
-      let sawPositive = false;
-      let sawNegative = false;
-      for (const [x, y] of samples) {
-        const dz = planeZ(current.plane, x, y, current.depth) - planeZ(other.plane, x, y, other.depth);
-        if (dz > 0.5) sawPositive = true;
-        else if (dz < -0.5) sawNegative = true;
-      }
-      if (sawPositive && sawNegative) crossings += 1;
-    }
-    active.push(current);
-  }
-
-  const minX = Math.min(...projected.map((item) => item.minX));
-  const maxX = Math.max(...projected.map((item) => item.maxX));
-  const minY = Math.min(...projected.map((item) => item.minY));
-  const maxY = Math.max(...projected.map((item) => item.maxY));
-  const screenArea = Math.max(1e-6, (maxX - minX) * (maxY - minY));
-  const boundsAreaSum = projected.reduce((sum, item) => sum + item.boundsArea2d, 0);
-  const quadAreaSum = projected.reduce((sum, item) => sum + item.area2d, 0);
-
-  let largestComponent = 0;
-  const componentSizes = new Map();
-  for (let i = 0; i < projected.length; i += 1) {
-    const root = dsu.find(i);
-    const size = (componentSizes.get(root) ?? 0) + 1;
-    componentSizes.set(root, size);
-    largestComponent = Math.max(largestComponent, size);
-  }
-
-  let faceSwitches = 0;
-  let depthJump = 0;
-  let sourceJump = 0;
-  const orderSorted = [...projected].sort((a, b) => a.order - b.order);
-  for (let i = 1; i < orderSorted.length; i += 1) {
-    const prev = orderSorted[i - 1];
-    const next = orderSorted[i];
-    if (prev.item.face !== next.item.face) faceSwitches += 1;
-    depthJump += Math.abs(prev.depth - next.depth);
-    sourceJump += Math.abs(prev.item.sourceIndex - next.item.sourceIndex);
-  }
-
-  return {
-    activeLeaves: projected.length,
-    screenArea,
-    boundsAreaSum,
-    quadAreaSum,
-    projectedBoundsFill: boundsAreaSum / screenArea,
-    projectedQuadFill: quadAreaSum / screenArea,
-    overlapPairs,
-    overlapArea,
-    invAsc,
-    invDesc,
-    depthTies,
-    crossings,
-    componentCount: componentSizes.size,
-    largestComponent,
-    faceSwitches,
-    depthJumpMean: orderSorted.length > 1 ? depthJump / (orderSorted.length - 1) : 0,
-    sourceJumpMean: orderSorted.length > 1 ? sourceJump / (orderSorted.length - 1) : 0,
-  };
-}
-
-function mergeMetricRows(rows) {
-  const total = {
-    samples: rows.length,
-    activeLeaves: 0,
-    screenAreaMedian: median(rows.map((row) => row.screenArea)),
-    projectedBoundsFillMedian: median(rows.map((row) => row.projectedBoundsFill)),
-    projectedQuadFillMedian: median(rows.map((row) => row.projectedQuadFill)),
-    overlapPairs: 0,
-    overlapArea: 0,
-    invAsc: 0,
-    invDesc: 0,
-    depthTies: 0,
-    crossings: 0,
-    largestComponentMax: 0,
-    largestComponentMedian: median(rows.map((row) => row.largestComponent)),
-    componentCountMedian: median(rows.map((row) => row.componentCount)),
-    faceSwitchesMedian: median(rows.map((row) => row.faceSwitches)),
-    depthJumpMeanMedian: median(rows.map((row) => row.depthJumpMean)),
-    sourceJumpMeanMedian: median(rows.map((row) => row.sourceJumpMean)),
-  };
-  for (const row of rows) {
-    total.activeLeaves += row.activeLeaves;
-    total.overlapPairs += row.overlapPairs;
-    total.overlapArea += row.overlapArea;
-    total.invAsc += row.invAsc;
-    total.invDesc += row.invDesc;
-    total.depthTies += row.depthTies;
-    total.crossings += row.crossings;
-    total.largestComponentMax = Math.max(total.largestComponentMax, row.largestComponent);
-  }
-  total.activeLeavesMedian = median(rows.map((row) => row.activeLeaves));
-  total.overlapPairsPerLeaf = total.activeLeaves ? total.overlapPairs / total.activeLeaves : 0;
-  total.invAscRate = total.overlapPairs ? total.invAsc / total.overlapPairs : 0;
-  total.invDescRate = total.overlapPairs ? total.invDesc / total.overlapPairs : 0;
-  total.tieRate = total.overlapPairs ? total.depthTies / total.overlapPairs : 0;
-  total.crossingRate = total.overlapPairs ? total.crossings / total.overlapPairs : 0;
-  total.minDepthInvRate = Math.min(total.invAscRate, total.invDescRate);
-  return total;
-}
-
-function visibleItems(items, rotY) {
-  const visibleFaces = new Set(
-    Object.entries(FACE_NORMALS)
-      .filter(([, normal]) => normalFacesCamera(normal, { rotX: 65, rotY }, 0.001))
-      .map(([face]) => face)
-  );
-  return items.filter((item) => visibleFaces.has(item.face));
-}
-
-async function findModelPath(model) {
-  if (model.includes("/") || model.includes("\\")) return resolve(repoRoot, model);
-  const direct = resolve(galleryVoxDir, model);
-  try {
-    await readFile(direct);
-    return direct;
-  } catch {
-    const files = await readdir(galleryVoxDir);
-    const needle = model.toLowerCase().replace(/\.vox$/, "");
-    const match = files.find((file) => file.toLowerCase().replace(/\.vox$/, "") === needle);
-    if (!match) throw new Error(`Could not find model ${model}`);
-    return join(galleryVoxDir, match);
-  }
-}
-
-async function loadBenchResult(modelFile) {
-  const slug = benchmarkResultSlug(modelFile);
-  const path = join(resultDir, `${benchResultPrefix}${slug}-rotation-compare.json`);
-  try {
-    const data = JSON.parse(await readFile(path, "utf8"));
-    const out = {};
-    for (const strategy of STRATEGIES) {
-      const runs = data.cases?.[strategy.caseId]?.runs ?? [];
-      out[strategy.key] = runs.length
-        ? {
-            runs: runs.length,
-            fpsP95: median(runs.map((run) => run.fps_p95)),
-            frameP99: median(runs.map((run) => run.frame_time_p99_ms)),
-          }
-        : null;
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-async function analyzeModel(model) {
-  const path = await findModelPath(model);
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize, gridShift: 0 },
-  );
-  const items = parsed.polygons
-    .map((polygon, sourceIndex) => exactMatrixItemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-  const angles = [];
-  for (let offset = 0; offset < 360; offset += angleStep) angles.push(45 + offset);
-  const bench = await loadBenchResult(path);
-  const strategyRows = [];
-  for (const strategy of selectedStrategies) {
-    const angleRows = [];
-    for (const rotY of angles) {
-      const currentVisible = visibleItems(items, rotY);
-      const ordered = strategy.order(currentVisible, rotY);
-      const projected = ordered.map((item, index) => projectedItem(item, index, rotY));
-      angleRows.push({ rotY, ...analyzeProjected(projected) });
-    }
-    strategyRows.push({
-      key: strategy.key,
-      label: strategy.label,
-      caseId: strategy.caseId,
-      bench: bench[strategy.key] ?? null,
-      metrics: mergeMetricRows(angleRows),
-      angles: angleRows,
-    });
-  }
-  return {
-    model: basename(path),
-    key: canonicalModelKey(path),
-    targetSize,
-    angleStep,
-    polygons: parsed.polygons.length,
-    exactItems: items.length,
-    strategies: strategyRows,
-  };
-}
-
-function renderMarkdown(rows) {
-  const lines = [];
-  lines.push("# Voxel Order Metrics");
-  lines.push("");
-  lines.push(`Target size: ${targetSize}`);
-  lines.push(`Angle step: ${angleStep}`);
-  lines.push("");
-  for (const row of rows) {
-    lines.push(`## ${row.model}`);
-    lines.push("");
-    lines.push(`Polygons: ${row.polygons}; exact matrix items: ${row.exactItems}`);
-    lines.push("");
-    lines.push("| Strategy | Runs | FPS p95 | Frame p99 | Active | Bounds fill | Quad fill | Overlap/leaf | Min inv % | Asc inv % | Desc inv % | Cross % | Tie % | Max comp | Face switches | Depth jump |");
-    lines.push("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-    for (const strategy of row.strategies) {
-      const m = strategy.metrics;
-      const b = strategy.bench;
-      lines.push([
-        `| ${strategy.label}`,
-        b?.runs ?? "",
-        fmt(b?.fpsP95),
-        fmt(b?.frameP99),
-        fmt(m.activeLeavesMedian, 0),
-        fmt(m.projectedBoundsFillMedian, 2),
-        fmt(m.projectedQuadFillMedian, 2),
-        fmt(m.overlapPairsPerLeaf, 2),
-        fmt(m.minDepthInvRate * 100, 2),
-        fmt(m.invAscRate * 100, 2),
-        fmt(m.invDescRate * 100, 2),
-        fmt(m.crossingRate * 100, 2),
-        fmt(m.tieRate * 100, 2),
-        fmt(m.largestComponentMax, 0),
-        fmt(m.faceSwitchesMedian, 0),
-        `${fmt(m.depthJumpMeanMedian, 1)} |`,
-      ].join(" | "));
-    }
-    lines.push("");
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-const rows = [];
-for (const model of models) {
-  console.log(`[voxel-order-metrics] analyzing ${model}`);
-  rows.push(await analyzeModel(model));
-}
-
-const jsonPath = join(resultDir, "voxel-order-metrics.json");
-const mdPath = join(resultDir, "voxel-order-metrics.md");
-await writeFile(jsonPath, JSON.stringify({
-  generatedAt: new Date().toISOString(),
-  targetSize,
-  angleStep,
-  models: rows,
-}, null, 2));
-await writeFile(mdPath, renderMarkdown(rows));
-
-console.log(`[voxel-order-metrics] wrote ${jsonPath}`);
-console.log(`[voxel-order-metrics] wrote ${mdPath}`);
diff --git a/bench/voxel-order-phase-metrics.mjs b/bench/voxel-order-phase-metrics.mjs
deleted file mode 100644
index 8c816a4c..00000000
--- a/bench/voxel-order-phase-metrics.mjs
+++ /dev/null
@@ -1,598 +0,0 @@
-#!/usr/bin/env node
-import { readFile, readdir, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  normalFacesCamera,
-  parseVox,
-  rotateVec3,
-} from "../packages/core/dist/index.js";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const galleryVoxDir = resolve(repoRoot, "website/public/gallery/vox");
-const resultDir = resolve(repoRoot, "bench/results");
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_ORDER = ["t", "b", "bl", "br", "fr", "fl"];
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const DEFAULT_MODELS = [
-  "Garden.vox",
-  "desert2.vox",
-  "scene_mechanic2.vox",
-  "obj_house3.vox",
-  "Treasure.vox",
-  "skyscraper.vox",
-  "AncientCrashSite.vox",
-  "army.vox",
-];
-
-const args = parseArgs(process.argv.slice(2));
-const angleStep = Number(args.angleStep ?? 5);
-const targetSize = Number(args.targetSize ?? 60);
-const models = args.models.length ? args.models : DEFAULT_MODELS;
-
-const STRATEGIES = [
-  { key: "baseline", label: "Current", phase(rotation, signature) { return rotation; } },
-  { key: "offset30", label: "+30deg", phase(rotation) { return { ...rotation, rotY: rotation.rotY + 30 }; } },
-  {
-    key: "center",
-    label: "Centered interval",
-    phase(rotation, signature) {
-      return intervalPhase(rotation, signature, 0.5);
-    },
-  },
-  {
-    key: "frac033",
-    label: "Interval 0.33",
-    phase(rotation, signature) {
-      return intervalPhase(rotation, signature, 0.33);
-    },
-  },
-  {
-    key: "frac067",
-    label: "Interval 0.67",
-    phase(rotation, signature) {
-      return intervalPhase(rotation, signature, 0.67);
-    },
-  },
-];
-
-function parseArgs(argv) {
-  const out = { models: [], angleStep: null, targetSize: null };
-  for (const arg of argv) {
-    if (arg.startsWith("--angle-step=")) out.angleStep = arg.slice("--angle-step=".length);
-    else if (arg.startsWith("--target-size=")) out.targetSize = arg.slice("--target-size=".length);
-    else if (arg.startsWith("--models=")) {
-      out.models.push(...arg.slice("--models=".length).split(",").map((value) => value.trim()).filter(Boolean));
-    } else if (!arg.startsWith("--")) {
-      out.models.push(arg);
-    }
-  }
-  return out;
-}
-
-function canonicalModelKey(file) {
-  return basename(file, ".vox").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 2) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function matrixItemForPolygon(polygon, sourceIndex) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const base = { face, sourceIndex };
-  const eps = 1e-6;
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      ...base,
-      axis: "z",
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      ...base,
-      axis: "x",
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      ...base,
-      axis: "y",
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-    };
-  }
-  return null;
-}
-
-function itemCenter(item) {
-  if (item.axis === "x") return [item.left + item.width / 2, -item.z, item.top + item.height / 2];
-  if (item.axis === "y") return [-item.z, item.top + item.height / 2, item.left + item.width / 2];
-  return [item.left + item.width / 2, item.top + item.height / 2, item.z];
-}
-
-function itemCorners(item) {
-  if (item.axis === "x") {
-    return [
-      [item.left, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top],
-      [item.left + item.width, -item.z, item.top + item.height],
-      [item.left, -item.z, item.top + item.height],
-    ];
-  }
-  if (item.axis === "y") {
-    return [
-      [-item.z, item.top, item.left],
-      [-item.z, item.top, item.left + item.width],
-      [-item.z, item.top + item.height, item.left + item.width],
-      [-item.z, item.top + item.height, item.left],
-    ];
-  }
-  return [
-    [item.left, item.top, item.z],
-    [item.left + item.width, item.top, item.z],
-    [item.left + item.width, item.top + item.height, item.z],
-    [item.left, item.top + item.height, item.z],
-  ];
-}
-
-function projectPoint(point, rotation) {
-  const [x, y, z] = rotateVec3(point, rotation.rotX, 0, rotation.rotY);
-  return { x, y, z };
-}
-
-function projectedPoint(item, rotation) {
-  const [x, y] = rotateVec3(itemCenter(item), rotation.rotX, 0, rotation.rotY);
-  return { x, y };
-}
-
-function projectedBounds(item, rotation) {
-  const points = itemCorners(item).map((point) => projectPoint(point, rotation));
-  return {
-    minX: Math.min(...points.map((point) => point.x)),
-    maxX: Math.max(...points.map((point) => point.x)),
-    minY: Math.min(...points.map((point) => point.y)),
-    maxY: Math.max(...points.map((point) => point.y)),
-    depth: points.reduce((sum, point) => sum + point.z, 0) / points.length,
-    area: Math.abs(item.width * item.height),
-    primitive: Math.max(item.width, item.height),
-  };
-}
-
-function visibleFaceSignature(rotation) {
-  const visible = [];
-  for (const face of FACE_ORDER) {
-    if (normalFacesCamera(FACE_NORMALS[face], rotation)) visible.push(face);
-  }
-  return visible.join("|");
-}
-
-function visibleItems(items, rotation) {
-  const visibleFaces = new Set(visibleFaceSignature(rotation).split("|").filter(Boolean));
-  return items.filter((item) => visibleFaces.has(item.face));
-}
-
-function intervalPhase(rotation, signature, fraction) {
-  const matches = [];
-  for (let offset = -180; offset <= 180; offset += 1) {
-    const candidate = { ...rotation, rotY: rotation.rotY + offset };
-    if (visibleFaceSignature(candidate) === signature) matches.push(offset);
-  }
-  const zeroIndex = matches.indexOf(0);
-  if (zeroIndex < 0) return rotation;
-  let start = zeroIndex;
-  let end = zeroIndex;
-  while (start > 0 && matches[start] - matches[start - 1] === 1) start -= 1;
-  while (end + 1 < matches.length && matches[end + 1] - matches[end] === 1) end += 1;
-  const offset = matches[start] + (matches[end] - matches[start]) * fraction;
-  return { ...rotation, rotY: rotation.rotY + offset };
-}
-
-function tileOrder(items, orderRotation) {
-  const entries = items.map((item) => ({ item, ...projectedPoint(item, orderRotation) }));
-  if (entries.length === 0) return [];
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const entry of entries) {
-    minX = Math.min(minX, entry.x);
-    maxX = Math.max(maxX, entry.x);
-    minY = Math.min(minY, entry.y);
-    maxY = Math.max(maxY, entry.y);
-  }
-  const tileCount = 4;
-  const spanX = Math.max(1e-6, maxX - minX);
-  const spanY = Math.max(1e-6, maxY - minY);
-  const tiles = new Map();
-  for (const entry of entries) {
-    const tx = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.x - minX) / spanX) * tileCount)));
-    const ty = Math.min(tileCount - 1, Math.max(0, Math.floor(((entry.y - minY) / spanY) * tileCount)));
-    const key = `${tx}:${ty}`;
-    let tile = tiles.get(key);
-    if (!tile) {
-      tile = { tx, ty, sourceIndex: entry.item.sourceIndex, items: [] };
-      tiles.set(key, tile);
-    }
-    tile.items.push(entry.item);
-    tile.sourceIndex = Math.min(tile.sourceIndex, entry.item.sourceIndex);
-  }
-  return [...tiles.values()]
-    .sort((a, b) => (a.ty - b.ty) || (a.tx - b.tx) || a.sourceIndex - b.sourceIndex)
-    .flatMap((tile) => tile.items);
-}
-
-function orderRanks(ordered) {
-  const ranks = new Map();
-  ordered.forEach((item, index) => ranks.set(item.sourceIndex, index));
-  return ranks;
-}
-
-function overlapPairs(items, actualRotation) {
-  const projected = items.map((item) => ({ item, ...projectedBounds(item, actualRotation) }));
-  const sorted = projected
-    .map((entry, index) => ({ ...entry, index }))
-    .sort((a, b) => a.minX - b.minX);
-  const active = [];
-  const pairs = [];
-  for (const current of sorted) {
-    for (let i = active.length - 1; i >= 0; i -= 1) {
-      if (active[i].maxX <= current.minX) active.splice(i, 1);
-    }
-    for (const other of active) {
-      if (other.maxY <= current.minY || other.minY >= current.maxY) continue;
-      const x0 = Math.max(current.minX, other.minX);
-      const x1 = Math.min(current.maxX, other.maxX);
-      const y0 = Math.max(current.minY, other.minY);
-      const y1 = Math.min(current.maxY, other.maxY);
-      if (x1 <= x0 || y1 <= y0) continue;
-      const overlapArea = (x1 - x0) * (y1 - y0);
-      pairs.push({
-        a: current,
-        b: other,
-        overlapArea,
-        maxPrimitive: Math.max(current.primitive, other.primitive),
-        maxArea: Math.max(current.area, other.area),
-        depthDelta: current.depth - other.depth,
-      });
-    }
-    active.push(current);
-  }
-  return pairs;
-}
-
-function pairSign(pair, ranks) {
-  const a = ranks.get(pair.a.item.sourceIndex);
-  const b = ranks.get(pair.b.item.sourceIndex);
-  if (!Number.isFinite(a) || !Number.isFinite(b) || a === b) return 0;
-  return a < b ? -1 : 1;
-}
-
-function summarize(values) {
-  return {
-    median: median(values),
-    p90: quantile(values, 0.9),
-    p95: quantile(values, 0.95),
-    max: values.length ? Math.max(...values) : null,
-  };
-}
-
-function analyzePhaseForAngle(items, actualRotation, strategy) {
-  const signature = visibleFaceSignature(actualRotation);
-  const visible = visibleItems(items, actualRotation);
-  const baselineOrder = tileOrder(visible, actualRotation);
-  const strategyOrder = tileOrder(visible, strategy.phase(actualRotation, signature));
-  const baselineRanks = orderRanks(baselineOrder);
-  const strategyRanks = orderRanks(strategyOrder);
-  const pairs = overlapPairs(visible, actualRotation);
-  let changedPairs = 0;
-  let changedArea = 0;
-  let changedHugePairs = 0;
-  let changedHugeArea = 0;
-  let depthAscBad = 0;
-  let depthDescBad = 0;
-  let depthAscArea = 0;
-  let depthDescArea = 0;
-  let changedDepthAscBad = 0;
-  let changedDepthDescBad = 0;
-  let changedDepthAscArea = 0;
-  let changedDepthDescArea = 0;
-  let totalArea = 0;
-  const movedDistances = [];
-  const movedPrimitives = [];
-  const movedAreas = [];
-
-  for (const item of visible) {
-    const baselineRank = baselineRanks.get(item.sourceIndex);
-    const strategyRank = strategyRanks.get(item.sourceIndex);
-    if (!Number.isFinite(baselineRank) || !Number.isFinite(strategyRank)) continue;
-    const distance = Math.abs(strategyRank - baselineRank);
-    if (distance > 0) {
-      movedDistances.push(distance);
-      movedPrimitives.push(Math.max(item.width, item.height));
-      movedAreas.push(item.width * item.height);
-    }
-  }
-
-  for (const pair of pairs) {
-    totalArea += pair.overlapArea;
-    const baseSign = pairSign(pair, baselineRanks);
-    const strategySign = pairSign(pair, strategyRanks);
-    const changed = baseSign !== strategySign;
-    if (changed) {
-      changedPairs += 1;
-      changedArea += pair.overlapArea;
-      if (pair.maxPrimitive > 600) {
-        changedHugePairs += 1;
-        changedHugeArea += pair.overlapArea;
-      }
-    }
-
-    if (Math.abs(pair.depthDelta) > 0.5 && strategySign !== 0) {
-      if ((strategySign < 0) !== (pair.depthDelta < 0)) {
-        depthAscBad += 1;
-        depthAscArea += pair.overlapArea;
-        if (changed) {
-          changedDepthAscBad += 1;
-          changedDepthAscArea += pair.overlapArea;
-        }
-      }
-      if ((strategySign < 0) !== (pair.depthDelta > 0)) {
-        depthDescBad += 1;
-        depthDescArea += pair.overlapArea;
-        if (changed) {
-          changedDepthDescBad += 1;
-          changedDepthDescArea += pair.overlapArea;
-        }
-      }
-    }
-  }
-
-  return {
-    rotY: actualRotation.rotY,
-    leaves: visible.length,
-    overlapPairs: pairs.length,
-    overlapArea: totalArea,
-    changedPairs,
-    changedPairRate: pairs.length ? changedPairs / pairs.length : 0,
-    changedAreaRate: totalArea ? changedArea / totalArea : 0,
-    changedHugePairs,
-    changedHugePairRate: pairs.length ? changedHugePairs / pairs.length : 0,
-    changedHugeAreaRate: totalArea ? changedHugeArea / totalArea : 0,
-    depthAscBadRate: pairs.length ? depthAscBad / pairs.length : 0,
-    depthDescBadRate: pairs.length ? depthDescBad / pairs.length : 0,
-    depthAscBadAreaRate: totalArea ? depthAscArea / totalArea : 0,
-    depthDescBadAreaRate: totalArea ? depthDescArea / totalArea : 0,
-    changedDepthAscBadRate: changedPairs ? changedDepthAscBad / changedPairs : 0,
-    changedDepthDescBadRate: changedPairs ? changedDepthDescBad / changedPairs : 0,
-    changedDepthAscBadAreaRate: changedArea ? changedDepthAscArea / changedArea : 0,
-    changedDepthDescBadAreaRate: changedArea ? changedDepthDescArea / changedArea : 0,
-    movedCount: movedDistances.length,
-    movedRate: visible.length ? movedDistances.length / visible.length : 0,
-    movedDistance: summarize(movedDistances),
-    movedPrimitive: summarize(movedPrimitives),
-    movedArea: summarize(movedAreas),
-  };
-}
-
-function mergeAngleRows(rows) {
-  const sum = (key) => rows.reduce((total, row) => total + row[key], 0);
-  const weighted = (valueKey, weightKey) => {
-    const weight = sum(weightKey);
-    return weight ? rows.reduce((total, row) => total + row[valueKey] * row[weightKey], 0) / weight : 0;
-  };
-  return {
-    samples: rows.length,
-    leavesMedian: median(rows.map((row) => row.leaves)),
-    overlapPairsPerLeaf: sum("leaves") ? sum("overlapPairs") / sum("leaves") : 0,
-    changedPairRate: weighted("changedPairRate", "overlapPairs"),
-    changedAreaRate: weighted("changedAreaRate", "overlapArea"),
-    changedHugePairRate: weighted("changedHugePairRate", "overlapPairs"),
-    changedHugeAreaRate: weighted("changedHugeAreaRate", "overlapArea"),
-    depthAscBadRate: weighted("depthAscBadRate", "overlapPairs"),
-    depthDescBadRate: weighted("depthDescBadRate", "overlapPairs"),
-    depthAscBadAreaRate: weighted("depthAscBadAreaRate", "overlapArea"),
-    depthDescBadAreaRate: weighted("depthDescBadAreaRate", "overlapArea"),
-    changedDepthAscBadRate: weighted("changedDepthAscBadRate", "changedPairs"),
-    changedDepthDescBadRate: weighted("changedDepthDescBadRate", "changedPairs"),
-    changedDepthAscBadAreaRate: weighted("changedDepthAscBadAreaRate", "changedArea"),
-    changedDepthDescBadAreaRate: weighted("changedDepthDescBadAreaRate", "changedArea"),
-    movedRate: weighted("movedRate", "leaves"),
-    movedDistanceP95Median: median(rows.map((row) => row.movedDistance.p95)),
-    movedPrimitiveP95Median: median(rows.map((row) => row.movedPrimitive.p95)),
-    movedAreaP95Median: median(rows.map((row) => row.movedArea.p95)),
-  };
-}
-
-async function findModelPath(model) {
-  if (model.includes("/") || model.includes("\\")) return resolve(repoRoot, model);
-  const direct = resolve(galleryVoxDir, model);
-  try {
-    await readFile(direct);
-    return direct;
-  } catch {
-    const files = await readdir(galleryVoxDir);
-    const needle = model.toLowerCase().replace(/\.vox$/, "");
-    const match = files.find((file) => file.toLowerCase().replace(/\.vox$/, "") === needle);
-    if (!match) throw new Error(`Could not find model ${model}`);
-    return join(galleryVoxDir, match);
-  }
-}
-
-async function analyzeModel(model) {
-  const path = await findModelPath(model);
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize, gridShift: 0 },
-  );
-  const items = parsed.polygons
-    .map((polygon, sourceIndex) => matrixItemForPolygon(polygon, sourceIndex))
-    .filter((item) => item && item.width > 0 && item.height > 0);
-  const angles = [];
-  for (let offset = 0; offset < 360; offset += angleStep) {
-    angles.push({ rotX: 65, rotY: 45 + offset });
-  }
-  return {
-    model: basename(path),
-    key: canonicalModelKey(path),
-    polygons: parsed.polygons.length,
-    items: items.length,
-    strategies: STRATEGIES.map((strategy) => {
-      const angleRows = angles.map((rotation) => analyzePhaseForAngle(items, rotation, strategy));
-      return {
-        key: strategy.key,
-        label: strategy.label,
-        metrics: mergeAngleRows(angleRows),
-        angles: angleRows,
-      };
-    }),
-  };
-}
-
-function renderMarkdown(rows) {
-  const lines = [];
-  lines.push("# Voxel Order Phase Metrics");
-  lines.push("");
-  lines.push(`Target size: ${targetSize}`);
-  lines.push(`Angle step: ${angleStep}`);
-  lines.push("");
-  for (const row of rows) {
-    lines.push(`## ${row.model}`);
-    lines.push("");
-    lines.push(`Polygons: ${row.polygons}; matrix items: ${row.items}`);
-    lines.push("");
-    lines.push("| Strategy | Active | Overlap/leaf | Changed pairs % | Changed overlap area % | Changed huge area % | Moved leaves % | Moved dist p95 | Moved primitive p95 | Asc-bad area % | Desc-bad area % |");
-    lines.push("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
-    for (const strategy of row.strategies) {
-      const m = strategy.metrics;
-      lines.push([
-        `| ${strategy.label}`,
-        fmt(m.leavesMedian, 0),
-        fmt(m.overlapPairsPerLeaf, 2),
-        fmt(m.changedPairRate * 100, 2),
-        fmt(m.changedAreaRate * 100, 2),
-        fmt(m.changedHugeAreaRate * 100, 2),
-        fmt(m.movedRate * 100, 2),
-        fmt(m.movedDistanceP95Median, 0),
-        fmt(m.movedPrimitiveP95Median, 0),
-        fmt(m.depthAscBadAreaRate * 100, 2),
-        `${fmt(m.depthDescBadAreaRate * 100, 2)} |`,
-      ].join(" | "));
-    }
-    lines.push("");
-  }
-  return `${lines.join("\n")}\n`;
-}
-
-const rows = [];
-for (const model of models) {
-  console.log(`[phase-metrics] analyzing ${model}`);
-  rows.push(await analyzeModel(model));
-}
-
-const out = {
-  generatedAt: new Date().toISOString(),
-  targetSize,
-  angleStep,
-  models: rows,
-};
-const jsonPath = join(resultDir, "voxel-order-phase-metrics.json");
-const mdPath = join(resultDir, "voxel-order-phase-metrics.md");
-await writeFile(jsonPath, JSON.stringify(out, null, 2));
-await writeFile(mdPath, renderMarkdown(rows));
-console.log(`[phase-metrics] wrote ${jsonPath}`);
-console.log(`[phase-metrics] wrote ${mdPath}`);
diff --git a/bench/voxel-progress-dashboard.html b/bench/voxel-progress-dashboard.html
deleted file mode 100644
index 74ad8a3e..00000000
--- a/bench/voxel-progress-dashboard.html
+++ /dev/null
@@ -1,449 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Voxel Renderer Progress</title>
-  <style>
-    :root {
-      color-scheme: light;
-      --bg: #f8fafc;
-      --ink: #111827;
-      --muted: #64748b;
-      --line: #d8dee9;
-      --panel: #ffffff;
-      --good: #047857;
-      --bad: #b91c1c;
-      --flat: #6b7280;
-    }
-    * { box-sizing: border-box; }
-    body {
-      margin: 0;
-      background: var(--bg);
-      color: var(--ink);
-      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      font-size: 14px;
-      line-height: 1.45;
-    }
-    main {
-      width: min(1180px, calc(100vw - 32px));
-      margin: 24px auto 56px;
-    }
-    header {
-      display: flex;
-      justify-content: space-between;
-      gap: 20px;
-      align-items: end;
-      margin-bottom: 18px;
-    }
-    h1, h2 {
-      margin: 0;
-      letter-spacing: 0;
-    }
-    h1 {
-      font-size: 24px;
-      line-height: 1.1;
-    }
-    h2 {
-      font-size: 15px;
-      margin-bottom: 10px;
-    }
-    .meta {
-      color: var(--muted);
-      font-size: 12px;
-      text-align: right;
-    }
-    .summary {
-      display: grid;
-      grid-template-columns: repeat(4, minmax(0, 1fr));
-      gap: 10px;
-      margin-bottom: 16px;
-    }
-    .metric, section {
-      background: var(--panel);
-      border: 1px solid var(--line);
-      border-radius: 8px;
-    }
-    .metric {
-      padding: 12px 14px;
-    }
-    .metric b {
-      display: block;
-      font-size: 24px;
-      line-height: 1.1;
-      margin-bottom: 4px;
-    }
-    .metric span {
-      color: var(--muted);
-      font-size: 12px;
-    }
-    section {
-      padding: 14px;
-      margin-top: 12px;
-      overflow: hidden;
-    }
-    .chart-shell {
-      overflow: hidden;
-    }
-    svg {
-      display: block;
-      width: 100%;
-      height: auto;
-    }
-    .grid {
-      stroke: #e5e7eb;
-      stroke-width: 1;
-    }
-    .grid.vertical {
-      stroke-dasharray: 3 4;
-    }
-    .axis {
-      fill: #64748b;
-      font-size: 12px;
-    }
-    .axis.strong {
-      fill: #111827;
-      font-weight: 650;
-    }
-    .chart-title {
-      fill: #111827;
-      font-size: 13px;
-      font-weight: 700;
-    }
-    .avg-line {
-      fill: none;
-      stroke: #111827;
-      stroke-width: 3.25;
-      opacity: 0.86;
-    }
-    .legend {
-      display: flex;
-      flex-wrap: wrap;
-      gap: 8px 14px;
-      margin-top: -12px;
-      padding: 0 6px 4px;
-      color: var(--muted);
-      font-size: 12px;
-    }
-    .legend-item {
-      display: inline-flex;
-      align-items: center;
-      gap: 6px;
-      white-space: nowrap;
-    }
-    .swatch {
-      width: 10px;
-      height: 10px;
-      border-radius: 50%;
-      display: inline-block;
-    }
-    .scroll-x {
-      overflow-x: auto;
-      padding-bottom: 2px;
-    }
-    table {
-      width: 100%;
-      border-collapse: collapse;
-      font-size: 12px;
-    }
-    th, td {
-      border-bottom: 1px solid #e5e7eb;
-      padding: 7px 8px;
-      text-align: left;
-      vertical-align: middle;
-      white-space: nowrap;
-    }
-    thead th {
-      color: #334155;
-      font-size: 11px;
-      text-transform: uppercase;
-      letter-spacing: 0.04em;
-      background: #f8fafc;
-      border-bottom-color: #cbd5e1;
-    }
-    tbody th {
-      font-weight: 650;
-    }
-    .num {
-      text-align: right;
-      font-variant-numeric: tabular-nums;
-    }
-    .good { color: var(--good); font-weight: 700; }
-    .bad { color: var(--bad); font-weight: 700; }
-    .flat { color: var(--flat); font-weight: 650; }
-    .strategy-table {
-      min-width: 940px;
-    }
-    .strategy-head {
-      max-width: 148px;
-      overflow: hidden;
-      text-overflow: ellipsis;
-    }
-    @media (max-width: 760px) {
-      main { width: min(100vw - 20px, 1180px); margin-top: 14px; }
-      header { display: block; }
-      .meta { text-align: left; margin-top: 6px; }
-      .summary { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-    }
-  </style>
-</head>
-<body>
-  <main>
-    <header>
-      <div>
-        <h1>Voxel renderer progress</h1>
-      </div>
-      <div class="meta">
-        generated 2026-05-19T17:24:51.414Z<br>
-        source /Users/ekrof/fed/polycss/bench/results
-      </div>
-    </header>
-
-    <div class="summary">
-      <div class="metric"><b>9</b><span>models with iterated results</span></div>
-      <div class="metric"><b>Baseline / A32 / A33 / A34</b><span>iterations</span></div>
-      <div class="metric"><b>82.1</b><span>A34 average best p95 (-3.0 vs A33)</span></div>
-      <div class="metric"><b>3/9</b><span>models above Baseline</span></div>
-    </div>
-
-    <section>
-      <h2>Progress</h2>
-
-    <div class="chart-shell">
-      <svg viewBox="0 0 1080 360" role="img" aria-label="Best p95 FPS by iteration">
-        <text x="54" y="18" class="chart-title">best p95 FPS by benchmark iteration</text>
-        <line x1="54" y1="290" x2="1052" y2="290" class="grid"/>
-<text x="44" y="294" text-anchor="end" class="axis">25</text>
-<line x1="54" y1="224" x2="1052" y2="224" class="grid"/>
-<text x="44" y="228" text-anchor="end" class="axis">49</text>
-<line x1="54" y1="158" x2="1052" y2="158" class="grid"/>
-<text x="44" y="162" text-anchor="end" class="axis">73</text>
-<line x1="54" y1="92" x2="1052" y2="92" class="grid"/>
-<text x="44" y="96" text-anchor="end" class="axis">96</text>
-<line x1="54" y1="26" x2="1052" y2="26" class="grid"/>
-<text x="44" y="30" text-anchor="end" class="axis">120</text>
-<line x1="54" y1="26" x2="54" y2="290" class="grid vertical"/>
-<text x="54" y="328" text-anchor="middle" class="axis strong">Baseline</text>
-<line x1="386.66666666666663" y1="26" x2="386.66666666666663" y2="290" class="grid vertical"/>
-<text x="386.66666666666663" y="328" text-anchor="middle" class="axis strong">A32</text>
-<line x1="719.3333333333333" y1="26" x2="719.3333333333333" y2="290" class="grid vertical"/>
-<text x="719.3333333333333" y="328" text-anchor="middle" class="axis strong">A33</text>
-<line x1="1052" y1="26" x2="1052" y2="290" class="grid vertical"/>
-<text x="1052" y="328" text-anchor="middle" class="axis strong">A34</text>
-<polyline points="54,129.67506729424662 386.66666666666663,151.53130432942942 719.3333333333333,122.95003739269555 1052,131.20197105564853" class="avg-line"/>
-<polyline points="54,248.51515596484217 386.66666666666663,248.75864961207756 719.3333333333333,248.3157894736842 1052,248.75864961207756" fill="none" stroke="#2563eb" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="248.51515596484217" r="3.6" fill="#2563eb" opacity="0.95"><title>AncientCrashSite.vox Baseline: 39.9 p95</title></circle>
-<circle cx="386.66666666666663" cy="248.75864961207756" r="3.6" fill="#2563eb" opacity="0.95"><title>AncientCrashSite.vox A32: 39.8 p95</title></circle>
-<circle cx="719.3333333333333" cy="248.3157894736842" r="3.6" fill="#2563eb" opacity="0.95"><title>AncientCrashSite.vox A33: 40.0 p95</title></circle>
-<circle cx="1052" cy="248.75864961207756" r="3.6" fill="#2563eb" opacity="0.95"><title>AncientCrashSite.vox A34: 39.8 p95</title></circle>
-<polyline points="54,222.57993548074592 386.66666666666663,247.73169382631986 719.3333333333333,195.95808497805123 1052,242.58841109081774" fill="none" stroke="#dc2626" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="222.57993548074592" r="3.6" fill="#dc2626" opacity="0.95"><title>army.vox Baseline: 49.3 p95</title></circle>
-<circle cx="386.66666666666663" cy="247.73169382631986" r="3.6" fill="#dc2626" opacity="0.95"><title>army.vox A32: 40.2 p95</title></circle>
-<circle cx="719.3333333333333" cy="195.95808497805123" r="3.6" fill="#dc2626" opacity="0.95"><title>army.vox A33: 58.8 p95</title></circle>
-<circle cx="1052" cy="242.58841109081774" r="3.6" fill="#dc2626" opacity="0.95"><title>army.vox A34: 42.1 p95</title></circle>
-<polyline points="54,41.70594939515883 386.66666666666663,41.86932849364426 719.3333333333333,32.634800508897044 1052,43.68421052630681" fill="none" stroke="#059669" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="41.70594939515883" r="3.6" fill="#059669" opacity="0.95"><title>desert2.vox Baseline: 114.3 p95</title></circle>
-<circle cx="386.66666666666663" cy="41.86932849364426" r="3.6" fill="#059669" opacity="0.95"><title>desert2.vox A32: 114.3 p95</title></circle>
-<circle cx="719.3333333333333" cy="32.634800508897044" r="3.6" fill="#059669" opacity="0.95"><title>desert2.vox A33: 117.6 p95</title></circle>
-<circle cx="1052" cy="43.68421052630681" r="3.6" fill="#059669" opacity="0.95"><title>desert2.vox A34: 113.6 p95</title></circle>
-<polyline points="54,47.49508880938704 386.66666666666663,59.03816343101977 719.3333333333333,47.232406859845426 1052,40.60422139687254" fill="none" stroke="#7c3aed" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="47.49508880938704" r="3.6" fill="#7c3aed" opacity="0.95"><title>house.vox Baseline: 112.3 p95</title></circle>
-<circle cx="386.66666666666663" cy="59.03816343101977" r="3.6" fill="#7c3aed" opacity="0.95"><title>house.vox A32: 108.1 p95</title></circle>
-<circle cx="719.3333333333333" cy="47.232406859845426" r="3.6" fill="#7c3aed" opacity="0.95"><title>house.vox A33: 112.4 p95</title></circle>
-<circle cx="1052" cy="40.60422139687254" r="3.6" fill="#7c3aed" opacity="0.95"><title>house.vox A34: 114.7 p95</title></circle>
-<polyline points="54,54.09485251590971 386.66666666666663,193.8874848917692 719.3333333333333,40.06077284715908 1052,43.68421052631538" fill="none" stroke="#ea580c" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="54.09485251590971" r="3.6" fill="#ea580c" opacity="0.95"><title>obj_house3.vox Baseline: 109.9 p95</title></circle>
-<circle cx="386.66666666666663" cy="193.8874848917692" r="3.6" fill="#ea580c" opacity="0.95"><title>obj_house3.vox A32: 59.6 p95</title></circle>
-<circle cx="719.3333333333333" cy="40.06077284715908" r="3.6" fill="#ea580c" opacity="0.95"><title>obj_house3.vox A33: 114.9 p95</title></circle>
-<circle cx="1052" cy="43.68421052631538" r="3.6" fill="#ea580c" opacity="0.95"><title>obj_house3.vox A34: 113.6 p95</title></circle>
-<polyline points="54,43.77387250066646 386.66666666666663,48.61545756282783 719.3333333333333,38.1973578694085 1052,44.22157208107973" fill="none" stroke="#0891b2" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="43.77387250066646" r="3.6" fill="#0891b2" opacity="0.95"><title>obj_house5.vox Baseline: 113.6 p95</title></circle>
-<circle cx="386.66666666666663" cy="48.61545756282783" r="3.6" fill="#0891b2" opacity="0.95"><title>obj_house5.vox A32: 111.9 p95</title></circle>
-<circle cx="719.3333333333333" cy="38.1973578694085" r="3.6" fill="#0891b2" opacity="0.95"><title>obj_house5.vox A33: 115.6 p95</title></circle>
-<circle cx="1052" cy="44.22157208107973" r="3.6" fill="#0891b2" opacity="0.95"><title>obj_house5.vox A34: 113.4 p95</title></circle>
-<polyline points="54,48.96708062290715 386.66666666666663,50.66362968787176 719.3333333333333,34.439484484122424 1052,44.0426548778363" fill="none" stroke="#be123c" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="48.96708062290715" r="3.6" fill="#be123c" opacity="0.95"><title>scene_mechanic2.vox Baseline: 111.7 p95</title></circle>
-<circle cx="386.66666666666663" cy="50.66362968787176" r="3.6" fill="#be123c" opacity="0.95"><title>scene_mechanic2.vox A32: 111.1 p95</title></circle>
-<circle cx="719.3333333333333" cy="34.439484484122424" r="3.6" fill="#be123c" opacity="0.95"><title>scene_mechanic2.vox A33: 117.0 p95</title></circle>
-<circle cx="1052" cy="44.0426548778363" r="3.6" fill="#be123c" opacity="0.95"><title>scene_mechanic2.vox A34: 113.5 p95</title></circle>
-<polyline points="54,263.6826238485054 386.66666666666663,276.0210587069366 719.3333333333333,276.1467392384509 1052,276.2716671919321" fill="none" stroke="#4d7c0f" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="263.6826238485054" r="3.6" fill="#4d7c0f" opacity="0.95"><title>skyscraper.vox Baseline: 34.5 p95</title></circle>
-<circle cx="386.66666666666663" cy="276.0210587069366" r="3.6" fill="#4d7c0f" opacity="0.95"><title>skyscraper.vox A32: 30.0 p95</title></circle>
-<circle cx="719.3333333333333" cy="276.1467392384509" r="3.6" fill="#4d7c0f" opacity="0.95"><title>skyscraper.vox A33: 30.0 p95</title></circle>
-<circle cx="1052" cy="276.2716671919321" r="3.6" fill="#4d7c0f" opacity="0.95"><title>skyscraper.vox A34: 29.9 p95</title></circle>
-<polyline points="54,196.26104651009712 386.66666666666663,197.19627275239804 719.3333333333333,193.56490027464093 1052,196.96214219759838" fill="none" stroke="#9333ea" stroke-width="1.55" opacity="0.72"/>
-<circle cx="54" cy="196.26104651009712" r="3.6" fill="#9333ea" opacity="0.95"><title>Treasure.vox Baseline: 58.7 p95</title></circle>
-<circle cx="386.66666666666663" cy="197.19627275239804" r="3.6" fill="#9333ea" opacity="0.95"><title>Treasure.vox A32: 58.4 p95</title></circle>
-<circle cx="719.3333333333333" cy="193.56490027464093" r="3.6" fill="#9333ea" opacity="0.95"><title>Treasure.vox A33: 59.7 p95</title></circle>
-<circle cx="1052" cy="196.96214219759838" r="3.6" fill="#9333ea" opacity="0.95"><title>Treasure.vox A34: 58.5 p95</title></circle>
-        <text x="1052" y="18" text-anchor="end" class="axis">thick line = corpus average</text>
-      </svg>
-      <div class="legend"><span class="legend-item"><span class="swatch" style="background:#2563eb"></span>AncientCrashSite.vox</span><span class="legend-item"><span class="swatch" style="background:#dc2626"></span>army.vox</span><span class="legend-item"><span class="swatch" style="background:#059669"></span>desert2.vox</span><span class="legend-item"><span class="swatch" style="background:#7c3aed"></span>house.vox</span><span class="legend-item"><span class="swatch" style="background:#ea580c"></span>obj_house3.vox</span><span class="legend-item"><span class="swatch" style="background:#0891b2"></span>obj_house5.vox</span><span class="legend-item"><span class="swatch" style="background:#be123c"></span>scene_mechanic2.vox</span><span class="legend-item"><span class="swatch" style="background:#4d7c0f"></span>skyscraper.vox</span><span class="legend-item"><span class="swatch" style="background:#9333ea"></span>Treasure.vox</span></div>
-    </div>
-
-    </section>
-
-    <section>
-      <h2>Best p95 heatmap</h2>
-
-    <table>
-      <thead><tr><th>Model</th><th>Baseline</th><th>A32</th><th>A33</th><th>A34</th><th>Delta</th></tr></thead>
-      <tbody><tr><th>AncientCrashSite.vox</th><td class="num" style="background: hsl(28.7 68% 92.1%); color: #111827;" title="face-order, 2 runs">39.9</td><td class="num" style="background: hsl(28.6 68% 92.1%); color: #111827;" title="source:block64-depth-front, 2 runs">39.8</td><td class="num" style="background: hsl(28.8 68% 92.1%); color: #111827;" title="screen:tile4-depth-front, 2 runs">40.0</td><td class="num" style="background: hsl(28.6 68% 92.1%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">39.8</td><td class="num flat">-0.1</td></tr><tr><th>army.vox</th><td class="num" style="background: hsl(41.7 68% 90.9%); color: #111827;" title="exact, 2 runs">49.3</td><td class="num" style="background: hsl(29.1 68% 92.1%); color: #111827;" title="source:block256-depth-front, 2 runs">40.2</td><td class="num" style="background: hsl(55.0 68% 89.7%); color: #111827;" title="screen:tile8-scanline-reverse, 2 runs">58.8</td><td class="num" style="background: hsl(31.7 68% 91.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">42.1</td><td class="num bad">-7.2</td></tr><tr><th>desert2.vox</th><td class="num" style="background: hsl(132.1 68% 82.7%); color: #111827;" title="exact, 2 runs">114.3</td><td class="num" style="background: hsl(132.1 68% 82.7%); color: #111827;" title="source:block128-depth-back, 2 runs">114.3</td><td class="num" style="background: hsl(136.7 68% 82.3%); color: #111827;" title="screen:tile4-depth-front, 2 runs">117.6</td><td class="num" style="background: hsl(131.2 68% 82.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">113.6</td><td class="num bad">-0.7</td></tr><tr><th>house.vox</th><td class="num" style="background: hsl(129.3 68% 83.0%); color: #111827;" title="exact, 2 runs">112.3</td><td class="num" style="background: hsl(123.5 68% 83.5%); color: #111827;" title="source:block128-depth-front, 2 runs">108.1</td><td class="num" style="background: hsl(129.4 68% 83.0%); color: #111827;" title="screen:tile8-depth-front, 2 runs">112.4</td><td class="num" style="background: hsl(132.7 68% 82.7%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">114.7</td><td class="num good">+2.5</td></tr><tr><th>obj_house3.vox</th><td class="num" style="background: hsl(126.0 68% 83.3%); color: #111827;" title="face-normal-front, 2 runs">109.9</td><td class="num" style="background: hsl(56.1 68% 89.6%); color: #111827;" title="source:block128-depth-back, 2 runs">59.6</td><td class="num" style="background: hsl(133.0 68% 82.6%); color: #111827;" title="screen:tile4-scanline-forward, 2 runs">114.9</td><td class="num" style="background: hsl(131.2 68% 82.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">113.6</td><td class="num good">+3.7</td></tr><tr><th>obj_house5.vox</th><td class="num" style="background: hsl(131.1 68% 82.8%); color: #111827;" title="face-order-top-reverse, 2 runs">113.6</td><td class="num" style="background: hsl(128.7 68% 83.0%); color: #111827;" title="source:block64-depth-front, 2 runs">111.9</td><td class="num" style="background: hsl(133.9 68% 82.6%); color: #111827;" title="screen:tile4-scanline-reverse, 2 runs">115.6</td><td class="num" style="background: hsl(130.9 68% 82.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">113.4</td><td class="num flat">-0.2</td></tr><tr><th>scene_mechanic2.vox</th><td class="num" style="background: hsl(128.5 68% 83.0%); color: #111827;" title="exact, 2 runs">111.7</td><td class="num" style="background: hsl(127.7 68% 83.1%); color: #111827;" title="source:block64-depth-front, 2 runs">111.1</td><td class="num" style="background: hsl(135.8 68% 82.4%); color: #111827;" title="screen:tile8-scanline-forward, 2 runs">117.0</td><td class="num" style="background: hsl(131.0 68% 82.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">113.5</td><td class="num good">+1.8</td></tr><tr><th>skyscraper.vox</th><td class="num" style="background: hsl(21.2 68% 92.8%); color: #111827;" title="depth-back, 2 runs">34.5</td><td class="num" style="background: hsl(15.0 68% 93.4%); color: #111827;" title="source:block256-depth-front, 2 runs">30.0</td><td class="num" style="background: hsl(14.9 68% 93.4%); color: #111827;" title="screen:tile4-scanline-forward, 2 runs">30.0</td><td class="num" style="background: hsl(14.9 68% 93.4%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">29.9</td><td class="num bad">-4.5</td></tr><tr><th>Treasure.vox</th><td class="num" style="background: hsl(54.9 68% 89.7%); color: #111827;" title="depth-front, 2 runs">58.7</td><td class="num" style="background: hsl(54.4 68% 89.8%); color: #111827;" title="source:block64-depth-front, 2 runs">58.4</td><td class="num" style="background: hsl(56.2 68% 89.6%); color: #111827;" title="screen:tile4-depth-back, 2 runs">59.7</td><td class="num" style="background: hsl(54.5 68% 89.8%); color: #111827;" title="screen:tile4-scanline-forward, 5 runs">58.5</td><td class="num bad">-0.3</td></tr></tbody>
-    </table>
-
-    </section>
-
-    <section>
-      <h2>A34 strategy heatmap</h2>
-
-    <div class="scroll-x">
-      <table class="strategy-table">
-        <thead><tr><th>Model</th><th class="strategy-head">screen:tile4-scanline-forward</th><th class="strategy-head">voxlocal</th></tr></thead>
-        <tbody><tr><th>AncientCrashSite.vox</th><td class="num" style="background: hsl(35.6 68% 91.5%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">39.8</td><td class="num" style="background: hsl(35.6 68% 91.5%); color: #111827;" title="polycss-voxlocal, 5 runs">39.8</td></tr><tr><th>army.vox</th><td class="num" style="background: hsl(38.7 68% 91.2%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">42.1</td><td class="num" style="background: hsl(35.6 68% 91.5%); color: #111827;" title="polycss-voxlocal, 5 runs">39.8</td></tr><tr><th>desert2.vox</th><td class="num" style="background: hsl(138.1 68% 82.2%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">113.6</td><td class="num" style="background: hsl(62.9 68% 89.0%); color: #111827;" title="polycss-voxlocal, 5 runs">59.5</td></tr><tr><th>house.vox</th><td class="num" style="background: hsl(139.6 68% 82.0%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">114.7</td><td class="num" style="background: hsl(63.4 68% 89.0%); color: #111827;" title="polycss-voxlocal, 5 runs">59.9</td></tr><tr><th>obj_house3.vox</th><td class="num" style="background: hsl(138.1 68% 82.2%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">113.6</td><td class="num" style="background: hsl(63.4 68% 89.0%); color: #111827;" title="polycss-voxlocal, 5 runs">59.9</td></tr><tr><th>obj_house5.vox</th><td class="num" style="background: hsl(137.8 68% 82.2%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">113.4</td><td class="num" style="background: hsl(63.4 68% 89.0%); color: #111827;" title="polycss-voxlocal, 5 runs">59.9</td></tr><tr><th>scene_mechanic2.vox</th><td class="num" style="background: hsl(137.9 68% 82.2%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">113.5</td><td class="num" style="background: hsl(35.8 68% 91.5%); color: #111827;" title="polycss-voxlocal, 5 runs">40.0</td></tr><tr><th>skyscraper.vox</th><td class="num" style="background: hsl(21.8 68% 92.7%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">29.9</td><td class="num" style="background: hsl(13.2 68% 93.5%); color: #111827;" title="polycss-voxlocal, 5 runs">23.7</td></tr><tr><th>Treasure.vox</th><td class="num" style="background: hsl(61.5 68% 89.1%); color: #111827;" title="polycss-voxlocal-direct-matrix-screen-tile4-scanline-forward, 5 runs">58.5</td><td class="num" style="background: hsl(22.5 68% 92.7%); color: #111827;" title="polycss-voxlocal, 5 runs">30.5</td></tr></tbody>
-      </table>
-    </div>
-
-    </section>
-
-    <section>
-      <h2>Model table</h2>
-
-    <table>
-      <thead>
-        <tr>
-          <th>Model</th>
-          <th>Baseline</th>
-          <th>A33</th>
-          <th>A34</th>
-          <th>Delta base</th>
-          <th>Delta prev</th>
-          <th>Latest best case</th>
-          <th>Nodes</th>
-          <th>Leaves</th>
-          <th>Cases</th>
-        </tr>
-      </thead>
-      <tbody>
-        <tr>
-          <th>AncientCrashSite.vox</th>
-          <td class="num">39.9</td>
-          <td class="num">40.0</td>
-          <td class="num">39.8</td>
-          <td class="num flat">-0.1</td>
-          <td class="num flat">-0.2</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">5267</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>army.vox</th>
-          <td class="num">49.3</td>
-          <td class="num">58.8</td>
-          <td class="num">42.1</td>
-          <td class="num bad">-7.2</td>
-          <td class="num bad">-16.8</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">3893</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>desert2.vox</th>
-          <td class="num">114.3</td>
-          <td class="num">117.6</td>
-          <td class="num">113.6</td>
-          <td class="num bad">-0.7</td>
-          <td class="num bad">-4.0</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">2011</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>house.vox</th>
-          <td class="num">112.3</td>
-          <td class="num">112.4</td>
-          <td class="num">114.7</td>
-          <td class="num good">+2.5</td>
-          <td class="num good">+2.4</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">2132</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>obj_house3.vox</th>
-          <td class="num">109.9</td>
-          <td class="num">114.9</td>
-          <td class="num">113.6</td>
-          <td class="num good">+3.7</td>
-          <td class="num bad">-1.3</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">1096</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>obj_house5.vox</th>
-          <td class="num">113.6</td>
-          <td class="num">115.6</td>
-          <td class="num">113.4</td>
-          <td class="num flat">-0.2</td>
-          <td class="num bad">-2.2</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">2522</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>scene_mechanic2.vox</th>
-          <td class="num">111.7</td>
-          <td class="num">117.0</td>
-          <td class="num">113.5</td>
-          <td class="num good">+1.8</td>
-          <td class="num bad">-3.5</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">2243</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>skyscraper.vox</th>
-          <td class="num">34.5</td>
-          <td class="num">30.0</td>
-          <td class="num">29.9</td>
-          <td class="num bad">-4.5</td>
-          <td class="num flat">-0.0</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">5793</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-
-        <tr>
-          <th>Treasure.vox</th>
-          <td class="num">58.7</td>
-          <td class="num">59.7</td>
-          <td class="num">58.5</td>
-          <td class="num bad">-0.3</td>
-          <td class="num bad">-1.2</td>
-          <td>screen:tile4-scanline-forward</td>
-          <td class="num">4037</td>
-          <td class="num"></td>
-          <td class="num">2</td>
-        </tr>
-      </tbody>
-    </table>
-
-    </section>
-  </main>
-</body>
-</html>
diff --git a/bench/voxel-progress-dashboard.mjs b/bench/voxel-progress-dashboard.mjs
deleted file mode 100644
index e1b72a14..00000000
--- a/bench/voxel-progress-dashboard.mjs
+++ /dev/null
@@ -1,688 +0,0 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const resultDir = process.argv[2] ?? join(repoRoot, "bench/results");
-const outputPath = process.argv[3] ?? join(repoRoot, "bench/voxel-progress-dashboard.html");
-
-const RESULT_FILE = /^(?:(a\d+)-)?(.+)-rotation-compare\.json$/i;
-const BASELINE_ITERATION = "a31";
-const PALETTE = [
-  "#2563eb",
-  "#dc2626",
-  "#059669",
-  "#7c3aed",
-  "#ea580c",
-  "#0891b2",
-  "#be123c",
-  "#4d7c0f",
-  "#9333ea",
-  "#0f766e",
-  "#b45309",
-  "#1d4ed8",
-];
-
-function esc(value) {
-  return String(value ?? "")
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;");
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function maybeNumber(value) {
-  return Number.isFinite(value) ? value : null;
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function iterationRank(id) {
-  const match = /^a(\d+)$/i.exec(id);
-  return match ? Number(match[1]) : Number.MAX_SAFE_INTEGER;
-}
-
-function iterationLabel(id) {
-  if (id === BASELINE_ITERATION) return "Baseline";
-  return id.toUpperCase();
-}
-
-function strategyLabel(id) {
-  return id
-    .replace(/^polycss-voxlocal-/, "")
-    .replace(/^polycss-/, "")
-    .replace(/^direct-matrix-screen-/, "screen:")
-    .replace(/^direct-matrix-source-/, "source:")
-    .replace(/^direct-matrix-/, "")
-    .replaceAll("screen-tile", "screen:tile")
-    .replaceAll("source-block", "source:block");
-}
-
-function fileIteration(prefix) {
-  return prefix ? prefix.toLowerCase() : BASELINE_ITERATION;
-}
-
-function cellColor(value, domain) {
-  if (!Number.isFinite(value)) {
-    return "background: #f3f4f6; color: #9ca3af;";
-  }
-  const [min, max] = domain;
-  const t = max > min ? Math.max(0, Math.min(1, (value - min) / (max - min))) : 0.5;
-  const hue = 8 + t * 132;
-  const light = 94 - t * 12;
-  return `background: hsl(${hue.toFixed(1)} 68% ${light.toFixed(1)}%); color: #111827;`;
-}
-
-function deltaClass(delta) {
-  if (!Number.isFinite(delta)) return "";
-  if (delta > 0.25) return "good";
-  if (delta < -0.25) return "bad";
-  return "flat";
-}
-
-function summarizeCase(id, entry) {
-  const aggregate = entry.aggregate ?? {};
-  const runs = Array.isArray(entry.runs) ? entry.runs : [];
-  return {
-    id,
-    label: strategyLabel(id),
-    p50: maybeNumber(aggregate.fps_p50_median),
-    p95: maybeNumber(aggregate.fps_p95_median),
-    p99FrameMs: maybeNumber(aggregate.frame_time_p99_ms_median),
-    nodes: maybeNumber(aggregate.nodes_median),
-    leaves: median(runs.map((run) => run.dom?.leaves ?? run.domSamples?.at?.(0)?.leaves)),
-    runs: runs.length,
-  };
-}
-
-function summarizeResult(data, file, mtime) {
-  const cases = Object.entries(data.cases ?? {})
-    .map(([id, entry]) => summarizeCase(id, entry))
-    .filter((entry) => Number.isFinite(entry.p95));
-
-  cases.sort((a, b) => {
-    const delta = b.p95 - a.p95;
-    return delta !== 0 ? delta : a.label.localeCompare(b.label);
-  });
-
-  return {
-    file,
-    mtime,
-    model: data.model ?? file.replace(/-rotation-compare\.json$/i, ""),
-    viewport: data.viewport ?? null,
-    caseCount: cases.length,
-    best: cases[0] ?? null,
-    cases,
-  };
-}
-
-async function discoverResults() {
-  if (!existsSync(resultDir)) {
-    throw new Error(`Result directory not found: ${resultDir}`);
-  }
-
-  const candidates = [];
-  for (const file of await readdir(resultDir)) {
-    const match = RESULT_FILE.exec(file);
-    if (!match) continue;
-    candidates.push({
-      prefix: match[1]?.toLowerCase() ?? null,
-      slug: match[2],
-      file,
-      path: join(resultDir, file),
-      mtime: (await stat(join(resultDir, file))).mtimeMs,
-    });
-  }
-
-  const iteratedSlugs = new Set(candidates.filter((entry) => entry.prefix).map((entry) => entry.slug));
-  const selected = new Map();
-  for (const entry of candidates) {
-    if (!entry.prefix && !iteratedSlugs.has(entry.slug)) continue;
-    const iteration = fileIteration(entry.prefix);
-    const key = `${entry.slug}:${iteration}`;
-    const current = selected.get(key);
-    if (!current || entry.mtime > current.mtime) selected.set(key, { ...entry, iteration });
-  }
-
-  const models = new Map();
-  const iterations = new Map();
-  for (const entry of selected.values()) {
-    const data = JSON.parse(await readFile(entry.path, "utf8"));
-    const summary = summarizeResult(data, entry.file, entry.mtime);
-    if (!summary.best) continue;
-
-    iterations.set(entry.iteration, {
-      id: entry.iteration,
-      label: iterationLabel(entry.iteration),
-      rank: iterationRank(entry.iteration),
-    });
-
-    const model = models.get(entry.slug) ?? {
-      slug: entry.slug,
-      name: String(summary.model),
-      results: new Map(),
-    };
-    model.name = String(summary.model);
-    model.results.set(entry.iteration, summary);
-    models.set(entry.slug, model);
-  }
-
-  const sortedIterations = [...iterations.values()].sort((a, b) => a.rank - b.rank || a.id.localeCompare(b.id));
-  const sortedModels = [...models.values()]
-    .filter((model) => sortedIterations.some((iteration) => model.results.has(iteration.id)))
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-  return { iterations: sortedIterations, models: sortedModels };
-}
-
-function valueDomain(models, iterations, pickValue) {
-  const values = [];
-  for (const model of models) {
-    for (const iteration of iterations) {
-      const value = pickValue(model, iteration);
-      if (Number.isFinite(value)) values.push(value);
-    }
-  }
-  if (values.length === 0) return [0, 1];
-  const min = Math.floor(Math.min(...values) / 5) * 5;
-  const max = Math.ceil(Math.max(...values) / 5) * 5;
-  return min === max ? [min - 1, max + 1] : [min, max];
-}
-
-function renderLineChart(models, iterations) {
-  const width = 1080;
-  const height = 360;
-  const pad = { top: 26, right: 28, bottom: 70, left: 54 };
-  const plotWidth = width - pad.left - pad.right;
-  const plotHeight = height - pad.top - pad.bottom;
-  const domain = valueDomain(models, iterations, (model, iteration) => model.results.get(iteration.id)?.best?.p95);
-  const [minY, maxY] = domain;
-  const xFor = (index) => pad.left + (iterations.length <= 1 ? plotWidth / 2 : (index / (iterations.length - 1)) * plotWidth);
-  const yFor = (value) => pad.top + ((maxY - value) / (maxY - minY)) * plotHeight;
-  const lines = [];
-
-  for (let i = 0; i <= 4; i += 1) {
-    const value = minY + ((maxY - minY) * i) / 4;
-    const y = yFor(value);
-    lines.push(`<line x1="${pad.left}" y1="${y}" x2="${width - pad.right}" y2="${y}" class="grid"/>`);
-    lines.push(`<text x="${pad.left - 10}" y="${y + 4}" text-anchor="end" class="axis">${fmt(value, 0)}</text>`);
-  }
-
-  iterations.forEach((iteration, index) => {
-    const x = xFor(index);
-    lines.push(`<line x1="${x}" y1="${pad.top}" x2="${x}" y2="${height - pad.bottom}" class="grid vertical"/>`);
-    lines.push(`<text x="${x}" y="${height - 32}" text-anchor="middle" class="axis strong">${esc(iteration.label)}</text>`);
-  });
-
-  const averages = iterations.map((iteration) => {
-    const values = models
-      .map((model) => model.results.get(iteration.id)?.best?.p95)
-      .filter(Number.isFinite);
-    return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
-  });
-  const avgPoints = averages
-    .map((value, index) => (Number.isFinite(value) ? `${xFor(index)},${yFor(value)}` : null))
-    .filter(Boolean)
-    .join(" ");
-  if (avgPoints) lines.push(`<polyline points="${avgPoints}" class="avg-line"/>`);
-
-  models.forEach((model, modelIndex) => {
-    const color = PALETTE[modelIndex % PALETTE.length];
-    const points = iterations
-      .map((iteration, index) => {
-        const value = model.results.get(iteration.id)?.best?.p95;
-        return Number.isFinite(value) ? `${xFor(index)},${yFor(value)}` : null;
-      })
-      .filter(Boolean)
-      .join(" ");
-    if (points.includes(" ")) {
-      lines.push(`<polyline points="${points}" fill="none" stroke="${color}" stroke-width="1.55" opacity="0.72"/>`);
-    }
-
-    iterations.forEach((iteration, index) => {
-      const value = model.results.get(iteration.id)?.best?.p95;
-      if (!Number.isFinite(value)) return;
-      lines.push(
-        `<circle cx="${xFor(index)}" cy="${yFor(value)}" r="3.6" fill="${color}" opacity="0.95"><title>${esc(
-          `${model.name} ${iteration.label}: ${fmt(value)} p95`,
-        )}</title></circle>`,
-      );
-    });
-  });
-
-  const legend = models
-    .map((model, index) => {
-      const color = PALETTE[index % PALETTE.length];
-      return `<span class="legend-item"><span class="swatch" style="background:${color}"></span>${esc(model.name)}</span>`;
-    })
-    .join("");
-
-  return `
-    <div class="chart-shell">
-      <svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Best p95 FPS by iteration">
-        <text x="${pad.left}" y="18" class="chart-title">best p95 FPS by benchmark iteration</text>
-        ${lines.join("\n")}
-        <text x="${width - pad.right}" y="18" text-anchor="end" class="axis">thick line = corpus average</text>
-      </svg>
-      <div class="legend">${legend}</div>
-    </div>
-  `;
-}
-
-function renderProgressHeatmap(models, iterations) {
-  const domain = valueDomain(models, iterations, (model, iteration) => model.results.get(iteration.id)?.best?.p95);
-  const header = iterations.map((iteration) => `<th>${esc(iteration.label)}</th>`).join("");
-  const rows = models
-    .map((model) => {
-      const cells = iterations
-        .map((iteration) => {
-          const best = model.results.get(iteration.id)?.best;
-          const title = best ? `${best.label}, ${best.runs} runs` : "missing";
-          return `<td class="num" style="${cellColor(best?.p95, domain)}" title="${esc(title)}">${fmt(best?.p95)}</td>`;
-        })
-        .join("");
-      const first = model.results.get(iterations[0]?.id)?.best?.p95;
-      const latest = model.results.get(iterations.at(-1)?.id)?.best?.p95;
-      const delta = Number.isFinite(first) && Number.isFinite(latest) ? latest - first : null;
-      return `<tr><th>${esc(model.name)}</th>${cells}<td class="num ${deltaClass(delta)}">${Number.isFinite(delta) ? `${delta >= 0 ? "+" : ""}${fmt(delta)}` : ""}</td></tr>`;
-    })
-    .join("");
-
-  return `
-    <table>
-      <thead><tr><th>Model</th>${header}<th>Delta</th></tr></thead>
-      <tbody>${rows}</tbody>
-    </table>
-  `;
-}
-
-function latestStrategies(models, latestIteration) {
-  const byLabel = new Map();
-  for (const model of models) {
-    for (const resultCase of model.results.get(latestIteration.id)?.cases ?? []) {
-      byLabel.set(resultCase.label, resultCase);
-    }
-  }
-  return [...byLabel.keys()].sort((a, b) => a.localeCompare(b));
-}
-
-function renderStrategyHeatmap(models, latestIteration) {
-  if (!latestIteration) return "";
-  const strategies = latestStrategies(models, latestIteration);
-  if (strategies.length === 0) return "";
-
-  const values = [];
-  for (const model of models) {
-    for (const resultCase of model.results.get(latestIteration.id)?.cases ?? []) {
-      if (Number.isFinite(resultCase.p95)) values.push(resultCase.p95);
-    }
-  }
-  const domain = values.length
-    ? [Math.floor(Math.min(...values) / 5) * 5, Math.ceil(Math.max(...values) / 5) * 5]
-    : [0, 1];
-  const header = strategies.map((label) => `<th class="strategy-head">${esc(label)}</th>`).join("");
-  const rows = models
-    .map((model) => {
-      const byStrategy = new Map((model.results.get(latestIteration.id)?.cases ?? []).map((entry) => [entry.label, entry]));
-      const cells = strategies
-        .map((strategy) => {
-          const entry = byStrategy.get(strategy);
-          const title = entry ? `${entry.id}, ${entry.runs} runs` : "missing";
-          return `<td class="num" style="${cellColor(entry?.p95, domain)}" title="${esc(title)}">${fmt(entry?.p95)}</td>`;
-        })
-        .join("");
-      return `<tr><th>${esc(model.name)}</th>${cells}</tr>`;
-    })
-    .join("");
-
-  return `
-    <div class="scroll-x">
-      <table class="strategy-table">
-        <thead><tr><th>Model</th>${header}</tr></thead>
-        <tbody>${rows}</tbody>
-      </table>
-    </div>
-  `;
-}
-
-function renderModelTable(models, iterations, latestIteration) {
-  const previousIteration = iterations.at(-2) ?? null;
-  const baselineIteration = iterations[0] ?? null;
-  const rows = models
-    .map((model) => {
-      const baseline = baselineIteration ? model.results.get(baselineIteration.id)?.best : null;
-      const previous = previousIteration ? model.results.get(previousIteration.id)?.best : null;
-      const latest = latestIteration ? model.results.get(latestIteration.id)?.best : null;
-      const deltaBaseline =
-        Number.isFinite(baseline?.p95) && Number.isFinite(latest?.p95) ? latest.p95 - baseline.p95 : null;
-      const deltaPrevious =
-        Number.isFinite(previous?.p95) && Number.isFinite(latest?.p95) ? latest.p95 - previous.p95 : null;
-      return `
-        <tr>
-          <th>${esc(model.name)}</th>
-          <td class="num">${fmt(baseline?.p95)}</td>
-          <td class="num">${fmt(previous?.p95)}</td>
-          <td class="num">${fmt(latest?.p95)}</td>
-          <td class="num ${deltaClass(deltaBaseline)}">${Number.isFinite(deltaBaseline) ? `${deltaBaseline >= 0 ? "+" : ""}${fmt(deltaBaseline)}` : ""}</td>
-          <td class="num ${deltaClass(deltaPrevious)}">${Number.isFinite(deltaPrevious) ? `${deltaPrevious >= 0 ? "+" : ""}${fmt(deltaPrevious)}` : ""}</td>
-          <td>${esc(latest?.label ?? "")}</td>
-          <td class="num">${fmt(latest?.nodes, 0)}</td>
-          <td class="num">${fmt(latest?.leaves, 0)}</td>
-          <td class="num">${latest?.caseCount ?? model.results.get(latestIteration?.id)?.caseCount ?? ""}</td>
-        </tr>
-      `;
-    })
-    .join("");
-
-  return `
-    <table>
-      <thead>
-        <tr>
-          <th>Model</th>
-          <th>${esc(baselineIteration?.label ?? "Base")}</th>
-          <th>${esc(previousIteration?.label ?? "Prev")}</th>
-          <th>${esc(latestIteration?.label ?? "Latest")}</th>
-          <th>Delta base</th>
-          <th>Delta prev</th>
-          <th>Latest best case</th>
-          <th>Nodes</th>
-          <th>Leaves</th>
-          <th>Cases</th>
-        </tr>
-      </thead>
-      <tbody>${rows}</tbody>
-    </table>
-  `;
-}
-
-function averageLatest(models, latestIteration) {
-  const values = models
-    .map((model) => model.results.get(latestIteration?.id)?.best?.p95)
-    .filter(Number.isFinite);
-  return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
-}
-
-function improvedCount(models, baselineIteration, latestIteration) {
-  let improved = 0;
-  let comparable = 0;
-  for (const model of models) {
-    const baseline = model.results.get(baselineIteration?.id)?.best?.p95;
-    const latest = model.results.get(latestIteration?.id)?.best?.p95;
-    if (!Number.isFinite(baseline) || !Number.isFinite(latest)) continue;
-    comparable += 1;
-    if (latest > baseline + 0.25) improved += 1;
-  }
-  return { improved, comparable };
-}
-
-function renderDashboard(data) {
-  const { models, iterations } = data;
-  const latestIteration = iterations.at(-1) ?? null;
-  const baselineIteration = iterations[0] ?? null;
-  const previousIteration = iterations.at(-2) ?? null;
-  const latestAverage = averageLatest(models, latestIteration);
-  const previousAverage = averageLatest(models, previousIteration);
-  const averageDelta =
-    Number.isFinite(latestAverage) && Number.isFinite(previousAverage) ? latestAverage - previousAverage : null;
-  const improved = improvedCount(models, baselineIteration, latestIteration);
-
-  return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Voxel Renderer Progress</title>
-  <style>
-    :root {
-      color-scheme: light;
-      --bg: #f8fafc;
-      --ink: #111827;
-      --muted: #64748b;
-      --line: #d8dee9;
-      --panel: #ffffff;
-      --good: #047857;
-      --bad: #b91c1c;
-      --flat: #6b7280;
-    }
-    * { box-sizing: border-box; }
-    body {
-      margin: 0;
-      background: var(--bg);
-      color: var(--ink);
-      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      font-size: 14px;
-      line-height: 1.45;
-    }
-    main {
-      width: min(1180px, calc(100vw - 32px));
-      margin: 24px auto 56px;
-    }
-    header {
-      display: flex;
-      justify-content: space-between;
-      gap: 20px;
-      align-items: end;
-      margin-bottom: 18px;
-    }
-    h1, h2 {
-      margin: 0;
-      letter-spacing: 0;
-    }
-    h1 {
-      font-size: 24px;
-      line-height: 1.1;
-    }
-    h2 {
-      font-size: 15px;
-      margin-bottom: 10px;
-    }
-    .meta {
-      color: var(--muted);
-      font-size: 12px;
-      text-align: right;
-    }
-    .summary {
-      display: grid;
-      grid-template-columns: repeat(4, minmax(0, 1fr));
-      gap: 10px;
-      margin-bottom: 16px;
-    }
-    .metric, section {
-      background: var(--panel);
-      border: 1px solid var(--line);
-      border-radius: 8px;
-    }
-    .metric {
-      padding: 12px 14px;
-    }
-    .metric b {
-      display: block;
-      font-size: 24px;
-      line-height: 1.1;
-      margin-bottom: 4px;
-    }
-    .metric span {
-      color: var(--muted);
-      font-size: 12px;
-    }
-    section {
-      padding: 14px;
-      margin-top: 12px;
-      overflow: hidden;
-    }
-    .chart-shell {
-      overflow: hidden;
-    }
-    svg {
-      display: block;
-      width: 100%;
-      height: auto;
-    }
-    .grid {
-      stroke: #e5e7eb;
-      stroke-width: 1;
-    }
-    .grid.vertical {
-      stroke-dasharray: 3 4;
-    }
-    .axis {
-      fill: #64748b;
-      font-size: 12px;
-    }
-    .axis.strong {
-      fill: #111827;
-      font-weight: 650;
-    }
-    .chart-title {
-      fill: #111827;
-      font-size: 13px;
-      font-weight: 700;
-    }
-    .avg-line {
-      fill: none;
-      stroke: #111827;
-      stroke-width: 3.25;
-      opacity: 0.86;
-    }
-    .legend {
-      display: flex;
-      flex-wrap: wrap;
-      gap: 8px 14px;
-      margin-top: -12px;
-      padding: 0 6px 4px;
-      color: var(--muted);
-      font-size: 12px;
-    }
-    .legend-item {
-      display: inline-flex;
-      align-items: center;
-      gap: 6px;
-      white-space: nowrap;
-    }
-    .swatch {
-      width: 10px;
-      height: 10px;
-      border-radius: 50%;
-      display: inline-block;
-    }
-    .scroll-x {
-      overflow-x: auto;
-      padding-bottom: 2px;
-    }
-    table {
-      width: 100%;
-      border-collapse: collapse;
-      font-size: 12px;
-    }
-    th, td {
-      border-bottom: 1px solid #e5e7eb;
-      padding: 7px 8px;
-      text-align: left;
-      vertical-align: middle;
-      white-space: nowrap;
-    }
-    thead th {
-      color: #334155;
-      font-size: 11px;
-      text-transform: uppercase;
-      letter-spacing: 0.04em;
-      background: #f8fafc;
-      border-bottom-color: #cbd5e1;
-    }
-    tbody th {
-      font-weight: 650;
-    }
-    .num {
-      text-align: right;
-      font-variant-numeric: tabular-nums;
-    }
-    .good { color: var(--good); font-weight: 700; }
-    .bad { color: var(--bad); font-weight: 700; }
-    .flat { color: var(--flat); font-weight: 650; }
-    .strategy-table {
-      min-width: 940px;
-    }
-    .strategy-head {
-      max-width: 148px;
-      overflow: hidden;
-      text-overflow: ellipsis;
-    }
-    @media (max-width: 760px) {
-      main { width: min(100vw - 20px, 1180px); margin-top: 14px; }
-      header { display: block; }
-      .meta { text-align: left; margin-top: 6px; }
-      .summary { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-    }
-  </style>
-</head>
-<body>
-  <main>
-    <header>
-      <div>
-        <h1>Voxel renderer progress</h1>
-      </div>
-      <div class="meta">
-        generated ${esc(data.generatedAt)}<br>
-        source ${esc(resultDir)}
-      </div>
-    </header>
-
-    <div class="summary">
-      <div class="metric"><b>${esc(models.length)}</b><span>models with iterated results</span></div>
-      <div class="metric"><b>${esc(iterations.map((iteration) => iteration.label).join(" / "))}</b><span>iterations</span></div>
-      <div class="metric"><b>${fmt(latestAverage)}</b><span>${esc(latestIteration?.label ?? "latest")} average best p95${Number.isFinite(averageDelta) ? ` (${averageDelta >= 0 ? "+" : ""}${fmt(averageDelta)} vs ${esc(previousIteration?.label ?? "previous")})` : ""}</span></div>
-      <div class="metric"><b>${esc(`${improved.improved}/${improved.comparable}`)}</b><span>models above ${esc(baselineIteration?.label ?? "baseline")}</span></div>
-    </div>
-
-    <section>
-      <h2>Progress</h2>
-      ${renderLineChart(models, iterations)}
-    </section>
-
-    <section>
-      <h2>Best p95 heatmap</h2>
-      ${renderProgressHeatmap(models, iterations)}
-    </section>
-
-    <section>
-      <h2>${esc(latestIteration?.label ?? "Latest")} strategy heatmap</h2>
-      ${renderStrategyHeatmap(models, latestIteration)}
-    </section>
-
-    <section>
-      <h2>Model table</h2>
-      ${renderModelTable(models, iterations, latestIteration)}
-    </section>
-  </main>
-</body>
-</html>
-`;
-}
-
-const data = await discoverResults();
-const html = renderDashboard({
-  ...data,
-  generatedAt: new Date().toISOString(),
-});
-
-await writeFile(outputPath, html, "utf8");
-console.log(`wrote ${outputPath}`);
diff --git a/bench/voxel-report.mjs b/bench/voxel-report.mjs
new file mode 100644
index 00000000..e5bf2899
--- /dev/null
+++ b/bench/voxel-report.mjs
@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+
+const DEFAULT_RESULT_DIR = "bench/results";
+const DEFAULT_BROWSER_PREFIXES = ["browser-chrome", "browser-canary", "browser-chrome-headed"];
+const CADENCE_FILE_PATTERNS = [
+  [/^cadence-clean-(.*)-rotation-compare\.json$/, 1, "clean"],
+  [/^cadence-wide-(.*)-rotation-compare\.json$/, 2, "wide"],
+  [/^cadence-extended-(.*)-rotation-compare\.json$/, 3, "extended"],
+  [/^cadence-validate-(.*)-rotation-compare\.json$/, 4, "validated"],
+];
+
+function parseArgs(argv) {
+  const args = {
+    mode: "cadence",
+    resultDir: DEFAULT_RESULT_DIR,
+    browserPrefixes: DEFAULT_BROWSER_PREFIXES,
+  };
+
+  const positional = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") args.help = true;
+    else if (arg === "--mode") args.mode = argv[++i] ?? args.mode;
+    else if (arg.startsWith("--mode=")) args.mode = arg.slice("--mode=".length);
+    else if (arg === "--result-dir") args.resultDir = argv[++i] ?? args.resultDir;
+    else if (arg.startsWith("--result-dir=")) args.resultDir = arg.slice("--result-dir=".length);
+    else if (arg === "--prefixes") args.browserPrefixes = splitList(argv[++i]);
+    else if (arg.startsWith("--prefixes=")) args.browserPrefixes = splitList(arg.slice("--prefixes=".length));
+    else if (arg.startsWith("-")) throw new Error(`Unknown option ${arg}`);
+    else positional.push(arg);
+  }
+
+  if (positional[0] && ["cadence", "browser", "all"].includes(positional[0])) {
+    args.mode = positional.shift();
+  }
+  if (positional[0]) args.resultDir = positional.shift();
+  if (positional.length > 0) args.browserPrefixes = positional;
+
+  if (!["cadence", "browser", "all"].includes(args.mode)) {
+    throw new Error(`Unknown mode "${args.mode}"`);
+  }
+  return args;
+}
+
+function splitList(value = "") {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function printHelp() {
+  console.log(`Usage: node bench/voxel-report.mjs [mode] [resultDir] [browserPrefix...]
+
+Modes:
+  cadence   Summarize cadence rotation-compare runs. This is the default.
+  browser   Compare browser/canary/headed result prefixes.
+  all       Print cadence and browser reports.
+
+Options:
+  --mode <mode>       Same as positional mode.
+  --result-dir <dir>  Result directory. Default: ${DEFAULT_RESULT_DIR}
+  --prefixes <list>   Browser prefixes for browser/all mode.
+
+Examples:
+  node bench/voxel-report.mjs
+  node bench/voxel-report.mjs all
+  node bench/voxel-report.mjs browser --prefixes browser-chrome,browser-canary
+`);
+}
+
+function matchCadenceFile(file) {
+  for (const [pattern, priority, label] of CADENCE_FILE_PATTERNS) {
+    const match = pattern.exec(file);
+    if (match) return { key: match[1], priority, label };
+  }
+  return null;
+}
+
+function quantile(values, q) {
+  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (sorted.length === 0) return null;
+  const i = (sorted.length - 1) * q;
+  const lo = Math.floor(i);
+  const hi = Math.ceil(i);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
+}
+
+function median(values) {
+  return quantile(values, 0.5);
+}
+
+function fmt(value, digits = 1) {
+  return Number.isFinite(value) ? value.toFixed(digits) : "";
+}
+
+function cadence4Plus(run) {
+  const pct = run.cadence?.vsync_pct;
+  if (!pct) return null;
+  return (pct.x4 ?? 0) + (pct.x5 ?? 0) + (pct.x6_plus ?? 0);
+}
+
+function winnerFor(deltaP95, deltaP99) {
+  if (Math.abs(deltaP95) >= 8) return deltaP95 > 0 ? "matrix" : "slice";
+  if (Math.abs(deltaP99) >= 8) return deltaP99 > 0 ? "matrix-p99" : "slice-p99";
+  return "flat";
+}
+
+async function loadCadenceRows(resultDir) {
+  const selected = new Map();
+  for (const file of await readdir(resultDir)) {
+    const match = matchCadenceFile(file);
+    if (!match) continue;
+    const path = join(resultDir, file);
+    const mtime = (await stat(path)).mtimeMs;
+    const current = selected.get(match.key);
+    if (
+      !current ||
+      match.priority > current.priority ||
+      (match.priority === current.priority && mtime > current.mtime)
+    ) {
+      selected.set(match.key, { ...match, path, mtime });
+    }
+  }
+
+  const rows = [];
+  for (const entry of selected.values()) {
+    const data = JSON.parse(await readFile(entry.path, "utf8"));
+    const row = summarizeRotationCompare(data, basename(entry.path), entry.label);
+    if (row) rows.push(row);
+  }
+  return rows.sort((a, b) => a.model.localeCompare(b.model));
+}
+
+function summarizeRotationCompare(data, fallbackName, source = "") {
+  const matrixRuns = data.cases?.["polycss-matrix"]?.runs ?? [];
+  const sliceRuns = data.cases?.["polycss-baked-voxzoom"]?.runs ?? [];
+  if (matrixRuns.length === 0 || sliceRuns.length === 0) return null;
+
+  const slice = sliceRuns[0];
+  const meta = slice.metadata ?? {};
+  const brush = slice.brushMetrics ?? {};
+  const matrixP95 = median(matrixRuns.map((run) => run.fps_p95));
+  const sliceP95 = median(sliceRuns.map((run) => run.fps_p95));
+  const matrixP50 = median(matrixRuns.map((run) => run.fps_p50));
+  const sliceP50 = median(sliceRuns.map((run) => run.fps_p50));
+  const matrixP99 = median(matrixRuns.map((run) => run.frame_time_p99_ms));
+  const sliceP99 = median(sliceRuns.map((run) => run.frame_time_p99_ms));
+
+  return {
+    model: String(data.model ?? fallbackName).replace(/\.vox$/, ""),
+    source,
+    runs: Math.min(matrixRuns.length, sliceRuns.length),
+    winner: winnerFor(matrixP95 - sliceP95, sliceP99 - matrixP99),
+    matrixP50,
+    sliceP50,
+    matrixP95,
+    sliceP95,
+    matrixP99,
+    sliceP99,
+    deltaP95: matrixP95 - sliceP95,
+    deltaP99: sliceP99 - matrixP99,
+    matrix4Plus: median(matrixRuns.map(cadence4Plus)),
+    slice4Plus: median(sliceRuns.map(cadence4Plus)),
+    activeLeaves: slice.dom?.leaves ?? null,
+    matrixNodes: median(matrixRuns.map((run) => run.performanceMetrics?.Nodes)),
+    sliceNodes: median(sliceRuns.map((run) => run.performanceMetrics?.Nodes)),
+    planes: brush.depthPlaneCount ?? null,
+    colors: brush.colorCount ?? null,
+    areaK: Number.isFinite(brush.localAreaTotal) ? Math.round(brush.localAreaTotal / 1000) : null,
+    fill: brush.localPlaneFillRatio ?? null,
+    screenFill: brush.screenFillRatio ?? null,
+    dimensions: [meta.rows, meta.cols, meta.depth].every(Number.isFinite)
+      ? `${meta.rows}x${meta.cols}x${meta.depth}`
+      : "",
+    browser: matrixRuns[0]?.browserVersion ?? "",
+  };
+}
+
+function printCadenceReport(rows) {
+  const groups = new Map();
+  for (const row of rows) {
+    const list = groups.get(row.winner) ?? [];
+    list.push(row);
+    groups.set(row.winner, list);
+  }
+
+  console.log("# Voxel Cadence Corpus\n");
+  console.log(`Models: ${rows.length}\n`);
+  for (const key of ["matrix", "slice", "matrix-p99", "slice-p99", "flat"]) {
+    const list = groups.get(key) ?? [];
+    console.log(`- ${key}: ${list.length}${list.length ? ` (${list.map((row) => row.model).join(", ")})` : ""}`);
+  }
+
+  console.log("\n## Strong Winners\n");
+  console.log("| Model | Winner | Source | Runs | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 | Matrix 4x+ | Slice 4x+ | Leaves | Nodes M/S | Planes | Colors | AreaK | Fill | Screen | Dims |");
+  console.log("| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: | ---: | ---: | ---: | ---: | --- |");
+  for (const row of rows
+    .filter((candidate) => candidate.winner === "matrix" || candidate.winner === "slice")
+    .sort((a, b) => Math.abs(b.deltaP95) - Math.abs(a.deltaP95))) {
+    console.log([
+      `| ${row.model}`,
+      row.winner,
+      row.source,
+      row.runs,
+      fmt(row.matrixP95),
+      fmt(row.sliceP95),
+      fmt(row.matrixP99),
+      fmt(row.sliceP99),
+      fmt(row.matrix4Plus),
+      fmt(row.slice4Plus),
+      row.activeLeaves ?? "",
+      `${fmt(row.matrixNodes, 0)}/${fmt(row.sliceNodes, 0)}`,
+      row.planes ?? "",
+      row.colors ?? "",
+      row.areaK ?? "",
+      fmt(row.fill, 3),
+      fmt(row.screenFill, 3),
+      `${row.dimensions} |`,
+    ].join(" | "));
+  }
+
+  console.log("\n## P50/P99 Splits Within Flat p95\n");
+  console.log("| Model | Source | Runs | Matrix p50 | Slice p50 | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 | Leaves | Screen |");
+  console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
+  for (const row of rows
+    .filter((candidate) =>
+      candidate.winner === "flat" &&
+      (Math.abs(candidate.matrixP50 - candidate.sliceP50) >= 20 || Math.abs(candidate.deltaP99) >= 5)
+    )
+    .sort((a, b) => Math.abs(b.deltaP99) - Math.abs(a.deltaP99))) {
+    console.log([
+      `| ${row.model}`,
+      row.source,
+      row.runs,
+      fmt(row.matrixP50),
+      fmt(row.sliceP50),
+      fmt(row.matrixP95),
+      fmt(row.sliceP95),
+      fmt(row.matrixP99),
+      fmt(row.sliceP99),
+      row.activeLeaves ?? "",
+      `${fmt(row.screenFill, 3)} |`,
+    ].join(" | "));
+  }
+}
+
+function matchesBrowserPrefix(file, prefix, selectedPrefixes) {
+  if (!file.startsWith(`${prefix}-`) || !file.endsWith("-rotation-compare.json")) return false;
+  return !selectedPrefixes.some((other) =>
+    other !== prefix &&
+    other.startsWith(`${prefix}-`) &&
+    file.startsWith(`${other}-`)
+  );
+}
+
+async function printBrowserReport(resultDir, prefixes) {
+  const files = await readdir(resultDir);
+  for (const prefix of prefixes) {
+    const rows = [];
+    for (const file of files) {
+      if (!matchesBrowserPrefix(file, prefix, prefixes)) continue;
+      const data = JSON.parse(await readFile(join(resultDir, file), "utf8"));
+      const row = summarizeRotationCompare(data, file);
+      if (row) rows.push(row);
+    }
+
+    rows.sort((a, b) => a.model.localeCompare(b.model));
+    console.log(`\n## ${prefix}${rows[0]?.browser ? ` (${rows[0].browser})` : ""}\n`);
+    console.log("| Model | Winner | Runs | Matrix p95 | Slice p95 | Matrix p99 | Slice p99 |");
+    console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: |");
+    for (const row of rows) {
+      console.log([
+        `| ${row.model}`,
+        row.winner,
+        row.runs,
+        fmt(row.matrixP95),
+        fmt(row.sliceP95),
+        fmt(row.matrixP99),
+        `${fmt(row.sliceP99)} |`,
+      ].join(" | "));
+    }
+  }
+}
+
+try {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.mode === "cadence" || args.mode === "all") {
+    printCadenceReport(await loadCadenceRows(args.resultDir));
+  }
+  if (args.mode === "browser" || args.mode === "all") {
+    if (args.mode === "all") console.log("\n---\n");
+    await printBrowserReport(args.resultDir, args.browserPrefixes);
+  }
+} catch (error) {
+  console.error(`[voxel-report] ${error.message}`);
+  process.exit(1);
+}
diff --git a/bench/voxel-static-metrics.mjs b/bench/voxel-static-metrics.mjs
deleted file mode 100644
index df89f380..00000000
--- a/bench/voxel-static-metrics.mjs
+++ /dev/null
@@ -1,607 +0,0 @@
-#!/usr/bin/env node
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import {
-  BASE_TILE,
-  buildPolyVoxelFaceData,
-  buildPolyVoxelSlicePlan,
-  normalFacesCamera,
-  parsePureColor,
-  parseVox,
-  POLY_VOXEL_NEXT_LAYER_STEP,
-} from "../packages/core/dist/index.js";
-
-const repoRoot = resolve(import.meta.dirname, "..");
-const voxDir = process.argv[2] ?? resolve(repoRoot, "website/public/gallery/vox");
-const resultDir = process.argv[3] ?? resolve(repoRoot, "bench/results");
-
-const ROTATION = { rotX: 65, rotY: 45 };
-const DIRECTIONAL_LIGHT = { direction: dirFromAzEl(50, 45), color: "#ffffff", intensity: 1 };
-const AMBIENT_LIGHT = { color: "#ffffff", intensity: 0.4 };
-
-const FACE_NORMALS = {
-  t: [0, 0, 1],
-  b: [0, 0, -1],
-  fl: [0, 1, 0],
-  br: [0, -1, 0],
-  fr: [1, 0, 0],
-  bl: [-1, 0, 0],
-};
-
-const FACE_BY_NORMAL = new Map([
-  ["0,0,1", "t"],
-  ["0,0,-1", "b"],
-  ["0,1,0", "fl"],
-  ["0,-1,0", "br"],
-  ["1,0,0", "fr"],
-  ["-1,0,0", "bl"],
-]);
-
-const FILE_PATTERNS = [
-  [/^cadence-clean-(.*)-rotation-compare\.json$/, 1, "clean"],
-  [/^cadence-wide-(.*)-rotation-compare\.json$/, 2, "wide"],
-  [/^cadence-extended-(.*)-rotation-compare\.json$/, 3, "extended"],
-  [/^cadence-validate-(.*)-rotation-compare\.json$/, 4, "validated"],
-];
-
-function dirFromAzEl(azDeg, elDeg) {
-  const az = (azDeg * Math.PI) / 180;
-  const el = (elDeg * Math.PI) / 180;
-  const cosEl = Math.cos(el);
-  return [cosEl * Math.sin(az), cosEl * Math.cos(az), Math.sin(el)];
-}
-
-function quantile(values, q) {
-  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
-  if (sorted.length === 0) return null;
-  const i = (sorted.length - 1) * q;
-  const lo = Math.floor(i);
-  const hi = Math.ceil(i);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (i - lo);
-}
-
-function median(values) {
-  return quantile(values, 0.5);
-}
-
-function fmt(value, digits = 1) {
-  return Number.isFinite(value) ? value.toFixed(digits) : "";
-}
-
-function canonicalModelKey(file) {
-  return basename(file, ".vox").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-function resultModelKey(model) {
-  return String(model ?? "").replace(/\.vox$/, "").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-function winnerFor(deltaP95, deltaP99) {
-  if (Math.abs(deltaP95) >= 8) return deltaP95 > 0 ? "matrix" : "slice";
-  if (Math.abs(deltaP99) >= 8) return deltaP99 > 0 ? "matrix-p99" : "slice-p99";
-  return "flat";
-}
-
-function parseColor(input) {
-  const parsed = parsePureColor(input);
-  if (!parsed) return { r: 255, g: 255, b: 255, alpha: 1 };
-  return { r: parsed.rgb[0], g: parsed.rgb[1], b: parsed.rgb[2], alpha: parsed.alpha };
-}
-
-function rgbToHex({ r, g, b }) {
-  const f = (n) => Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
-  return `#${f(r)}${f(g)}${f(b)}`;
-}
-
-function clampChannel(value) {
-  return Math.round(Math.max(0, Math.min(255, value)));
-}
-
-function shadeBrushColor(normal, baseColor) {
-  const base = parseColor(baseColor);
-  const light = parseColor(DIRECTIONAL_LIGHT.color);
-  const ambient = parseColor(AMBIENT_LIGHT.color);
-  const lightDir = DIRECTIONAL_LIGHT.direction;
-  const lightLen = Math.hypot(lightDir[0], lightDir[1], lightDir[2]) || 1;
-  const lx = lightDir[0] / lightLen;
-  const ly = lightDir[1] / lightLen;
-  const lz = lightDir[2] / lightLen;
-  const directScale = Math.max(0, DIRECTIONAL_LIGHT.intensity) *
-    Math.max(0, normal[0] * lx + normal[1] * ly + normal[2] * lz);
-  const tintR = (ambient.r / 255) * AMBIENT_LIGHT.intensity + (light.r / 255) * directScale;
-  const tintG = (ambient.g / 255) * AMBIENT_LIGHT.intensity + (light.g / 255) * directScale;
-  const tintB = (ambient.b / 255) * AMBIENT_LIGHT.intensity + (light.b / 255) * directScale;
-  const shaded = {
-    r: base.r * tintR,
-    g: base.g * tintG,
-    b: base.b * tintB,
-    alpha: base.alpha,
-  };
-  return shaded.alpha < 1
-    ? `rgba(${clampChannel(shaded.r)}, ${clampChannel(shaded.g)}, ${clampChannel(shaded.b)}, ${shaded.alpha})`
-    : rgbToHex(shaded);
-}
-
-function cssNormalForPolygon(polygon) {
-  const vertices = polygon.vertices;
-  if (vertices.length < 3) return null;
-  const v0 = vertices[0];
-  let nx = 0;
-  let ny = 0;
-  let nz = 0;
-  for (let i = 1; i + 1 < vertices.length; i += 1) {
-    const v1 = vertices[i];
-    const v2 = vertices[i + 1];
-    const e1x = v1[1] - v0[1];
-    const e1y = v1[0] - v0[0];
-    const e1z = v1[2] - v0[2];
-    const e2x = v2[1] - v0[1];
-    const e2y = v2[0] - v0[0];
-    const e2z = v2[2] - v0[2];
-    nx -= e1y * e2z - e1z * e2y;
-    ny -= e1z * e2x - e1x * e2z;
-    nz -= e1x * e2y - e1y * e2x;
-  }
-  const len = Math.hypot(nx, ny, nz);
-  if (len <= 1e-9) return null;
-  return [
-    Math.round(nx / len),
-    Math.round(ny / len),
-    Math.round(nz / len),
-  ];
-}
-
-function polygonBrush(polygon) {
-  if (polygon.texture || polygon.material || polygon.uvs || polygon.textureTriangles) return null;
-  if (polygon.vertices.length !== 4) return null;
-  const normal = cssNormalForPolygon(polygon);
-  const face = normal ? FACE_BY_NORMAL.get(normal.join(",")) : undefined;
-  if (!face) return null;
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const v of polygon.vertices) {
-    minX = Math.min(minX, v[0]);
-    minY = Math.min(minY, v[1]);
-    minZ = Math.min(minZ, v[2]);
-    maxX = Math.max(maxX, v[0]);
-    maxY = Math.max(maxY, v[1]);
-    maxZ = Math.max(maxZ, v[2]);
-  }
-
-  const eps = 1e-6;
-  const baseColor = polygon.color || "#cccccc";
-  if (Math.abs(maxZ - minZ) <= eps) {
-    return {
-      axis: "z",
-      face,
-      left: minY * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: minZ * BASE_TILE,
-      baseColor,
-    };
-  }
-  if (Math.abs(maxX - minX) <= eps) {
-    return {
-      axis: "x",
-      face,
-      left: minY * BASE_TILE,
-      top: minZ * BASE_TILE,
-      width: Math.max(0, (maxY - minY) * BASE_TILE),
-      height: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      z: -minX * BASE_TILE,
-      baseColor,
-    };
-  }
-  if (Math.abs(maxY - minY) <= eps) {
-    return {
-      axis: "y",
-      face,
-      left: minZ * BASE_TILE,
-      top: minX * BASE_TILE,
-      width: Math.max(0, (maxZ - minZ) * BASE_TILE),
-      height: Math.max(0, (maxX - minX) * BASE_TILE),
-      z: -minY * BASE_TILE,
-      baseColor,
-    };
-  }
-  return null;
-}
-
-function buildPolygonPlans(polygons) {
-  const plans = new Map();
-  let accepted = 0;
-  for (const polygon of polygons) {
-    const brush = polygonBrush(polygon);
-    if (!brush || brush.width <= 0 || brush.height <= 0) continue;
-    accepted += 1;
-    const key = `${brush.axis}:${brush.face}`;
-    let plan = plans.get(key);
-    if (!plan) {
-      plan = { axis: brush.axis, face: brush.face, brushes: [] };
-      plans.set(key, plan);
-    }
-    plan.brushes.push(brush);
-  }
-  return accepted === polygons.length ? Array.from(plans.values()) : [];
-}
-
-function planBrushZ(plan, cellPx) {
-  const plane = plan.key.plane * cellPx;
-  return plan.key.axis === "z" ? plane : -plane;
-}
-
-function buildMergedPlans(source, cellPx) {
-  const faces = buildPolyVoxelFaceData(source);
-  const faceIndex = new Map();
-  for (const face of faces) {
-    faceIndex.set(`${face.key.axis}:${face.key.plane}:${face.key.face}`, face);
-  }
-  return faces.map((face) => {
-    const nextPlane = face.key.plane + POLY_VOXEL_NEXT_LAYER_STEP[face.key.face];
-    const nextFace = faceIndex.get(`${face.key.axis}:${nextPlane}:${face.key.face}`);
-    const plan = buildPolyVoxelSlicePlan(face, nextFace?.buffer ?? null);
-    const z = planBrushZ(plan, cellPx);
-    return {
-      axis: plan.key.axis,
-      face: plan.key.face,
-      brushes: plan.brushes.map((brush) => ({
-        left: (plan.buffer.minCol + brush.c0) * cellPx,
-        top: (plan.buffer.minRow + brush.r0) * cellPx,
-        width: (brush.c1 - brush.c0) * cellPx,
-        height: (brush.r1 - brush.r0) * cellPx,
-        z,
-        baseColor: brush.baseColor,
-      })),
-    };
-  });
-}
-
-function rectUnionArea(rects) {
-  if (!rects.length) return 0;
-  const xs = [...new Set(rects.flatMap((rect) => [rect.left, rect.right]))].sort((a, b) => a - b);
-  let area = 0;
-  for (let i = 0; i < xs.length - 1; i += 1) {
-    const x0 = xs[i];
-    const x1 = xs[i + 1];
-    if (x1 <= x0) continue;
-    const intervals = [];
-    for (const rect of rects) {
-      if (rect.left < x1 && rect.right > x0) intervals.push([rect.top, rect.bottom]);
-    }
-    intervals.sort((a, b) => a[0] - b[0]);
-    let covered = 0;
-    let start = -Infinity;
-    let end = -Infinity;
-    for (const interval of intervals) {
-      if (interval[0] > end) {
-        if (Number.isFinite(end)) covered += end - start;
-        start = interval[0];
-        end = interval[1];
-      } else {
-        end = Math.max(end, interval[1]);
-      }
-    }
-    if (Number.isFinite(end)) covered += end - start;
-    area += (x1 - x0) * covered;
-  }
-  return area;
-}
-
-function brushMetrics(plans) {
-  const visibleFaces = new Set(
-    Object.entries(FACE_NORMALS)
-      .filter(([, normal]) => normalFacesCamera(normal, ROTATION))
-      .map(([face]) => face)
-  );
-  const activeRects = [];
-  const allRects = [];
-  const visibleBaseColors = new Set();
-  const visibleShadedColors = new Set();
-  const allBaseColors = new Set();
-  const visiblePlanes = new Set();
-  const allPlanes = new Set();
-  const faceCounts = {};
-  for (const plan of plans) {
-    const normal = FACE_NORMALS[plan.face];
-    const visible = visibleFaces.has(plan.face);
-    for (const brush of plan.brushes) {
-      const rect = {
-        axis: plan.axis,
-        plane: Number(brush.z.toFixed(3)),
-        left: brush.left,
-        top: brush.top,
-        right: brush.left + brush.width,
-        bottom: brush.top + brush.height,
-        width: brush.width,
-        height: brush.height,
-        area: brush.width * brush.height,
-      };
-      allRects.push(rect);
-      allBaseColors.add(brush.baseColor);
-      allPlanes.add(`${plan.axis}:${rect.plane}`);
-      faceCounts[plan.face] = (faceCounts[plan.face] ?? 0) + 1;
-      if (!visible) continue;
-      activeRects.push(rect);
-      visibleBaseColors.add(brush.baseColor);
-      visibleShadedColors.add(shadeBrushColor(normal, brush.baseColor));
-      visiblePlanes.add(`${plan.axis}:${rect.plane}`);
-    }
-  }
-
-  const activeArea = activeRects.reduce((sum, rect) => sum + rect.area, 0);
-  const byPlane = new Map();
-  for (const rect of activeRects) {
-    const key = `${rect.axis}:${rect.plane}`;
-    const list = byPlane.get(key) ?? [];
-    list.push(rect);
-    byPlane.set(key, list);
-  }
-  let unionArea = 0;
-  let planeBoundsArea = 0;
-  for (const list of byPlane.values()) {
-    unionArea += rectUnionArea(list);
-    const minX = Math.min(...list.map((rect) => rect.left));
-    const minY = Math.min(...list.map((rect) => rect.top));
-    const maxX = Math.max(...list.map((rect) => rect.right));
-    const maxY = Math.max(...list.map((rect) => rect.bottom));
-    planeBoundsArea += Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
-  }
-
-  return {
-    totalBrushes: allRects.length,
-    activeBrushes: activeRects.length,
-    allBaseColors: allBaseColors.size,
-    visibleBaseColors: visibleBaseColors.size,
-    visibleShadedColors: visibleShadedColors.size,
-    allPlanes: allPlanes.size,
-    visiblePlanes: visiblePlanes.size,
-    activeArea,
-    activeAreaK: Math.round(activeArea / 1000),
-    activeUnionArea: Math.round(unionArea),
-    activePlaneFillRatio: planeBoundsArea ? +(activeArea / planeBoundsArea).toFixed(3) : null,
-    faceCounts,
-  };
-}
-
-async function loadCadenceRows() {
-  const selected = new Map();
-  for (const file of await readdir(resultDir)) {
-    let matchInfo = null;
-    for (const [pattern, priority, label] of FILE_PATTERNS) {
-      const match = pattern.exec(file);
-      if (match) {
-        matchInfo = { key: match[1], priority, label };
-        break;
-      }
-    }
-    if (!matchInfo) continue;
-    const path = join(resultDir, file);
-    const mtime = (await stat(path)).mtimeMs;
-    const current = selected.get(matchInfo.key);
-    if (!current || matchInfo.priority > current.priority || (matchInfo.priority === current.priority && mtime > current.mtime)) {
-      selected.set(matchInfo.key, { ...matchInfo, path, mtime });
-    }
-  }
-
-  const rows = new Map();
-  for (const entry of selected.values()) {
-    const data = JSON.parse(await readFile(entry.path, "utf8"));
-    const matrixRuns = data.cases?.["polycss-matrix"]?.runs ?? [];
-    const sliceRuns = data.cases?.["polycss-baked-voxzoom"]?.runs ?? [];
-    if (matrixRuns.length === 0 || sliceRuns.length === 0) continue;
-    const matrixP95 = median(matrixRuns.map((run) => run.fps_p95));
-    const sliceP95 = median(sliceRuns.map((run) => run.fps_p95));
-    const matrixP99 = median(matrixRuns.map((run) => run.frame_time_p99_ms));
-    const sliceP99 = median(sliceRuns.map((run) => run.frame_time_p99_ms));
-    const deltaP95 = matrixP95 - sliceP95;
-    const deltaP99 = sliceP99 - matrixP99;
-    const model = resultModelKey(data.model ?? entry.key);
-    rows.set(model, {
-      source: entry.label,
-      runs: Math.min(matrixRuns.length, sliceRuns.length),
-      winner: winnerFor(deltaP95, deltaP99),
-      matrixP95,
-      sliceP95,
-      matrixP99,
-      sliceP99,
-      deltaP95,
-      deltaP99,
-    });
-  }
-  return rows;
-}
-
-async function analyzeVoxFile(path) {
-  const bytes = await readFile(path);
-  const parsed = parseVox(
-    bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-    { targetSize: 70, gridShift: 0 },
-  );
-  const source = parsed.voxelSource;
-  const sourceColors = new Set((source?.cells ?? []).map((cell) => cell.color));
-  const cellPx = source ? Math.max(1, Math.round(source.scale * BASE_TILE)) : BASE_TILE;
-  const polygonPlans = buildPolygonPlans(parsed.polygons);
-  const plans = polygonPlans.length > 0 ? polygonPlans : (source ? buildMergedPlans(source, cellPx) : []);
-  const metrics = brushMetrics(plans);
-  return {
-    file: basename(path),
-    key: canonicalModelKey(path),
-    rows: source?.rows ?? null,
-    cols: source?.cols ?? null,
-    depth: source?.depth ?? null,
-    maxDim: source ? Math.max(source.rows, source.cols, source.depth) : null,
-    cellPx,
-    sourceBytes: source?.sourceBytes ?? bytes.byteLength,
-    voxels: source?.cells.length ?? parsed.metadata?.voxelCount ?? null,
-    polygons: parsed.polygons.length,
-    sourceColors: sourceColors.size,
-    planner: polygonPlans.length > 0 ? "polygons" : "source",
-    ...metrics,
-  };
-}
-
-const cadenceRows = await loadCadenceRows();
-const files = (await readdir(voxDir))
-  .filter((file) => file.toLowerCase().endsWith(".vox"))
-  .sort((a, b) => a.localeCompare(b));
-
-const staticRows = [];
-for (const file of files) {
-  staticRows.push(await analyzeVoxFile(join(voxDir, file)));
-}
-
-const joined = staticRows.map((row) => ({ ...row, cadence: cadenceRows.get(row.key) ?? null }));
-const tested = joined.filter((row) => row.cadence);
-const strong = tested.filter((row) => ["matrix", "slice"].includes(row.cadence.winner));
-const untested = joined.filter((row) => !row.cadence);
-
-console.log("# Voxel Static Metrics\n");
-console.log(`Models scanned: ${joined.length}`);
-console.log(`Models with cadence: ${tested.length}`);
-console.log(`Strong cadence winners: ${strong.length}\n`);
-
-console.log("## Strong Winners Joined To Static Metrics\n");
-console.log("| Model | Winner | Runs | Matrix p95 | Slice p95 | Active | Total | Source colors | Visible base | Visible shaded | Planes | AreaK | Fill | Dims |");
-console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |");
-for (const row of strong.sort((a, b) => Math.abs(b.cadence.deltaP95) - Math.abs(a.cadence.deltaP95))) {
-  console.log([
-    `| ${basename(row.file, ".vox")}`,
-    row.cadence.winner,
-    row.cadence.runs,
-    fmt(row.cadence.matrixP95),
-    fmt(row.cadence.sliceP95),
-    row.activeBrushes,
-    row.totalBrushes,
-    row.sourceColors,
-    row.visibleBaseColors,
-    row.visibleShadedColors,
-    row.visiblePlanes,
-    row.activeAreaK,
-    fmt(row.activePlaneFillRatio, 3),
-    `${row.rows}x${row.cols}x${row.depth} |`,
-  ].join(" | "));
-}
-
-const highShadedCutoff = 52;
-const highShaded = tested.filter((row) => row.visibleShadedColors >= highShadedCutoff);
-console.log(`\n## Diagnostic Rule: visibleShadedColors >= ${highShadedCutoff}\n`);
-const highShadedGroups = new Map();
-for (const row of highShaded) {
-  const key = row.cadence.winner;
-  highShadedGroups.set(key, (highShadedGroups.get(key) ?? 0) + 1);
-}
-const strongMatrixRows = tested.filter((row) => row.cadence.winner === "matrix");
-const strongSliceRows = tested.filter((row) => row.cadence.winner === "slice");
-const capturedMatrixRows = strongMatrixRows.filter((row) => row.visibleShadedColors >= highShadedCutoff);
-const hitSliceRows = strongSliceRows.filter((row) => row.visibleShadedColors >= highShadedCutoff);
-const adaptiveRows = tested.map((row) => {
-  const useMatrix = row.visibleShadedColors >= highShadedCutoff;
-  return {
-    row,
-    useMatrix,
-    p95DeltaVsSlice: useMatrix ? row.cadence.matrixP95 - row.cadence.sliceP95 : 0,
-    p99DeltaVsSlice: useMatrix ? row.cadence.sliceP99 - row.cadence.matrixP99 : 0,
-  };
-});
-const p95Gains = adaptiveRows.filter((item) => item.p95DeltaVsSlice >= 8);
-const p95Losses = adaptiveRows.filter((item) => item.p95DeltaVsSlice <= -8);
-const p99Gains = adaptiveRows.filter((item) => item.p99DeltaVsSlice >= 5);
-const p99Losses = adaptiveRows.filter((item) => item.p99DeltaVsSlice <= -5);
-function scoreRule(predicate) {
-  const rows = tested.map((row) => {
-    const useMatrix = predicate(row);
-    return {
-      row,
-      useMatrix,
-      p95DeltaVsSlice: useMatrix ? row.cadence.matrixP95 - row.cadence.sliceP95 : 0,
-      p99DeltaVsSlice: useMatrix ? row.cadence.sliceP99 - row.cadence.matrixP99 : 0,
-    };
-  });
-  return {
-    hits: rows.filter((item) => item.useMatrix),
-    p95Gains: rows.filter((item) => item.p95DeltaVsSlice >= 8),
-    p95Losses: rows.filter((item) => item.p95DeltaVsSlice <= -8),
-    p99Gains: rows.filter((item) => item.p99DeltaVsSlice >= 5),
-    p99Losses: rows.filter((item) => item.p99DeltaVsSlice <= -5),
-  };
-}
-const refinedScore = scoreRule((row) =>
-  row.visibleShadedColors >= highShadedCutoff && row.visiblePlanes < 200
-);
-console.log(`- Hits ${highShaded.length} tested models: ${
-  [...highShadedGroups.entries()].map(([key, count]) => `${key}=${count}`).join(", ")
-}`);
-console.log(`- Captures ${capturedMatrixRows.length}/${strongMatrixRows.length} strong matrix wins: ${
-  capturedMatrixRows.map((row) => basename(row.file, ".vox")).join(", ") || "none"
-}`);
-console.log(`- Hits ${hitSliceRows.length}/${strongSliceRows.length} strong slice wins: ${
-  hitSliceRows.map((row) => basename(row.file, ".vox")).join(", ") || "none"
-}`);
-console.log(`- Adaptive p95 gains/losses vs always-slice: +${p95Gains.length}/-${p95Losses.length}`);
-console.log(`- Adaptive p99 gains/losses vs always-slice: +${p99Gains.length}/-${p99Losses.length}${
-  p99Losses.length ? ` (${p99Losses.map((item) => basename(item.row.file, ".vox")).join(", ")})` : ""
-}`);
-console.log(`- Refined visibleShadedColors >= ${highShadedCutoff} && visiblePlanes < 200: ` +
-  `hits=${refinedScore.hits.length}, p95 +${refinedScore.p95Gains.length}/-${refinedScore.p95Losses.length}, ` +
-  `p99 +${refinedScore.p99Gains.length}/-${refinedScore.p99Losses.length}\n`);
-console.log("| Model | Winner | Runs | Visible shaded | Delta p95 | Matrix p95 | Slice p95 |");
-console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: |");
-for (const row of highShaded.sort((a, b) => b.visibleShadedColors - a.visibleShadedColors)) {
-  console.log([
-    `| ${basename(row.file, ".vox")}`,
-    row.cadence.winner,
-    row.cadence.runs,
-    row.visibleShadedColors,
-    fmt(row.cadence.deltaP95),
-    fmt(row.cadence.matrixP95),
-    fmt(row.cadence.sliceP95),
-    "|",
-  ].join(" | "));
-}
-
-const suggested = [
-  ...untested
-    .filter((row) => row.visibleShadedColors >= highShadedCutoff)
-    .sort((a, b) => b.visibleShadedColors - a.visibleShadedColors || b.activeBrushes - a.activeBrushes)
-    .slice(0, 8),
-  ...untested
-    .filter((row) => row.visibleShadedColors < highShadedCutoff)
-    .sort((a, b) => b.activeBrushes - a.activeBrushes)
-    .slice(0, 8),
-  ...untested
-    .filter((row) => row.visibleShadedColors < highShadedCutoff)
-    .sort((a, b) => b.activePlaneFillRatio - a.activePlaneFillRatio)
-    .slice(0, 8),
-];
-const dedupedSuggested = Array.from(new Map(suggested.map((row) => [row.key, row])).values());
-
-console.log("\n## Suggested Bench Additions\n");
-console.log("| Model | Reason | Active | Total | Source colors | Visible shaded | Planes | AreaK | Fill | Dims |");
-console.log("| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |");
-for (const row of dedupedSuggested.slice(0, 20)) {
-  const reason = row.visibleShadedColors >= highShadedCutoff
-    ? "high shaded colors"
-    : row.activePlaneFillRatio >= 0.18
-      ? "high plane fill"
-      : "high active brushes";
-  console.log([
-    `| ${basename(row.file, ".vox")}`,
-    reason,
-    row.activeBrushes,
-    row.totalBrushes,
-    row.sourceColors,
-    row.visibleShadedColors,
-    row.visiblePlanes,
-    row.activeAreaK,
-    fmt(row.activePlaneFillRatio, 3),
-    `${row.rows}x${row.cols}x${row.depth} |`,
-  ].join(" | "));
-}
diff --git a/package.json b/package.json
index 020a129e..f82a0320 100644
--- a/package.json
+++ b/package.json
@@ -22,7 +22,7 @@
     "build:packages": "pnpm --filter './packages/*' -r build",
     "test": "pnpm --filter './packages/*' -r --if-present test",
     "test:coverage": "pnpm --filter './packages/*' -r --if-present test:coverage",
-    "sync:readmes": "node tools/sync-package-readmes.mjs",
+    "sync:readmes": "node .github/scripts/sync-package-readmes.mjs",
     "publish:all": "pnpm sync:readmes && pnpm --filter './packages/*' -r publish --access public",
     "dev:website": "pnpm --filter @layoutit/polycss-website dev",
     "build:website": "pnpm --filter @layoutit/polycss-website build",
@@ -31,7 +31,10 @@
     "bench:perf": "node bench/build.mjs && node bench/perf-bench.mjs",
     "bench:animated-human": "node bench/build.mjs && node bench/animated-human-bench.mjs",
     "bench:nonvoxel-drag-trace": "node bench/build.mjs && node bench/nonvoxel-drag-trace.mjs",
+    "bench:trace": "node bench/build.mjs && node bench/trace-analysis.mjs",
     "bench:lossy": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-optimizer-bench.mjs",
+    "bench:lossy:corpus": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-corpus-bench.mjs",
+    "bench:voxel-report": "node bench/voxel-report.mjs",
     "bench:visual": "node bench/build.mjs && node bench/perf-visual.mjs"
   },
   "pnpm": {
diff --git a/packages/core/package.json b/packages/core/package.json
index 4b44512b..9a68dd54 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -31,7 +31,7 @@
     "build": "tsup",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
-    "prepack": "node ../../tools/sync-package-readmes.mjs",
+    "prepack": "node ../../.github/scripts/sync-package-readmes.mjs",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {
diff --git a/packages/core/src/merge/coverPlanarPolygons.ts b/packages/core/src/merge/coverPlanarPolygons.ts
index fddb63c6..29206a58 100644
--- a/packages/core/src/merge/coverPlanarPolygons.ts
+++ b/packages/core/src/merge/coverPlanarPolygons.ts
@@ -57,6 +57,9 @@ const DEFAULT_PLANE_EPSILON = 1e-3;
 const EPS = 1e-9;
 const LOCAL_ROUND = 1e6;
 const WORLD_ROUND = 1e6;
+// Highly fragmented scanline covers spend most time merging cells and usually
+// expand back past the source group; tiny groups can still collapse to one leaf.
+const MAX_LOCAL_CELL_GROUP_RATIO = 8;
 
 const sub = (a: Vec3, b: Vec3): Vec3 => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 const add = (a: Vec3, b: Vec3): Vec3 => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
@@ -583,6 +586,7 @@ function mergeLocalCells(cells: Vec2[][]): Vec2[][] {
     changed = false;
     for (let i = 0; i < polygons.length; i++) {
       for (let j = i + 1; j < polygons.length; j++) {
+        if (!localBBoxesCanTouch(bboxes[i], bboxes[j])) continue;
         const merged = unionConvexLocalPair(polygons[i], polygons[j], bboxes[i], bboxes[j]);
         if (!merged) continue;
         polygons[i] = merged;
@@ -685,6 +689,7 @@ function decomposeWithAxis(
   }
 
   if (localCells.length === 0) return null;
+  if (group.length > 2 && localCells.length > group.length * MAX_LOCAL_CELL_GROUP_RATIO) return null;
   const toWorld = localToWorldFactory(origin, xAxisProjected, yAxis);
   const cells = mergeLocalCells(localCells).map((local): Polygon => ({
     vertices: local.map(toWorld),
diff --git a/packages/core/src/merge/mergePolygons.test.ts b/packages/core/src/merge/mergePolygons.test.ts
index 57b4821a..1ed9e98c 100644
--- a/packages/core/src/merge/mergePolygons.test.ts
+++ b/packages/core/src/merge/mergePolygons.test.ts
@@ -476,6 +476,28 @@ describe("mergePolygons", () => {
       expect(result).toHaveLength(1);
       expect(result[0].vertices).toHaveLength(6);
     });
+
+    it("does not grow unbounded rings on large coplanar fans", () => {
+      const tris: Polygon[] = [];
+      const segments = 160;
+      const ring: Vec3[] = [];
+      for (let i = 0; i < segments; i++) {
+        const angle = (i / segments) * Math.PI * 2;
+        ring.push([Math.cos(angle), Math.sin(angle), 0]);
+      }
+      for (let i = 0; i < segments; i++) {
+        tris.push({
+          vertices: [[0, 0, 0], ring[i], ring[(i + 1) % segments]],
+          color: "#abc",
+        });
+      }
+
+      const result = mergePolygons(tris);
+
+      expect(result.length).toBeGreaterThan(1);
+      expect(result.length).toBeLessThan(tris.length);
+      expect(Math.max(...result.map((polygon) => polygon.vertices.length))).toBeLessThanOrEqual(96);
+    });
   });
 
   describe("output structure", () => {
diff --git a/packages/core/src/merge/mergePolygons.ts b/packages/core/src/merge/mergePolygons.ts
index b1308b80..1ab01685 100644
--- a/packages/core/src/merge/mergePolygons.ts
+++ b/packages/core/src/merge/mergePolygons.ts
@@ -31,6 +31,9 @@ const EPS_NORMAL = 1e-3;   // dot product tolerance for "same plane"
 const EPS_DISTANCE = 0.05; // signed-distance tolerance (in scene-space units)
 const EPS_TEXTURE_DISTANCE = 1e-3;
 const EPS_RENDER_DISTANCE = 1e-3;
+const MAX_MERGED_VERTEX_COUNT = 96;
+const MERGE_WORK_UNIT_LIMIT = 8_000_000;
+const MERGE_PASS_LIMIT = 16;
 
 interface PolyState {
   vertices: Vec3[];
@@ -48,11 +51,18 @@ interface PolyState {
   normal: Vec3;
   /** Plane offset: distance from origin along the normal. */
   d: number;
+  directedEdges: Set<string>;
   alive: boolean;
   /** Original Polygon's `data` field, preserved through the merge. */
   data?: Record<string, string | number | boolean>;
 }
 
+interface EdgeOwners {
+  a: Vec3;
+  b: Vec3;
+  owners: number[];
+}
+
 const sub = (a: Vec3, b: Vec3): Vec3 => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 const cross = (a: Vec3, b: Vec3): Vec3 => [
   a[1] * b[2] - a[2] * b[1],
@@ -65,12 +75,28 @@ const eqVec = (a: Vec3, b: Vec3): boolean =>
   a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
 
 /** Canonical key for an undirected edge between two vertex positions. */
+function vertexKey(vertex: Vec3): string {
+  return `${vertex[0]},${vertex[1]},${vertex[2]}`;
+}
+
 function edgeKey(a: Vec3, b: Vec3): string {
-  const ka = `${a[0]},${a[1]},${a[2]}`;
-  const kb = `${b[0]},${b[1]},${b[2]}`;
+  const ka = vertexKey(a);
+  const kb = vertexKey(b);
   return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
 }
 
+function directedEdgeKey(a: Vec3, b: Vec3): string {
+  return `${vertexKey(a)}>${vertexKey(b)}`;
+}
+
+function directedEdgeSet(vertices: Vec3[]): Set<string> {
+  const edges = new Set<string>();
+  for (let k = 0; k < vertices.length; k++) {
+    edges.add(directedEdgeKey(vertices[k], vertices[(k + 1) % vertices.length]));
+  }
+  return edges;
+}
+
 function planeOf(vertices: Vec3[]): { normal: Vec3; d: number } | null {
   if (vertices.length < 3) return null;
   const e1 = sub(vertices[1], vertices[0]);
@@ -277,6 +303,14 @@ function rotateToNonCollinearStart(vertices: Vec3[], uvs?: Vec2[]): { vertices:
 export function mergePolygons(input: Polygon[]): Polygon[] {
   const out: Polygon[] = [];
   const polys: PolyState[] = [];
+  let workUnits = 0;
+  let workBudgetExhausted = false;
+  const consumeWork = (units: number): boolean => {
+    workUnits += units;
+    if (workUnits <= MERGE_WORK_UNIT_LIMIT) return true;
+    workBudgetExhausted = true;
+    return false;
+  };
 
   // Pass 1: collect each polygon, seed PolyState. Skip polygons without
   // a usable plane (degenerate; should have been removed by normalize).
@@ -311,6 +345,7 @@ export function mergePolygons(input: Polygon[]): Polygon[] {
       textureTriangles,
       normal: plane.normal,
       d: plane.d,
+      directedEdges: directedEdgeSet(verts),
       alive: true,
       data: polygon.data,
     });
@@ -329,42 +364,37 @@ export function mergePolygons(input: Polygon[]): Polygon[] {
   // wouldn't merge). Re-validation per candidate gives both speed AND the
   // chain merging the original (slow) algo had.
   const tryMergePass = (): boolean => {
-    const edgeIndex = new Map<string, number[]>();
+    const edgeIndex = new Map<string, EdgeOwners>();
     for (let i = 0; i < polys.length; i++) {
       const p = polys[i];
       if (!p.alive) continue;
       const n = p.vertices.length;
+      if (!consumeWork(n)) return false;
+      p.directedEdges = new Set();
       for (let k = 0; k < n; k++) {
         const a = p.vertices[k];
         const b = p.vertices[(k + 1) % n];
+        p.directedEdges.add(directedEdgeKey(a, b));
         const key = edgeKey(a, b);
-        let arr = edgeIndex.get(key);
-        if (!arr) { arr = []; edgeIndex.set(key, arr); }
-        arr.push(i);
+        let edge = edgeIndex.get(key);
+        if (!edge) {
+          edge = { a, b, owners: [] };
+          edgeIndex.set(key, edge);
+        }
+        edge.owners.push(i);
       }
     }
 
     let mergedThisPass = false;
 
-    // findSharedEdge returns the (e0, e1) endpoints of the edge a and b
-    // currently share, or null if a's vertex list has been mutated since
-    // edgeIndex was built and no longer touches b. Because polycss CCW
-    // winding faces opposite directions on the two sides of a shared edge,
-    // a's edge va→vb matches b's edge vb→va.
-    const findSharedEdge = (a: PolyState, b: PolyState): [Vec3, Vec3] | null => {
-      for (let k = 0; k < a.vertices.length; k++) {
-        const va = a.vertices[k];
-        const vb = a.vertices[(k + 1) % a.vertices.length];
-        for (let j = 0; j < b.vertices.length; j++) {
-          const ub = b.vertices[j];
-          const uc = b.vertices[(j + 1) % b.vertices.length];
-          if (eqVec(va, uc) && eqVec(vb, ub)) return [va, vb];
-        }
-      }
-      return null;
+    const edgeDirection = (poly: PolyState, e0: Vec3, e1: Vec3): 1 | -1 | 0 => {
+      if (poly.directedEdges.has(directedEdgeKey(e0, e1))) return 1;
+      if (poly.directedEdges.has(directedEdgeKey(e1, e0))) return -1;
+      return 0;
     };
 
-    for (const [, owners] of edgeIndex) {
+    for (const edge of edgeIndex.values()) {
+      const { owners } = edge;
       // owners can have >2 if a degenerate input had three+ polys sharing
       // an edge; we still try each pair below — but the simple dedupe
       // skips index entries where both polys were already merged away.
@@ -382,20 +412,28 @@ export function mergePolygons(input: Polygon[]): Polygon[] {
       // states can't merge cleanly.
       if (!!a.uvs !== !!b.uvs) continue;
       if (hasTexture ? !sameTexturePlane(a, b) : !samePlane(a, b)) continue;
+      if (!consumeWork(a.vertices.length + b.vertices.length)) return false;
 
-      // Re-validate the shared edge — a or b may have grown since the
-      // edge index was built (chain merge within this pass).
-      const shared = findSharedEdge(a, b);
-      if (!shared) continue;
-      const [e0, e1] = shared;
+      // Re-validate the indexed edge — a or b may have grown since this
+      // pass began. Use the snapshot endpoints directly instead of scanning
+      // every edge of both polygons against each other; large merged rings
+      // can otherwise make this check dominate real-world meshes.
+      const aDirection = edgeDirection(a, edge.a, edge.b);
+      if (aDirection === 0) continue;
+      const bDirection = edgeDirection(b, edge.a, edge.b);
+      if (bDirection === 0 || aDirection === bDirection) continue;
+      const [e0, e1] = aDirection === 1 ? [edge.a, edge.b] : [edge.b, edge.a];
 
       const merged = mergeAlongEdge(a, b, e0, e1);
       if (!merged) continue;
+      if (!consumeWork(merged.vertices.length)) return false;
+      if (merged.vertices.length > MAX_MERGED_VERTEX_COUNT) continue;
       if (!mergeIsPlanar(merged.vertices, hasTexture ? EPS_TEXTURE_DISTANCE : EPS_RENDER_DISTANCE)) continue;
       if (!isConvex(merged.vertices, a.normal)) continue;
 
       a.vertices = merged.vertices;
       a.uvs = merged.uvs;
+      a.directedEdges = directedEdgeSet(merged.vertices);
       a.textureTriangles = hasTexture
         ? [...(a.textureTriangles ?? []), ...(b.textureTriangles ?? [])]
         : undefined;
@@ -407,7 +445,11 @@ export function mergePolygons(input: Polygon[]): Polygon[] {
 
   // Iterate to fixed point — each pass merges as much as it can while
   // working from a single snapshot of the edge index.
-  while (tryMergePass()) { /* loop */ }
+  let passCount = 0;
+  while (!workBudgetExhausted && passCount < MERGE_PASS_LIMIT) {
+    if (!tryMergePass()) break;
+    passCount++;
+  }
 
   // Pass 3: emit surviving polygons.
   for (const p of polys) {
diff --git a/packages/core/src/merge/optimizePolygons.test.ts b/packages/core/src/merge/optimizePolygons.test.ts
index ce3d6372..1c3c67fd 100644
--- a/packages/core/src/merge/optimizePolygons.test.ts
+++ b/packages/core/src/merge/optimizePolygons.test.ts
@@ -1,8 +1,11 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import type { Polygon } from "../types";
+import { pathToFileURL } from "url";
+import type { Polygon, Vec3 } from "../types";
+import { parseGltf } from "../parser/parseGltf";
 import { parseObj } from "../parser/parseObj";
+import { bakeSolidTextureSamples } from "../parser/solidTextureSamples";
 import { optimizeMeshPolygons } from "./optimizePolygons";
 
 function rect(x0: number, y0: number, x1: number, y1: number): Polygon[] {
@@ -69,6 +72,99 @@ function loadObjGalleryFile(name: string): string {
   );
 }
 
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+function galleryGlbPath(name: string): string {
+  return resolve(__dirname, "../../../../website/public/gallery/glb", name);
+}
+
+function loadGlbGalleryFile(name: string): ArrayBuffer {
+  const bytes = readFileSync(galleryGlbPath(name));
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+function installSolidTextureEnv(color: [number, number, number, number]): void {
+  class FakeImage {
+    naturalWidth = 1;
+    naturalHeight = 1;
+    width = 1;
+    height = 1;
+    onload: (() => void) | null = null;
+
+    set src(_value: string) {
+      queueMicrotask(() => this.onload?.());
+    }
+  }
+
+  vi.stubGlobal("Image", FakeImage);
+  vi.stubGlobal("document", {
+    createElement(tagName: string) {
+      if (tagName !== "canvas") throw new Error(`unexpected element ${tagName}`);
+      return {
+        width: 0,
+        height: 0,
+        getContext(type: string) {
+          if (type !== "2d") return null;
+          return {
+            drawImage() {},
+            getImageData() {
+              return { data: color };
+            },
+          };
+        },
+      };
+    },
+  });
+}
+
+function renderCost(polygons: Polygon[]): number {
+  let cost = 0;
+  for (const polygon of polygons) {
+    const vertexCount = polygon.vertices.length;
+    const irregularPenalty = vertexCount <= 4 ? 0 : Math.min(4, vertexCount - 4) * 0.12;
+    const texturePenalty = polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length
+      ? 0.15
+      : 0;
+    cost += 1 + irregularPenalty + texturePenalty;
+  }
+  return cost;
+}
+
+function triangulatedPatchHalf(
+  x0: number,
+  x1: number,
+  y0: number,
+  y1: number,
+  zAt: (x: number, y: number) => number,
+): Polygon[] {
+  const polygons: Polygon[] = [];
+  const columns = 3;
+  const point = (x: number, y: number): Vec3 => [x, y, zAt(x, y)];
+  for (let column = 0; column < columns; column++) {
+    const xa = x0 + ((x1 - x0) * column) / columns;
+    const xb = x0 + ((x1 - x0) * (column + 1)) / columns;
+    polygons.push(
+      { vertices: [point(xa, y0), point(xb, y0), point(xb, y1)], color: "#f00" },
+      { vertices: [point(xa, y0), point(xb, y1), point(xa, y1)], color: "#f00" },
+    );
+  }
+  return polygons;
+}
+
+function lowValueApproximationCorpus(): Polygon[] {
+  const polygons: Polygon[] = [];
+  for (let patch = 0; patch < 90; patch++) {
+    const x = patch * 3;
+    polygons.push(
+      ...triangulatedPatchHalf(x, x + 1, 0, 1, () => 0),
+      ...triangulatedPatchHalf(x + 1, x + 2, 0, 1, (px) => (px - x - 1) * 0.08),
+    );
+  }
+  return polygons;
+}
+
 describe("optimizeMeshPolygons", () => {
   it("uses exact planar cover candidates for lossless resolution", () => {
     const input = [
@@ -105,6 +201,26 @@ describe("optimizeMeshPolygons", () => {
     expect(optimizeMeshPolygons(input)).toHaveLength(1);
   });
 
+  it("skips low-value automatic lossy approximation after a small exact result", () => {
+    const input = lowValueApproximationCorpus();
+    const lossless = optimizeMeshPolygons(input, { meshResolution: "lossless" });
+    const automatic = optimizeMeshPolygons(input, { meshResolution: "lossy" });
+    const explicit = optimizeMeshPolygons(input, {
+      meshResolution: "lossy",
+      approximateMerge: {
+        maxAngleDeg: 15,
+        maxPlaneDisplacement: 0.35,
+        maxBoundaryDisplacement: 0.0725,
+        isolatedPairs: false,
+      },
+    });
+
+    expect(input.length).toBeGreaterThanOrEqual(1000);
+    expect(renderCost(lossless)).toBeLessThanOrEqual(300);
+    expect(automatic).toHaveLength(lossless.length);
+    expect(explicit.length).toBeLessThan(lossless.length);
+  });
+
   it("allows lossy approximate merge for same-texture UV polygons", () => {
     const input: Polygon[] = [
       {
@@ -257,6 +373,76 @@ describe("optimizeMeshPolygons", () => {
     expect(polygonSignature(automatic)).toEqual(polygonSignature(exact));
   });
 
+  it("does not let default lossy rect-cover heuristics regress below lossless", () => {
+    const raw = parseGltf(loadGlbGalleryFile("poly-pizza/cardboard-box-closed.glb")).polygons;
+
+    const lossless = optimizeMeshPolygons(raw, { meshResolution: "lossless" });
+    const lossy = optimizeMeshPolygons(raw, { meshResolution: "lossy" });
+
+    expect(lossless).toHaveLength(10);
+    expect(lossy.length).toBeLessThanOrEqual(lossless.length);
+  });
+
+  it("keeps automatic lossy quality fallback under the exact lossless floor", async () => {
+    installSolidTextureEnv([10, 20, 30, 255]);
+
+    for (const file of ["poly-pizza/arrow.glb", "poly-pizza/bucket.glb"]) {
+      const parsed = parseGltf(loadGlbGalleryFile(file), {
+        baseUrl: pathToFileURL(galleryGlbPath(file)).href,
+      });
+      const baked = await bakeSolidTextureSamples(parsed);
+
+      const lossless = optimizeMeshPolygons(baked.polygons, { meshResolution: "lossless" });
+      const lossy = optimizeMeshPolygons(baked.polygons, { meshResolution: "lossy" });
+
+      expect(lossy.length, file).toBeLessThanOrEqual(lossless.length);
+      expect(renderCost(lossy), file).toBeLessThanOrEqual(renderCost(lossless) + 1e-9);
+    }
+  });
+
+  it("does not keep searching lossy candidates after reaching one polygon", () => {
+    const input: Polygon[] = [];
+    const segments = 12;
+    const ring: Vec3[] = [];
+    for (let i = 0; i < segments; i++) {
+      const angle = (i / segments) * Math.PI * 2;
+      ring.push([Math.cos(angle), Math.sin(angle), 0]);
+    }
+    for (let i = 0; i < segments; i++) {
+      input.push({
+        vertices: [[0, 0, 0], ring[i], ring[(i + 1) % segments]],
+        color: "#abcdef",
+      });
+    }
+
+    const lossless = optimizeMeshPolygons(input, { meshResolution: "lossless" });
+    const lossy = optimizeMeshPolygons(input, { meshResolution: "lossy" });
+
+    expect(lossless).toHaveLength(1);
+    expect(lossy).toHaveLength(1);
+    expect(polygonSignature(lossy)).toEqual(polygonSignature(lossless));
+  });
+
+  it("salvages safe local pair wins without accepting the unsafe full pair set", () => {
+    const raw = parseGltf(loadGlbGalleryFile("Snail.glb")).polygons;
+
+    const lossless = optimizeMeshPolygons(raw, { meshResolution: "lossless" });
+    const forced = optimizeMeshPolygons(raw, {
+      meshResolution: "lossy",
+      approximateMerge: {
+        maxAngleDeg: 45,
+        maxPlaneDisplacement: 1,
+        maxBoundaryDisplacement: 0.0725,
+        isolatedPairs: true,
+      },
+    });
+    const automatic = optimizeMeshPolygons(raw, { meshResolution: "lossy" });
+
+    expect(forced.length).toBeLessThan(lossless.length);
+    expect(automatic.length).toBeGreaterThan(forced.length);
+    expect(automatic.length).toBeLessThan(lossless.length);
+  });
+
   it("keeps lossy pair-merge neighbor seams on shared geometry", () => {
     const input: Polygon[] = [
       { vertices: [[0, 0, 0.02], [1, 0, 0], [1, 1, 0.11]], color: "#f00" },
diff --git a/packages/core/src/merge/optimizePolygons.ts b/packages/core/src/merge/optimizePolygons.ts
index 050ad1ca..96920e35 100644
--- a/packages/core/src/merge/optimizePolygons.ts
+++ b/packages/core/src/merge/optimizePolygons.ts
@@ -25,7 +25,7 @@ export interface OptimizeMeshPolygonsOptions {
   rectCover?: boolean | CoverPlanarPolygonsOptions;
   /**
    * Lossy approximate merge settings. Ignored for lossless resolution.
-   * When omitted, lossy evaluates isolated-pair and small plane-group
+   * When omitted, lossy evaluates isolated-pair and tiny plane-group
    * strategies, then chooses the lowest render-cost result with a near-cost
    * preference for candidates that reduce detected internal gaps.
    */
@@ -54,6 +54,7 @@ interface PlaneNormalizeMeta {
 interface PlaneFit {
   normal: Vec3;
   point: Vec3;
+  boundaryVertexKeys?: Set<string>;
 }
 
 interface PairCandidate {
@@ -158,6 +159,24 @@ interface LossyQualityCandidate {
   metrics?: CrackMetrics;
 }
 
+interface PendingLocalCrackCandidate {
+  options: LossyApproximateCandidate;
+  cost: number;
+  sample: CrackMetricSample;
+  allowReferenceCracks: boolean;
+}
+
+interface LocalCrackGuard {
+  source: CrackSourceContext;
+  limits: CrackMetricLimits;
+  searchTolerance: number;
+}
+
+interface LocalCrackGapOffenders {
+  keys: Set<string>;
+  segments: Segment3[];
+}
+
 const DEFAULT_NORMALIZE_OPTIONS: ResolvedGeometryNormalizeOptions = {
   maxAngleDeg: NORMALIZE_MAX_ANGLE_DEG,
   maxPlaneDisplacement: NORMALIZE_MAX_PLANE_DISPLACEMENT,
@@ -189,21 +208,29 @@ const LOSSY_BUDGET_SWEEP: Array<Required<Omit<ApproximateMergeOptions, "isolated
     maxBoundaryDisplacement: 0.0725,
   },
 ];
-
 const LOSSY_COLOR_QUANTIZE_STEPS = [4, 8, 12] as const;
+const LOSSY_COLOR_QUANTIZE_SMALL_BASELINE_MAX_POLYGONS = 300;
+const LOSSY_COLOR_QUANTIZE_LOW_PALETTE_MAX_COLORS = 28;
+const LOSSY_COLOR_QUANTIZE_GROUP_RETRY_MIN_SOURCE_POLYGONS = 900;
 const LOSSY_RECTANGULATED_MIN_POLYGONS = 300;
 const LOSSY_RECTANGULATED_MAX_TRIANGLE_RATIO = 0.3;
 const LOSSY_AUTOMATIC_GROUP_MAX_POLYGONS = 300;
 const LOSSY_CRACK_COST_SLACK = 16;
 const LOSSY_CRACK_RELATIVE_COST_SLACK = 0.015;
 const LOSSY_CRACK_QUALITY_SEARCH_MULTIPLIER = 2.6;
+const LOSSY_LOCAL_CRACK_PRUNE_PASSES = 2;
 const LOSSY_POLYGON_PAIR_MAX_PASSES = 3;
-const RECT_COVER_MOSTLY_QUAD_TRIANGLE_LIMIT = 96;
+const LOSSY_AUTOMATIC_LOW_VALUE_SOURCE_MIN_POLYGONS = 1000;
+const LOSSY_AUTOMATIC_APPROXIMATE_LOW_VALUE_EXACT_COST = 300;
 const AUTOMATIC_RECT_COVER_MAX_POLYGONS = 1800;
 const AUTOMATIC_RECT_COVER_MIN_TRIANGLE_RATIO = 0.65;
 const LOSSY_RECTANGULATED_FAST_EXIT_MIN_POLYGONS = 900;
 const AUTOMATIC_GEOMETRY_SKIP_MIN_POLYGONS = 300;
 const CARDINAL_NORMAL_EPSILON = 1e-5;
+const DEFAULT_RECT_COVER_SMALL_AUTOMATIC_SKIP_MIN_POLYGONS = 24;
+const DEFAULT_RECT_COVER_SMALL_AUTOMATIC_SKIP_MAX_POLYGONS = 50;
+const DEFAULT_RECT_COVER_MAX_AUTOMATIC_POLYGONS = 1000;
+const DEFAULT_RECT_COVER_MAX_BOUNDARY_EDGES = 1000;
 
 const DEFAULT_RECT_COVER_OPTIONS: CoverPlanarPolygonsOptions = {
   minGroupPolygons: 2,
@@ -242,6 +269,21 @@ export function optimizeMeshPolygons(
     : options.rectCover;
   const rectCovered = applyRectCoverCandidate(baseline, initialRectCover);
   if (rectCovered !== baseline) acceptCandidate(rectCovered);
+  if (
+    meshResolution === "lossy" &&
+    options.rectCover === undefined
+  ) {
+    const losslessRectCovered = applyRectCoverCandidate(baseline, undefined);
+    if (losslessRectCovered !== baseline) acceptCandidate(losslessRectCovered);
+  }
+  const exactCostCeiling = bestCost;
+  if (meshResolution === "lossy" && (best.length <= 1 || bestCost <= 1 + 1e-9)) return best;
+  if (
+    meshResolution === "lossy" &&
+    options.approximateMerge === undefined &&
+    polygons.length >= LOSSY_AUTOMATIC_LOW_VALUE_SOURCE_MIN_POLYGONS &&
+    bestCost <= LOSSY_AUTOMATIC_APPROXIMATE_LOW_VALUE_EXACT_COST
+  ) return best;
 
   if (meshResolution === "lossy" && options.approximateMerge !== false) {
     const qualityCandidates: LossyQualityCandidate[] = [];
@@ -288,6 +330,34 @@ export function optimizeMeshPolygons(
         ),
       );
     };
+    const localCrackGuardForSample = (
+      sample: CrackMetricSample,
+      maxBoundaryDisplacement?: number,
+      allowReferenceCracks = true,
+    ): LocalCrackGuard => {
+      const source = getCrackSource();
+      return {
+        source,
+        limits: crackMetricLimits(
+          source,
+          sample.tolerance,
+          allowReferenceCracks ? getReferenceCracks() : null,
+        ),
+        searchTolerance: crackQualitySearchToleranceForSource(source, maxBoundaryDisplacement),
+      };
+    };
+    const sampleExceedsGapLimit = (
+      sample: CrackMetricSample,
+      allowReferenceCracks = true,
+    ): boolean => {
+      const source = getCrackSource();
+      const limits = crackMetricLimits(
+        source,
+        sample.tolerance,
+        allowReferenceCracks ? getReferenceCracks() : null,
+      );
+      return sample.metrics.maxGap > limits.maxGap;
+    };
     const acceptLossyCandidate = (
       candidate: Polygon[],
       cost: number,
@@ -318,8 +388,9 @@ export function optimizeMeshPolygons(
           automaticApproximate ? baseline : undefined,
         );
     const colorQuantizeCandidates = automaticApproximate
-      ? lossyColorQuantizeCandidates(polygons)
+      ? lossyColorQuantizeCandidates(polygons, baseline)
       : [];
+    const pendingLocalCrackCandidates: PendingLocalCrackCandidate[] = [];
     for (let approximateIndex = 0; approximateIndex < approximateCandidates.length; approximateIndex++) {
       const approximateOptions = approximateCandidates[approximateIndex];
       const approximate = preprocessModelPolygons(polygons, approximateOptions, preprocessCache);
@@ -342,6 +413,18 @@ export function optimizeMeshPolygons(
         approximatePassesCrackBudget = passesLossyCrackBudget(sample, approximateAllowsReferenceCracks);
       }
       if (!approximatePassesCrackBudget && approximateCost < bestCost) {
+        if (
+          automaticApproximate &&
+          approximateOptions.isolatedPairs &&
+          sampleExceedsGapLimit(approximateCracks!, approximateAllowsReferenceCracks)
+        ) {
+          pendingLocalCrackCandidates.push({
+            options: approximateOptions,
+            cost: approximateCost,
+            sample: approximateCracks!,
+            allowReferenceCracks: approximateAllowsReferenceCracks,
+          });
+        }
         continue;
       }
       if (approximatePassesCrackBudget) {
@@ -387,6 +470,36 @@ export function optimizeMeshPolygons(
 
     }
 
+    pendingLocalCrackCandidates.sort((a, b) => a.cost - b.cost);
+    for (const pending of pendingLocalCrackCandidates) {
+      if (pending.cost >= bestCost) continue;
+      const guarded = preprocessModelPolygonsWithLocalCrackGuard(
+        polygons,
+        pending.options,
+        preprocessCache,
+        localCrackGuardForSample(
+          pending.sample,
+          pending.options.maxBoundaryDisplacement,
+          pending.allowReferenceCracks,
+        ),
+      );
+      const guardedCost = polygonRenderCost(guarded);
+      if (guardedCost >= bestCost) continue;
+      const guardedCracks = sampleCandidateCracks(
+        guarded,
+        pending.options.maxBoundaryDisplacement,
+        pending.allowReferenceCracks,
+      );
+      if (!passesLossyCrackBudget(guardedCracks, pending.allowReferenceCracks)) continue;
+      acceptLossyCandidate(guarded, guardedCost);
+      considerQualityCandidate(
+        guarded,
+        guardedCost,
+        pending.options.maxBoundaryDisplacement,
+        guardedCracks.metrics,
+      );
+    }
+
     if (
       automaticApproximate &&
       colorQuantizeCandidates.length === 0 &&
@@ -447,12 +560,15 @@ export function optimizeMeshPolygons(
           }
         }
 
+        const skipColorPlaneGroupRetries =
+          colorBaseline.length <= LOSSY_COLOR_QUANTIZE_SMALL_BASELINE_MAX_POLYGONS &&
+          colorPolygons.length >= LOSSY_COLOR_QUANTIZE_GROUP_RETRY_MIN_SOURCE_POLYGONS;
         const colorApproximateCandidates = skipAutomaticGeometryApproximation
           ? []
           : lossyApproximateCandidates(
               options.approximateMerge,
               colorCache.baseline,
-            );
+            ).filter((candidate) => !skipColorPlaneGroupRetries || candidate.isolatedPairs !== false);
         for (const approximateOptions of colorApproximateCandidates) {
           const approximate = preprocessModelPolygons(colorPolygons, approximateOptions, colorCache);
           const approximateCost = polygonRenderCost(approximate);
@@ -547,6 +663,7 @@ export function optimizeMeshPolygons(
       qualityCandidates,
       best,
       bestCost,
+      exactCostCeiling,
       (candidate) => {
         candidate.metrics ??= candidateCrackQualityMetrics(
           getCrackSource(),
@@ -570,9 +687,16 @@ export function optimizeMeshPolygons(
   return best;
 }
 
-function lossyColorQuantizeCandidates(polygons: Polygon[]): Polygon[][] {
+function lossyColorQuantizeCandidates(polygons: Polygon[], baseline?: Polygon[]): Polygon[][] {
   const profile = solidHexColorProfile(polygons);
   if (profile.eligiblePolygons < 24 || profile.colorCount < 8) return [];
+  // Low-palette large baselines rerun pair passes without changing geometry;
+  // high-cardinality palettes still unlock exact merges on real corpus models.
+  if (
+    baseline &&
+    baseline.length > LOSSY_COLOR_QUANTIZE_SMALL_BASELINE_MAX_POLYGONS &&
+    profile.colorCount <= LOSSY_COLOR_QUANTIZE_LOW_PALETTE_MAX_COLORS
+  ) return [];
 
   const candidates: Polygon[][] = [];
   const seen = new Set<string>();
@@ -680,9 +804,9 @@ function lossyApproximateCandidates(
 
   const candidates: LossyApproximateCandidate[] = [];
   const seen = new Set<string>();
-  const isolatedPairModes = baseline && baseline.length > LOSSY_AUTOMATIC_GROUP_MAX_POLYGONS
-    ? [true]
-    : [true, false];
+  const isolatedPairModes = baseline && baseline.length <= LOSSY_AUTOMATIC_GROUP_MAX_POLYGONS
+    ? [true, false]
+    : [true];
   for (let budgetIndex = 0; budgetIndex < LOSSY_BUDGET_SWEEP.length; budgetIndex++) {
     const budget = LOSSY_BUDGET_SWEEP[budgetIndex];
     for (const isolatedPairs of isolatedPairModes) {
@@ -763,6 +887,7 @@ function chooseLossyQualityCandidate(
   candidates: LossyQualityCandidate[],
   best: Polygon[],
   bestCost: number,
+  maxSelectedCost: number,
   candidateMetrics: (candidate: LossyQualityCandidate) => CrackMetrics,
   bestMetrics: () => CrackMetrics,
 ): LossyQualityCandidate | null {
@@ -775,7 +900,11 @@ function chooseLossyQualityCandidate(
   let selectedMetrics: CrackMetrics | null = null;
 
   for (const candidate of candidates) {
-    if (candidate.polygons === best || candidate.cost > bestCost + slack) continue;
+    if (
+      candidate.polygons === best ||
+      candidate.cost > bestCost + slack ||
+      candidate.cost > maxSelectedCost + 1e-9
+    ) continue;
     const metrics = candidateMetrics(candidate);
     currentMetrics ??= currentCandidate ? candidateMetrics(currentCandidate) : bestMetrics();
     if (!crackMetricsMateriallyBetter(metrics, currentMetrics)) continue;
@@ -1070,26 +1199,31 @@ function resolveRectCoverOptions(
 ): CoverPlanarPolygonsOptions | null {
   if (setting && setting !== true) return setting;
 
+  const explicit = setting === true;
   const polygonCount = polygons.length;
   if (polygonCount > 2200) return null;
-  if (polygonCount > 1200) {
+  if (
+    !explicit &&
+    polygonCount >= DEFAULT_RECT_COVER_SMALL_AUTOMATIC_SKIP_MIN_POLYGONS &&
+    polygonCount < DEFAULT_RECT_COVER_SMALL_AUTOMATIC_SKIP_MAX_POLYGONS
+  ) return null;
+  if (!explicit && polygonCount > DEFAULT_RECT_COVER_MAX_AUTOMATIC_POLYGONS) return null;
+  if (!explicit && polygonCount <= 300) {
     return {
       ...DEFAULT_RECT_COVER_OPTIONS,
-      maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 2),
+      maxCandidateAxes: 1,
     };
   }
-  if (polygonCount > 300 && polygonTriangleCount(polygons) <= RECT_COVER_MOSTLY_QUAD_TRIANGLE_LIMIT) {
+  if (polygonCount > 300) {
+    if (!explicit) {
+      if (maxPolygonVertexCount(polygons) > 12) return null;
+      if (polygonBoundaryEdgeCount(polygons) > DEFAULT_RECT_COVER_MAX_BOUNDARY_EDGES) return null;
+    }
     return {
       ...DEFAULT_RECT_COVER_OPTIONS,
       maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 2),
     };
   }
-  if (polygonCount > 900) {
-    return {
-      ...DEFAULT_RECT_COVER_OPTIONS,
-      maxCandidateAxes: Math.min(DEFAULT_RECT_COVER_OPTIONS.maxCandidateAxes ?? 24, 4),
-    };
-  }
   return DEFAULT_RECT_COVER_OPTIONS;
 }
 
@@ -1110,6 +1244,31 @@ function polygonTriangleCount(polygons: Polygon[]): number {
   return triangles;
 }
 
+function maxPolygonVertexCount(polygons: Polygon[]): number {
+  let max = 0;
+  for (const polygon of polygons) {
+    max = Math.max(max, polygon.vertices.length);
+  }
+  return max;
+}
+
+function polygonBoundaryEdgeCount(polygons: Polygon[]): number {
+  const edges = new Map<string, number>();
+  for (const polygon of polygons) {
+    for (let i = 0; i < polygon.vertices.length; i++) {
+      const a = polygon.vertices[i];
+      const b = polygon.vertices[(i + 1) % polygon.vertices.length];
+      const key = edgeKey(a, b);
+      edges.set(key, (edges.get(key) ?? 0) + 1);
+    }
+  }
+  let boundary = 0;
+  for (const count of edges.values()) {
+    if (count === 1) boundary += 1;
+  }
+  return boundary;
+}
+
 function applyIndexFilter(polygons: Polygon[], filter: IndexFilter | undefined): Polygon[] {
   if (filter === undefined || filter === null) return polygons;
   return filter.map((index) => polygons[index]).filter((polygon): polygon is Polygon => !!polygon);
@@ -1219,6 +1378,29 @@ function preprocessModelPolygons(
   return normalized.length < baseline.length ? normalized : baseline;
 }
 
+function preprocessModelPolygonsWithLocalCrackGuard(
+  polygons: Polygon[],
+  normalizeGeometry: ApproximateMergeOptions,
+  cache: PreprocessCache,
+  guard: LocalCrackGuard,
+): Polygon[] {
+  const deduped = dedupedPolygonsForMerge(polygons, cache);
+  const interior = interiorPolygonsForMerge(deduped, cache);
+  const baseline = cache.baseline ?? mergePolygons(interior);
+  if (!cache.baseline) cache.baseline = baseline;
+
+  const options = resolveNormalizeOptions(normalizeGeometry);
+  if (!options.isolatedPairs) return baseline;
+
+  const paired = mergeIsolatedTrianglePairs(
+    interior,
+    options,
+    guard,
+  );
+  const mergedPaired = mergePolygons(paired);
+  return mergedPaired.length < baseline.length ? mergedPaired : baseline;
+}
+
 function snappedPolygonsForMerge(polygons: Polygon[], cache?: PreprocessCache): Polygon[] {
   if (!cache) return snapGeometryForMerge(polygons);
   if (!cache.snapped) cache.snapped = snapGeometryForMerge(polygons);
@@ -1252,6 +1434,7 @@ function resolveNormalizeOptions(options: ApproximateMergeOptions): ResolvedGeom
 function mergeIsolatedTrianglePairs(
   polygons: Polygon[],
   options: ResolvedGeometryNormalizeOptions,
+  guard?: LocalCrackGuard,
 ): Polygon[] {
   const metas = polygons.map((polygon): PlaneNormalizeMeta | null => {
     const plane = planeOfPolygon(polygon);
@@ -1280,16 +1463,24 @@ function mergeIsolatedTrianglePairs(
     if (owners.length !== 2) continue;
     const [a, b] = owners;
     const candidate = approximateTrianglePairCandidate(a, b, polygons, metas, options);
+    if (candidate && guard && pairCandidateExceedsLocalCrackGap(candidate, guard, edgeOwners)) continue;
     if (candidate) candidates.push(candidate);
   }
-  const used = new Set<number>();
+  let selected = choosePairCandidates(candidates);
+  if (guard) selected = prunePairCandidatesByLocalCrackGaps(polygons, selected, guard);
+  if (selected.length === 0) return polygons;
+
+  return buildIsolatedTrianglePairOutput(polygons, selected);
+}
+
+function buildIsolatedTrianglePairOutput(
+  polygons: Polygon[],
+  selected: PairCandidate[],
+): Polygon[] {
   const replacements = new Map<number, Polygon>();
   const skipped = new Set<number>();
-  const selected = choosePairCandidates(candidates);
   const vertexMoves = averagedVertexPositionMoves(selected.flatMap((candidate) => candidate.vertexMoves));
   for (const candidate of selected) {
-    used.add(candidate.a);
-    used.add(candidate.b);
     const outputIndex = Math.min(candidate.a, candidate.b);
     replacements.set(outputIndex, candidate.polygon);
     skipped.add(Math.max(candidate.a, candidate.b));
@@ -1308,6 +1499,111 @@ function mergeIsolatedTrianglePairs(
   return vertexMoves.size > 0 ? applyVertexPositionMoves(output, vertexMoves) : output;
 }
 
+function prunePairCandidatesByLocalCrackGaps(
+  polygons: Polygon[],
+  selected: PairCandidate[],
+  guard: LocalCrackGuard,
+): PairCandidate[] {
+  let current = selected;
+  for (let pass = 0; pass < LOSSY_LOCAL_CRACK_PRUNE_PASSES; pass++) {
+    const output = buildIsolatedTrianglePairOutput(polygons, current);
+    const mergedOutput = mergePolygons(output);
+    const offenders = localCrackGapOffenders(mergedOutput, guard);
+    if (offenders.keys.size === 0) return current;
+
+    const next = current.filter((candidate) =>
+      !pairCandidateTouchesOffenders(candidate, offenders, guard.searchTolerance)
+    );
+    if (next.length === current.length) return current;
+    current = next;
+    if (current.length === 0) return current;
+  }
+  return current;
+}
+
+function localCrackGapOffenders(polygons: Polygon[], guard: LocalCrackGuard): LocalCrackGapOffenders {
+  const outputEdges = collectEdgeStats(polygons);
+  const internalIndex = guard.searchTolerance > 0
+    ? internalSegmentIndexForSource(guard.source, guard.searchTolerance)
+    : null;
+  const offenders = new Set<string>();
+  const segments: Segment3[] = [];
+  if (!internalIndex) return { keys: offenders, segments };
+
+  for (const edge of outputEdges.boundarySegments) {
+    const key = edgeKey(edge.a, edge.b);
+    if (guard.source.edges.boundaryKeys.has(key) || guard.source.edges.internalKeys.has(key)) {
+      continue;
+    }
+    const gap = indexedInternalEdgeGap(edge, internalIndex, guard.searchTolerance);
+    if (gap !== null && gap > guard.limits.maxGap) {
+      offenders.add(vertexKey(edge.a));
+      offenders.add(vertexKey(edge.b));
+      segments.push(edge);
+    }
+  }
+
+  return { keys: offenders, segments };
+}
+
+function pairCandidateTouchesOffenders(
+  candidate: PairCandidate,
+  offenders: LocalCrackGapOffenders,
+  tolerance: number,
+): boolean {
+  const vertices: Vec3[] = [...candidate.polygon.vertices];
+  for (const move of candidate.vertexMoves) {
+    if (offenders.keys.has(move.key)) return true;
+    vertices.push(move.target);
+  }
+  const moves = averagedVertexPositionMoves(candidate.vertexMoves);
+  for (const target of moves.values()) {
+    if (offenders.keys.has(vertexKey(target))) return true;
+    vertices.push(target);
+  }
+  for (const vertex of vertices) {
+    if (offenders.keys.has(vertexKey(vertex))) return true;
+    if (offenders.segments.some((segment) => pointSegmentDistance(vertex, segment) <= tolerance)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function pairCandidateExceedsLocalCrackGap(
+  candidate: PairCandidate,
+  guard: LocalCrackGuard,
+  edgeOwners: Map<string, number[]>,
+): boolean {
+  const moves = averagedVertexPositionMoves(candidate.vertexMoves);
+  const sourceVertices = candidate.polygon.vertices;
+  const vertices = sourceVertices.map((vertex) =>
+    moves.get(vertexKey(vertex)) ?? vertex
+  );
+  const internalIndex = guard.searchTolerance > 0
+    ? internalSegmentIndexForSource(guard.source, guard.searchTolerance)
+    : null;
+  if (!internalIndex) return false;
+
+  for (let i = 0; i < vertices.length; i++) {
+    const sourceA = sourceVertices[i];
+    const sourceB = sourceVertices[(i + 1) % sourceVertices.length];
+    const owners = edgeOwners.get(edgeKey(sourceA, sourceB));
+    if (owners?.some((owner) => owner !== candidate.a && owner !== candidate.b)) continue;
+
+    const a = vertices[i];
+    const b = vertices[(i + 1) % vertices.length];
+    const key = edgeKey(a, b);
+    if (guard.source.edges.boundaryKeys.has(key) || guard.source.edges.internalKeys.has(key)) {
+      continue;
+    }
+    const gap = indexedInternalEdgeGap({ a, b }, internalIndex, guard.searchTolerance);
+    if (gap !== null && gap > guard.limits.maxGap) return true;
+  }
+
+  return false;
+}
+
 function choosePairCandidates(candidates: PairCandidate[]): PairCandidate[] {
   if (candidates.length > 3000) return choosePairCandidatesStatic(candidates);
   return choosePairCandidatesDynamic(candidates);
@@ -2451,12 +2747,14 @@ function fitPlaneForGroup(
     return {
       normal,
       point: [normal[0] * d, normal[1] * d, normal[2] * d],
+      boundaryVertexKeys: boundaryVertices,
     };
   }
 
   return {
     normal,
     point: [px / weightSum, py / weightSum, pz / weightSum],
+    boundaryVertexKeys: boundaryVertices,
   };
 }
 
@@ -2491,7 +2789,7 @@ function groupWithinPlaneBudget(
   options: ResolvedGeometryNormalizeOptions,
 ): boolean {
   const normalDotMin = Math.cos((options.maxAngleDeg * Math.PI) / 180);
-  const boundaryVertices = groupBoundaryVertexKeys(group, metas);
+  const boundaryVertices = fit.boundaryVertexKeys ?? groupBoundaryVertexKeys(group, metas);
   for (const index of group) {
     const meta = metas[index];
     if (!meta) return false;
@@ -2599,6 +2897,18 @@ function distanceVec(a: Vec3, b: Vec3): number {
   return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
 }
 
+function pointSegmentDistance(point: Vec3, segment: Segment3): number {
+  const ab = subVec(segment.b, segment.a);
+  const abLengthSq = dotVec(ab, ab);
+  if (abLengthSq <= 1e-12) return distanceVec(point, segment.a);
+  const t = Math.max(0, Math.min(1, dotVec(subVec(point, segment.a), ab) / abLengthSq));
+  return Math.hypot(
+    point[0] - (segment.a[0] + ab[0] * t),
+    point[1] - (segment.a[1] + ab[1] * t),
+    point[2] - (segment.a[2] + ab[2] * t),
+  );
+}
+
 function normalizeVec(value: Vec3): Vec3 | null {
   const length = Math.hypot(value[0], value[1], value[2]);
   if (length <= 1e-10) return null;
diff --git a/packages/polycss/package.json b/packages/polycss/package.json
index cafd2adb..4f8f0c2d 100644
--- a/packages/polycss/package.json
+++ b/packages/polycss/package.json
@@ -36,7 +36,7 @@
     "build": "tsup",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
-    "prepack": "node ../../tools/sync-package-readmes.mjs",
+    "prepack": "node ../../.github/scripts/sync-package-readmes.mjs",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {
diff --git a/packages/polycss/src/api/createPolyScene.test.ts b/packages/polycss/src/api/createPolyScene.test.ts
index 64e2c791..ea65060f 100644
--- a/packages/polycss/src/api/createPolyScene.test.ts
+++ b/packages/polycss/src/api/createPolyScene.test.ts
@@ -399,7 +399,7 @@ describe("createPolyScene", () => {
       expect(styleEl?.textContent).toContain("height: 64px;");
       expect(styleEl?.textContent).toContain("width: var(--polycss-atlas-size, 64px);");
       expect(styleEl?.textContent).toContain("height: var(--polycss-atlas-size, 64px);");
-      expect(styleEl?.textContent).toContain("border-width: 0 32px 64px 32px;");
+      expect(styleEl?.textContent).toContain("border-width: 0 16px 32px 16px;");
       expect(styleEl?.textContent).toContain("width: 0;");
       expect(styleEl?.textContent).toContain("height: 0;");
     });
diff --git a/packages/polycss/src/elements/PolyPolygonElement.test.ts b/packages/polycss/src/elements/PolyPolygonElement.test.ts
index 917731b9..425beb1a 100644
--- a/packages/polycss/src/elements/PolyPolygonElement.test.ts
+++ b/packages/polycss/src/elements/PolyPolygonElement.test.ts
@@ -130,7 +130,7 @@ describe("PolyPolygonElement — inside poly-scene", () => {
 
     const rendered = sceneEl.querySelector("u");
     expect(rendered).toBeTruthy();
-    expect(rendered?.className).toBe("");
+    expect(rendered?.className === "" || rendered?.className === "polycss-corner-triangle").toBe(true);
     cleanup();
   });
 
diff --git a/packages/polycss/src/render/polyDOM.test.ts b/packages/polycss/src/render/polyDOM.test.ts
index 2c810a73..f554878b 100644
--- a/packages/polycss/src/render/polyDOM.test.ts
+++ b/packages/polycss/src/render/polyDOM.test.ts
@@ -1,12 +1,44 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
 import { describe, it, expect, vi, afterEach } from "vitest";
 import { renderPoly } from "./polyDOM";
-import { renderPolygonsWithTextureAtlas, renderPolygonsWithTextureAtlasAsync } from "./textureAtlas";
-import type { Polygon } from "@layoutit/polycss-core";
+import {
+  renderPolygonsWithTextureAtlas,
+  renderPolygonsWithTextureAtlasAsync,
+  updatePolygonsWithStableTopology,
+} from "./textureAtlas";
+import {
+  optimizeMeshPolygons,
+  parseGltf,
+  type Polygon,
+} from "@layoutit/polycss-core";
 
 const ATLAS_CANONICAL_SIZE_EXPLICIT = 64;
 const ATLAS_CANONICAL_SIZE_AUTO_DESKTOP = 128;
 const SOLID_QUAD_CANONICAL_SIZE = 64;
-const SOLID_TRIANGLE_CANONICAL_SIZE = 64;
+
+const CORNER_SHAPE_CORPUS = [
+  ["Bear.glb"],
+  ["Cat.glb"],
+  ["Wolf.glb"],
+  ["Frog.glb"],
+  ["Bat.glb"],
+  ["apple.glb"],
+  ["Grapes.glb"],
+  ["Watermelon.glb"],
+  ["urban", "Adventurer.glb"],
+  ["urban", "Car.glb"],
+  ["urban", "Bus.glb"],
+  ["urban", "Box.glb"],
+  ["urban", "Fire hydrant.glb"],
+  ["urban", "Cone.glb"],
+  ["urban", "Mailbox.glb"],
+  ["urban", "ATM.glb"],
+  ["city", "Small Building.glb"],
+  ["city", "Large Building.glb"],
+  ["tree.glb"],
+  ["poly-pizza", "cardboard-box-closed.glb"],
+] as const;
 
 const FLAT_TRIANGLE: Polygon = {
   vertices: [
@@ -66,6 +98,17 @@ const UNSTABLE_PROJECTIVE_QUAD: Polygon = {
   color: "#ff00ff",
 };
 
+const CHAMFERED_SOLID: Polygon = {
+  vertices: [
+    [0, 0.4, 0],
+    [0, 2, 0],
+    [2, 2, 0],
+    [2, 0, 0],
+    [0.6, 0, 0],
+  ],
+  color: "#0f766e",
+};
+
 const OFFAXIS_TRIANGLE: Polygon = {
   vertices: [
     [0, 0, 0],
@@ -100,6 +143,44 @@ function roundedMatrix(values: number[], decimals = 3): number[] {
   return values.map((value) => Number(value.toFixed(decimals)));
 }
 
+function loadGalleryGlb(...parts: string[]): ArrayBuffer {
+  const filePath = resolve(__dirname, "../../../../website/public/gallery/glb", ...parts);
+  const buffer = readFileSync(filePath);
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}
+
+function supportDoc(options: { borderShape?: boolean; cornerShape?: boolean }): Document {
+  return {
+    defaultView: {
+      CSS: {
+        supports: (property: string, value?: string) => {
+          if (property === "border-shape") return options.borderShape === true;
+          if (property.startsWith("corner-") && value === "bevel") return options.cornerShape === true;
+          return false;
+        },
+      },
+      matchMedia: (query: string) => ({
+        matches: query.includes("pointer: fine") || query.includes("hover: hover"),
+      }),
+    },
+    createElement(tagName: string) {
+      if (tagName === "canvas") {
+        return { width: 0, height: 0, getContext: () => null };
+      }
+      return document.createElement(tagName);
+    },
+  } as unknown as Document;
+}
+
+function leafTagCounts(result: ReturnType<typeof renderPolygonsWithTextureAtlas>): Record<string, number> {
+  const counts: Record<string, number> = { b: 0, i: 0, s: 0, u: 0 };
+  for (const { element } of result.rendered) {
+    const tag = element.tagName.toLowerCase();
+    counts[tag] = (counts[tag] ?? 0) + 1;
+  }
+  return counts;
+}
+
 function computeExpectedPlan(
   vertices: [number, number, number][],
   tileSize = 50,
@@ -350,14 +431,14 @@ describe("renderPolygonsWithTextureAtlas", () => {
     const element = result.rendered[0].element;
     const styleText = element.getAttribute("style") ?? "";
     expect(element.tagName.toLowerCase()).toBe("u");
-    expect(styleText).toMatch(/^transform:[^;]+;color:/);
+    expect(styleText).toMatch(/^transform:/);
     expect(styleText).not.toContain("border-width:");
     expect(styleText).not.toContain("background:linear-gradient");
     expect(styleText).not.toMatch(/(^|;)width:/);
     expect(styleText).not.toMatch(/(^|;)height:/);
     const matrix = extractMatrix(element);
-    expect(Math.hypot(matrix[0], matrix[1], matrix[2])).toBeLessThan(2);
-    expect(Math.hypot(matrix[4], matrix[5], matrix[6])).toBeLessThan(2);
+    expect(Math.hypot(matrix[0], matrix[1], matrix[2])).toBeLessThan(3);
+    expect(Math.hypot(matrix[4], matrix[5], matrix[6])).toBeLessThan(3);
     result.dispose();
   });
 
@@ -386,6 +467,108 @@ describe("renderPolygonsWithTextureAtlas", () => {
     result.dispose();
   });
 
+  it("updates WebKit solid atlas fallbacks without replacing the loaded atlas", () => {
+    const doc = {
+      defaultView: {
+        navigator: {
+          userAgent: "Mozilla/5.0 AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+        },
+        CSS: { supports: () => false },
+      },
+      createElement(tagName: string) {
+        if (tagName === "canvas") {
+          return { width: 0, height: 0, getContext: () => null };
+        }
+        return document.createElement(tagName);
+      },
+    } as unknown as Document;
+
+    const result = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE], { doc });
+    const element = result.rendered[0].element;
+    element.style.background = 'url("blob:solid-atlas") 0px 0px / 8px 8px no-repeat';
+    element.style.opacity = "";
+    const beforeTransform = element.style.transform;
+
+    const updated = updatePolygonsWithStableTopology(
+      result.rendered,
+      [{
+        ...FLAT_TRIANGLE,
+        vertices: [
+          [0, 0, 0],
+          [2, 0, 0],
+          [0, 1, 0],
+        ],
+      }],
+      { doc },
+    );
+
+    expect(updated).toBe(true);
+    expect(result.rendered[0].element).toBe(element);
+    expect(element.style.background).toContain("blob:solid-atlas");
+    expect(element.style.opacity).toBe("");
+    expect(element.style.transform).not.toBe(beforeTransform);
+    result.dispose();
+  });
+
+  it("keeps WebKit solid atlas fallbacks mounted through degenerate frames", () => {
+    const doc = {
+      defaultView: {
+        navigator: {
+          userAgent: "Mozilla/5.0 AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+        },
+        CSS: { supports: () => false },
+      },
+      createElement(tagName: string) {
+        if (tagName === "canvas") {
+          return { width: 0, height: 0, getContext: () => null };
+        }
+        return document.createElement(tagName);
+      },
+    } as unknown as Document;
+
+    const result = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE], { doc });
+    const element = result.rendered[0].element;
+    element.style.background = 'url("blob:solid-atlas") 0px 0px / 8px 8px no-repeat';
+    element.style.opacity = "";
+    const beforeTransform = element.style.transform;
+
+    const degenerateUpdated = updatePolygonsWithStableTopology(
+      result.rendered,
+      [{
+        ...FLAT_TRIANGLE,
+        vertices: [
+          [0, 0, 0],
+          [0, 0, 0],
+          [0, 1, 0],
+        ],
+      }],
+      { doc },
+    );
+    expect(degenerateUpdated).toBe(true);
+    expect(result.rendered[0].element).toBe(element);
+    expect(element.style.background).toContain("blob:solid-atlas");
+    expect(element.style.visibility).toBe("hidden");
+
+    const restoredUpdated = updatePolygonsWithStableTopology(
+      result.rendered,
+      [{
+        ...FLAT_TRIANGLE,
+        vertices: [
+          [0, 0, 0],
+          [2, 0, 0],
+          [0, 1, 0],
+        ],
+      }],
+      { doc },
+    );
+    expect(restoredUpdated).toBe(true);
+    expect(result.rendered[0].element).toBe(element);
+    expect(element.style.background).toContain("blob:solid-atlas");
+    expect(element.style.visibility).toBe("");
+    expect(element.style.transform).not.toBe(beforeTransform);
+    result.dispose();
+  });
+
   it("async renderer returns the same solid triangle element shape", async () => {
     const result = await renderPolygonsWithTextureAtlasAsync([FLAT_TRIANGLE, SECOND_FLAT_TRIANGLE]);
     const element = result.rendered[0].element;
@@ -531,6 +714,80 @@ describe("renderPolygonsWithTextureAtlas", () => {
     result.dispose();
   });
 
+  it("uses bare u corner-shape boxes for exact chamfered solids", () => {
+    const doc = supportDoc({ borderShape: true, cornerShape: true });
+
+    const chamfered = renderPolygonsWithTextureAtlas([CHAMFERED_SOLID], { doc });
+    const chamferedElement = chamfered.rendered[0].element;
+    expect(chamferedElement.tagName.toLowerCase()).toBe("u");
+    expect(chamferedElement.className).toBe("");
+    expect(chamferedElement.getAttribute("style") ?? "").toMatch(/corner-[a-z-]+-shape:bevel/);
+    expect(chamferedElement.style.getPropertyValue("border-shape")).toBe("");
+    chamfered.dispose();
+
+    const fallback = renderPolygonsWithTextureAtlas([CHAMFERED_SOLID], {
+      doc: supportDoc({ borderShape: true, cornerShape: false }),
+    });
+    expect(fallback.rendered[0].element.tagName.toLowerCase()).toBe("i");
+    fallback.dispose();
+  });
+
+  it("keeps non-chamfered n-gons on border-shape when corner-shape is supported", () => {
+    const irregularSolid: Polygon = {
+      vertices: [
+        [0, 0, 0],
+        [0, 2, 0],
+        [1, 1.4, 0],
+        [2, 2, 0],
+        [2, 0, 0],
+      ],
+      color: "#f59e0b",
+    };
+    const result = renderPolygonsWithTextureAtlas([irregularSolid], {
+      doc: supportDoc({ borderShape: true, cornerShape: true }),
+    });
+    const element = result.rendered[0].element;
+    expect(element.tagName.toLowerCase()).toBe("i");
+    expect(element.style.getPropertyValue("border-shape")).toContain("polygon(");
+    result.dispose();
+  });
+
+  it("replaces a subset of border-shape leaves with u leaves across a 20-model corpus", () => {
+    const beforeDoc = supportDoc({ borderShape: true, cornerShape: false });
+    const afterDoc = supportDoc({ borderShape: true, cornerShape: true });
+    let beforeI = 0;
+    let beforeU = 0;
+    let afterI = 0;
+    let afterU = 0;
+
+    expect(CORNER_SHAPE_CORPUS).toHaveLength(20);
+
+    for (const fixture of CORNER_SHAPE_CORPUS) {
+      const parsed = parseGltf(loadGalleryGlb(...fixture));
+      const polygons = optimizeMeshPolygons(parsed.polygons, { meshResolution: "lossy" });
+      parsed.dispose();
+
+      const before = renderPolygonsWithTextureAtlas(polygons, { doc: beforeDoc });
+      const after = renderPolygonsWithTextureAtlas(polygons, { doc: afterDoc });
+      const beforeCounts = leafTagCounts(before);
+      const afterCounts = leafTagCounts(after);
+
+      beforeI += beforeCounts.i;
+      beforeU += beforeCounts.u;
+      afterI += afterCounts.i;
+      afterU += afterCounts.u;
+      expect(afterCounts.i + afterCounts.u).toBe(beforeCounts.i + beforeCounts.u);
+
+      before.dispose();
+      after.dispose();
+    }
+
+    const replaced = beforeI - afterI;
+    expect(beforeI).toBeGreaterThan(0);
+    expect(replaced).toBeGreaterThan(0);
+    expect(afterU - beforeU).toBe(replaced);
+  }, 15000);
+
   it("uses the atlas fallback for solid non-rect polygons on non-desktop pointers when projective quads are disabled", () => {
     const canvases: Array<{ width: number; height: number; getContext: () => null }> = [];
     const doc = {
@@ -1292,6 +1549,44 @@ describe("renderPolygonsWithTextureAtlas — strategies.disable", () => {
     result.dispose();
   });
 
+  it("paints solid triangles with the corner class when corner-shape is supported", () => {
+    const doc = {
+      defaultView: {
+        CSS: {
+          supports: (property: string, value?: string) =>
+            value === "bevel" &&
+            (property === "corner-top-left-shape" || property === "corner-top-right-shape"),
+        },
+      },
+      createElement: document.createElement.bind(document),
+    } as unknown as Document;
+
+    const result = renderPolygonsWithTextureAtlas(
+      [FLAT_TRIANGLE],
+      { doc },
+    );
+    const element = result.rendered[0].element;
+    expect(element.tagName.toLowerCase()).toBe("u");
+    expect(element.classList.contains("polycss-corner-triangle")).toBe(true);
+    result.dispose();
+  });
+
+  it("progressively falls back to the border triangle when corner-shape is unsupported", () => {
+    const doc = {
+      defaultView: { CSS: { supports: () => false } },
+      createElement: document.createElement.bind(document),
+    } as unknown as Document;
+
+    const result = renderPolygonsWithTextureAtlas(
+      [FLAT_TRIANGLE],
+      { doc },
+    );
+    const element = result.rendered[0].element;
+    expect(element.tagName.toLowerCase()).toBe("u");
+    expect(element.classList.contains("polycss-corner-triangle")).toBe(false);
+    result.dispose();
+  });
+
   it("axis-aligned solid rect with disable:b renders as atlas when border-shape is unsupported", () => {
     const canvases: Array<{ width: number; height: number; getContext: () => null }> = [];
     const doc = {
@@ -1402,6 +1697,36 @@ describe("renderPolygonsWithTextureAtlas — strategies.disable", () => {
     result.dispose();
   });
 
+  it("falls back to atlas for projective solid quads on Safari", () => {
+    const canvases: Array<{ width: number; height: number; getContext: () => null }> = [];
+    const doc = {
+      defaultView: {
+        navigator: {
+          userAgent: "Mozilla/5.0 AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+        },
+        CSS: { supports: () => false },
+      },
+      createElement(tagName: string) {
+        if (tagName === "canvas") {
+          const canvas = { width: 0, height: 0, getContext: () => null };
+          canvases.push(canvas);
+          return canvas;
+        }
+        return document.createElement(tagName);
+      },
+    } as unknown as Document;
+
+    const result = renderPolygonsWithTextureAtlas(
+      [NON_RECT_QUAD],
+      { doc },
+    );
+    const element = result.rendered[0].element;
+    expect(element.tagName.toLowerCase()).toBe("s");
+    expect(result.rendered[0].kind).toBe("atlas");
+    expect(canvases).toHaveLength(1);
+    result.dispose();
+  });
+
   it("projective b matrix maps planar quad corners to their CSS-space vertices", () => {
     const doc = {
       defaultView: {
@@ -1589,6 +1914,7 @@ describe("renderPolygonsWithTextureAtlas — strategies.disable", () => {
     expect(element.getAttribute("style")).not.toContain("border-width:");
     result.dispose();
   });
+
 });
 
 describe("renderPoly — data attributes and lighting", () => {
diff --git a/packages/polycss/src/render/polyDOM.ts b/packages/polycss/src/render/polyDOM.ts
index 752b6cf0..f17f8b26 100644
--- a/packages/polycss/src/render/polyDOM.ts
+++ b/packages/polycss/src/render/polyDOM.ts
@@ -2,8 +2,9 @@
  * polyDOM — compatibility wrapper for rendering a single Polygon.
  *
  * The vanilla package renders every valid polygon through the same brush
- * dispatch used by mesh rendering: rects use <b>, solid triangles use <u>,
- * sprites use <s>, and other irregular solid polygons use <i> when available.
+ * dispatch used by mesh rendering: rects use <b>, solid triangles and exact
+ * corner-shape solids use <u>, sprites use <s>, and remaining irregular solid
+ * polygons use <i> when available.
  */
 import type { Polygon } from "@layoutit/polycss-core";
 import {
diff --git a/packages/polycss/src/render/renderStats.test.ts b/packages/polycss/src/render/renderStats.test.ts
index b9c09936..08b91d1f 100644
--- a/packages/polycss/src/render/renderStats.test.ts
+++ b/packages/polycss/src/render/renderStats.test.ts
@@ -20,6 +20,7 @@ describe("collectPolyRenderStats", () => {
         <i></i>
         <s></s>
         <u></u>
+        <u style="width:16px;height:16px;corner-bottom-left-shape:bevel"></u>
         <q></q>
         <div class="polycss-bucket"><b></b><s></s></div>
       </div>
@@ -27,9 +28,9 @@ describe("collectPolyRenderStats", () => {
 
     expect(collectPolyRenderStats(root, { polygonCount: 12 })).toEqual({
       polygonCount: 12,
-      mountedPolygonLeafCount: 6,
+      mountedPolygonLeafCount: 7,
       shadowLeafCount: 1,
-      surfaceLeafCounts: { quad: 2, clippedSolid: 1, atlas: 2, stableTriangle: 1 },
+      surfaceLeafCounts: { quad: 2, clippedSolid: 1, atlas: 2, stableTriangle: 2 },
       bucketCount: 1,
     });
   });
diff --git a/packages/polycss/src/render/textureAtlas.ts b/packages/polycss/src/render/textureAtlas.ts
index 54c7ffbf..82b064fd 100644
--- a/packages/polycss/src/render/textureAtlas.ts
+++ b/packages/polycss/src/render/textureAtlas.ts
@@ -38,6 +38,7 @@ const COLOR_PARSE_CACHE_MAX = 512;
 export type TextureQuality = number | "auto";
 
 export type PolyRenderStrategy = "b" | "i" | "u";
+type SolidTrianglePrimitive = "border" | "corner-bevel";
 
 export interface PolyRenderStrategiesOption {
   /** Strategies to skip; polygons that would normally use them fall through
@@ -139,6 +140,7 @@ interface SolidTrianglePlan extends SolidTriangleColorPlan {
   styleText: string;
   transformText: string;
   basis: SolidTriangleBasis;
+  primitive: SolidTrianglePrimitive;
 }
 
 interface SolidTriangleBasis {
@@ -152,10 +154,12 @@ interface SolidTriangleComputeOptions {
   includeColor?: boolean;
   matrixDecimals?: number;
   color?: string;
+  primitive?: SolidTrianglePrimitive;
 }
 
 interface SolidTriangleElement extends HTMLElement {
   __polycssSolidTriangleBasis?: SolidTriangleBasis;
+  __polycssSolidTrianglePrimitive?: SolidTrianglePrimitive;
   __polycssSolidTriangleColor?: string;
   __polycssSolidTriangleColorRgb?: RGB;
   __polycssSolidTriangleColorAlpha?: number;
@@ -270,7 +274,7 @@ interface InternalRenderTextureAtlasOptions extends RenderTextureAtlasOptions {
 export interface RenderedPoly {
   polygonIndex: number;
   element: HTMLElement;
-  kind?: "atlas" | "solid" | "border" | "triangle";
+  kind?: "atlas" | "solid" | "border" | "corner" | "triangle";
   plan?: TextureAtlasPlan;
   dispose(): void;
 }
@@ -302,13 +306,16 @@ const DEFAULT_BORDER_SHAPE_DECIMALS = 2;
 const DEFAULT_ATLAS_CSS_DECIMALS = 4;
 const DECIMAL_SCALES = [1, 10, 100, 1000, 10000, 100000, 1000000];
 const SOLID_QUAD_CANONICAL_SIZE = 64;
-const SOLID_TRIANGLE_CANONICAL_SIZE = 64;
+const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
+const SOLID_TRIANGLE_CORNER_CLASS = "polycss-corner-triangle";
 const ATLAS_CANONICAL_SIZE_EXPLICIT = 64;
 const ATLAS_CANONICAL_SIZE_AUTO_DESKTOP = 128;
 const BORDER_SHAPE_CENTER_PERCENT = 50;
 const BORDER_SHAPE_POINT_EPS = 1e-7;
 const BORDER_SHAPE_CANONICAL_SIZE = 16;
 const BORDER_SHAPE_BLEED = 0.9;
+const CORNER_SHAPE_POINT_EPS = 0.75;
+const CORNER_SHAPE_DUPLICATE_EPS = 0.2;
 const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
 const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = Number.POSITIVE_INFINITY;
 const PROJECTIVE_QUAD_BLEED = 0.6;
@@ -332,6 +339,19 @@ interface BorderShapeGeometry {
   points: Array<[number, number]>;
 }
 
+type CornerShapeCorner = "topLeft" | "topRight" | "bottomRight" | "bottomLeft";
+type CornerShapeSide = "left" | "right" | "top" | "bottom";
+
+interface CornerShapeRadius {
+  x: number;
+  y: number;
+}
+
+interface CornerShapeGeometry {
+  bounds: BorderShapeBounds;
+  radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>>;
+}
+
 interface ProjectiveQuadGuardSettings {
   denomEps: number;
   maxWeightRatio: number;
@@ -2484,12 +2504,16 @@ function computeSolidTrianglePlanFromCssPoints(
   const basis = basisHint && basisHint.a === a && basisHint.b === b && basisHint.c === c
     ? basisHint
     : { a, b, c };
+  const doc = options.doc ?? (typeof document !== "undefined" ? document : null);
+  const primitive = computeOptions.primitive ??
+    (doc ? resolveSolidTrianglePrimitive(doc, options.strategies) ?? "border" : "border");
   return {
     index,
     polygon,
     styleText,
     transformText,
     basis,
+    primitive,
     colorComputed,
     bakedColor: bakedColorValue,
     bakedRgb,
@@ -3077,6 +3101,26 @@ function formatBorderShapeElementStyle(entry: TextureAtlasPlan): string {
   ].join(";");
 }
 
+function formatCornerShapeElementStyle(
+  entry: TextureAtlasPlan,
+  geometry: CornerShapeGeometry,
+): string {
+  const styles = [
+    `transform:matrix3d(${formatBorderShapeMatrix(entry, geometry.bounds)})`,
+    `width:${BORDER_SHAPE_CANONICAL_SIZE}px`,
+    `height:${BORDER_SHAPE_CANONICAL_SIZE}px`,
+    "border:0",
+    "box-sizing:border-box",
+    "background:currentColor",
+  ];
+  for (const [corner, radius] of Object.entries(geometry.radii) as Array<[CornerShapeCorner, CornerShapeRadius]>) {
+    const cssCorner = corner.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+    styles.push(`border-${cssCorner}-radius:${formatPercent(radius.x)} ${formatPercent(radius.y)}`);
+    styles.push(`corner-${cssCorner}-shape:bevel`);
+  }
+  return styles.join(";");
+}
+
 interface StablePlanBasis {
   normal: Vec3;
   xAxis: Vec3;
@@ -3196,9 +3240,18 @@ function updateAtlasElementWithStablePlan(
   polygon: Polygon,
   textureLighting: PolyTextureLightingMode,
 ): boolean {
-  if (!source.texture || !polygon.texture || source.texture !== polygon.texture) return false;
+  if (source.texture) {
+    if (!polygon.texture || source.texture !== polygon.texture) return false;
+  } else if (polygon.texture) {
+    return false;
+  }
   const next = stableMatrixFromPlan(source, polygon);
-  if (!next) return false;
+  if (!next) {
+    el.style.visibility = "hidden";
+    applyPolygonDataAttrs(el, polygon);
+    return true;
+  }
+  el.style.visibility = "";
   setInlineStyleProperty(el, "transform", `matrix3d(${next.matrix})`);
   if (textureLighting === "dynamic") {
     setInlineStyleProperty(el, "--pnx", next.normal[0].toFixed(4));
@@ -3297,9 +3350,44 @@ function solidTriangleSupported(doc: Document): boolean {
   const userAgent = win?.navigator?.userAgent ?? "";
   if (!userAgent) return true;
 
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function cornerShapeSupported(doc: Document): boolean {
+  const css = doc.defaultView?.CSS ?? (typeof CSS !== "undefined" ? CSS : undefined);
+  return !!css?.supports?.("corner-top-left-shape", "bevel") &&
+    !!css.supports("corner-top-right-shape", "bevel") &&
+    !!css.supports("corner-bottom-right-shape", "bevel") &&
+    !!css.supports("corner-bottom-left-shape", "bevel");
+}
+
+function cornerTriangleSupported(doc: Document): boolean {
+  const css = doc.defaultView?.CSS ?? (typeof CSS !== "undefined" ? CSS : undefined);
+  return !!css?.supports?.("corner-top-left-shape", "bevel") &&
+    !!css.supports("corner-top-right-shape", "bevel");
+}
+
+function resolveSolidTrianglePrimitive(
+  doc: Document,
+  strategies?: PolyRenderStrategiesOption,
+): SolidTrianglePrimitive | null {
+  if (strategies?.disable?.includes("u")) return null;
+  if (cornerTriangleSupported(doc)) return "corner-bevel";
+  return solidTriangleSupported(doc) ? "border" : null;
+}
+
+function projectiveQuadSupported(doc: Document): boolean {
+  const win = doc.defaultView ?? (typeof window !== "undefined" ? window : undefined);
+  const userAgent = win?.navigator?.userAgent ?? "";
+  if (!userAgent) return true;
+
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function safariCssProjectiveUnsupported(userAgent: string): boolean {
   const isChromiumFamily = /\b(?:Chrome|HeadlessChrome|Chromium|Edg|OPR)\//.test(userAgent);
   const isSafariFamily = /\bVersion\/[\d.]+.*\bSafari\//.test(userAgent);
-  return !isSafariFamily || isChromiumFamily;
+  return isSafariFamily && !isChromiumFamily;
 }
 
 function incrementCount(map: Map<string, number>, key: string): void {
@@ -3322,24 +3410,28 @@ function getSolidPaintDefaultsForPlans(
   plans: Array<TextureAtlasPlan | null>,
   textureLighting: PolyTextureLightingMode,
   doc: Document,
-  disabled: ReadonlySet<PolyRenderStrategy>,
+  strategies?: PolyRenderStrategiesOption,
 ): SolidPaintDefaults {
   const paintCounts = new Map<string, number>();
   const dynamicCounts = new Map<string, number>();
   const dynamicColors = new Map<string, RGB>();
+  const disabled = new Set(strategies?.disable ?? []);
   const useFullRectSolid = !disabled.has("b");
-  const useProjectiveQuad = useFullRectSolid;
-  const useStableTriangle = !disabled.has("u") && solidTriangleSupported(doc);
+  const useProjectiveQuad = useFullRectSolid && projectiveQuadSupported(doc);
+  const useStableTriangle = resolveSolidTrianglePrimitive(doc, strategies) !== null;
+  const useCornerShapeSolid = !disabled.has("i") && cornerShapeSupported(doc);
   const useBorderShape = !disabled.has("i") && borderShapeSupported(doc);
 
   for (const plan of plans) {
     if (!plan || plan.texture) continue;
+    const usesCornerShape = useCornerShapeSolid && !!cornerShapeGeometryForPlan(plan);
 
     if (textureLighting === "dynamic") {
       if (
         !(useStableTriangle && isSolidTrianglePlan(plan)) &&
         !(useFullRectSolid && isFullRectSolid(plan)) &&
         !(useProjectiveQuad && isProjectiveQuadPlan(plan)) &&
+        !usesCornerShape &&
         !useBorderShape
       ) continue;
       const color = parseHex(plan.polygon.color ?? "#cccccc");
@@ -3353,6 +3445,7 @@ function getSolidPaintDefaultsForPlans(
       !(useStableTriangle && isSolidTrianglePlan(plan)) &&
       !(useFullRectSolid && isFullRectSolid(plan)) &&
       !(useProjectiveQuad && isProjectiveQuadPlan(plan)) &&
+      !usesCornerShape &&
       !useBorderShape
     ) continue;
     incrementCount(paintCounts, plan.shadedColor);
@@ -3383,7 +3476,6 @@ export function getSolidPaintDefaults(
 ): SolidPaintDefaults {
   const doc = options.doc ?? (typeof document !== "undefined" ? document : null);
   if (!doc) return {};
-  const disabled = new Set(options.strategies?.disable ?? []);
   const basisHints = buildBasisHints(polygons, options);
   const projectiveQuadGuards = resolveProjectiveQuadGuards(doc);
   const plans = polygons.map((polygon, index) =>
@@ -3393,7 +3485,7 @@ export function getSolidPaintDefaults(
     plans,
     options.textureLighting ?? "baked",
     doc,
-    disabled,
+    options.strategies,
   );
 }
 
@@ -3448,6 +3540,126 @@ function borderShapeGeometryForPlan(entry: TextureAtlasPlan): BorderShapeGeometr
   return { bounds, points };
 }
 
+function simplifyCornerShapePoints(points: Array<[number, number]>): Array<[number, number]> {
+  const simplified: Array<[number, number]> = [];
+  for (const point of points) {
+    const previous = simplified[simplified.length - 1];
+    if (
+      previous &&
+      Math.hypot(previous[0] - point[0], previous[1] - point[1]) <= CORNER_SHAPE_DUPLICATE_EPS
+    ) {
+      continue;
+    }
+    simplified.push(point);
+  }
+  if (simplified.length > 1) {
+    const first = simplified[0];
+    const last = simplified[simplified.length - 1];
+    if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= CORNER_SHAPE_DUPLICATE_EPS) {
+      simplified.pop();
+    }
+  }
+  return simplified;
+}
+
+function cornerShapePointSides([x, y]: [number, number]): Set<CornerShapeSide> | null {
+  const sides = new Set<CornerShapeSide>();
+  if (Math.abs(x) <= CORNER_SHAPE_POINT_EPS) sides.add("left");
+  if (Math.abs(x - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("right");
+  if (Math.abs(y) <= CORNER_SHAPE_POINT_EPS) sides.add("top");
+  if (Math.abs(y - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("bottom");
+  return sides.size > 0 ? sides : null;
+}
+
+function sharedCornerShapeSide(a: Set<CornerShapeSide>, b: Set<CornerShapeSide>): boolean {
+  for (const side of a) {
+    if (b.has(side)) return true;
+  }
+  return false;
+}
+
+function cornerShapeDiagonal(
+  aPoint: [number, number],
+  aSides: Set<CornerShapeSide>,
+  bPoint: [number, number],
+  bSides: Set<CornerShapeSide>,
+): [CornerShapeCorner, CornerShapeRadius] | null {
+  const read = (
+    corner: CornerShapeCorner,
+    horizontal: CornerShapeSide,
+    vertical: CornerShapeSide,
+  ): [CornerShapeCorner, CornerShapeRadius] | null => {
+    const horizontalPoint = aSides.has(horizontal) ? aPoint : bSides.has(horizontal) ? bPoint : null;
+    const verticalPoint = aSides.has(vertical) ? aPoint : bSides.has(vertical) ? bPoint : null;
+    if (!horizontalPoint || !verticalPoint) return null;
+    const radius = (() => {
+      switch (corner) {
+        case "topLeft":
+          return { x: horizontalPoint[0], y: verticalPoint[1] };
+        case "topRight":
+          return { x: 100 - horizontalPoint[0], y: verticalPoint[1] };
+        case "bottomRight":
+          return { x: 100 - horizontalPoint[0], y: 100 - verticalPoint[1] };
+        case "bottomLeft":
+          return { x: horizontalPoint[0], y: 100 - verticalPoint[1] };
+      }
+    })();
+    return radius.x > CORNER_SHAPE_POINT_EPS &&
+        radius.y > CORNER_SHAPE_POINT_EPS &&
+        radius.x < 100 - CORNER_SHAPE_POINT_EPS &&
+        radius.y < 100 - CORNER_SHAPE_POINT_EPS
+      ? [corner, radius]
+      : null;
+  };
+
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("topLeft", "top", "left");
+  }
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("topRight", "top", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("bottomRight", "bottom", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("bottomLeft", "bottom", "left");
+  }
+  return null;
+}
+
+function cornerShapeGeometryForPlan(entry: TextureAtlasPlan): CornerShapeGeometry | null {
+  if (entry.texture || isSolidTrianglePlan(entry) || isFullRectSolid(entry)) return null;
+  const geometry = borderShapeGeometryForPlan(entry);
+  const points = simplifyCornerShapePoints(geometry.points);
+  if (points.length < 4) return null;
+
+  const sides = points.map(cornerShapePointSides);
+  if (sides.some((side) => !side)) return null;
+
+  const radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>> = {};
+  let diagonalCount = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const aSides = sides[i]!;
+    const bSides = sides[(i + 1) % points.length]!;
+    if (sharedCornerShapeSide(aSides, bSides)) continue;
+    const diagonal = cornerShapeDiagonal(points[i], aSides, points[(i + 1) % points.length], bSides);
+    if (!diagonal) return null;
+    const [corner, radius] = diagonal;
+    const previous = radii[corner];
+    if (
+      previous &&
+      (Math.abs(previous.x - radius.x) > CORNER_SHAPE_POINT_EPS ||
+        Math.abs(previous.y - radius.y) > CORNER_SHAPE_POINT_EPS)
+    ) {
+      return null;
+    }
+    radii[corner] = radius;
+    diagonalCount += 1;
+  }
+
+  return diagonalCount > 0 ? { bounds: geometry.bounds, radii } : null;
+}
+
 function cssBorderShapePoint([x, y]: [number, number]): string {
   return `${formatPercent(x)} ${formatPercent(y)}`;
 }
@@ -3562,6 +3774,22 @@ function createBorderShapeSolidElement(
   return el;
 }
 
+function createCornerShapeSolidElement(
+  entry: TextureAtlasPlan,
+  geometry: CornerShapeGeometry,
+  textureLighting: PolyTextureLightingMode,
+  doc: Document,
+  solidPaintDefaults?: SolidPaintDefaults,
+): HTMLElement {
+  const el = doc.createElement("u");
+  el.setAttribute("style", formatCornerShapeElementStyle(entry, geometry));
+  applyPolygonDataAttrs(el, entry.polygon);
+  applySolidPaint(el, entry, textureLighting, solidPaintDefaults);
+  setInlineStyleProperty(el, "background", "currentColor");
+
+  return el;
+}
+
 function createProjectiveSolidElement(
   entry: TextureAtlasPlan & { projectiveMatrix: string },
   textureLighting: PolyTextureLightingMode,
@@ -3609,6 +3837,20 @@ function updateBorderShapeElementWithStablePlan(
   applyPolygonDataAttrs(el, entry.polygon);
 }
 
+function updateCornerShapeElementWithStablePlan(
+  el: HTMLElement,
+  entry: TextureAtlasPlan,
+  geometry: CornerShapeGeometry,
+  textureLighting: PolyTextureLightingMode,
+  solidPaintDefaults?: SolidPaintDefaults,
+): void {
+  el.style.visibility = "";
+  el.setAttribute("style", formatCornerShapeElementStyle(entry, geometry));
+  applySolidPaint(el, entry, textureLighting, solidPaintDefaults);
+  setInlineStyleProperty(el, "background", "currentColor");
+  applyPolygonDataAttrs(el, entry.polygon);
+}
+
 function createAtlasElement(
   entry: PackedTextureAtlasEntry,
   textureLighting: PolyTextureLightingMode,
@@ -3638,8 +3880,10 @@ export function renderPolygonsWithTextureAtlas(
   const textureLighting = options.textureLighting ?? "baked";
   const disabled = new Set(options.strategies?.disable ?? []);
   const useFullRectSolid = !disabled.has("b");
-  const useProjectiveQuad = useFullRectSolid;
-  const useStableTriangle = !disabled.has("u") && solidTriangleSupported(doc);
+  const useProjectiveQuad = useFullRectSolid && projectiveQuadSupported(doc);
+  const solidTrianglePrimitive = resolveSolidTrianglePrimitive(doc, options.strategies);
+  const useStableTriangle = solidTrianglePrimitive !== null;
+  const useCornerShapeSolid = !disabled.has("i") && cornerShapeSupported(doc);
   const useBorderShape = !disabled.has("i") && borderShapeSupported(doc);
   const basisHints = buildBasisHints(polygons, options);
   const projectiveQuadGuards = resolveProjectiveQuadGuards(doc);
@@ -3648,14 +3892,25 @@ export function renderPolygonsWithTextureAtlas(
   );
   const trianglePlans = plans.map((plan) =>
     plan && useStableTriangle && isSolidTrianglePlan(plan)
-      ? computeSolidTrianglePlan(plan.polygon, plan.index, options)
+      ? computeSolidTrianglePlan(plan.polygon, plan.index, options, {
+          primitive: solidTrianglePrimitive ?? undefined,
+        })
+      : null
+  );
+  const cornerShapePlans = plans.map((plan) =>
+    plan &&
+    useCornerShapeSolid &&
+    !isSolidTrianglePlan(plan) &&
+    !(useFullRectSolid && isFullRectSolid(plan)) &&
+    !(useProjectiveQuad && isProjectiveQuadPlan(plan))
+      ? cornerShapeGeometryForPlan(plan)
       : null
   );
   const atlasPlans = plans.map((plan, index) =>
     plan &&
     (plan.texture
       ? plan
-      : (!(useFullRectSolid && isFullRectSolid(plan)) && !trianglePlans[index] && !(useProjectiveQuad && isProjectiveQuadPlan(plan)) && !useBorderShape) ? plan : null)
+      : (!(useFullRectSolid && isFullRectSolid(plan)) && !trianglePlans[index] && !(useProjectiveQuad && isProjectiveQuadPlan(plan)) && !cornerShapePlans[index] && !useBorderShape) ? plan : null)
   );
   const { packed, atlasScale } = packTextureAtlasPlansWithScale(atlasPlans, options.textureQuality, doc);
   const atlasElements = new Map<number, HTMLElement>();
@@ -3666,6 +3921,7 @@ export function renderPolygonsWithTextureAtlas(
   for (let i = 0; i < polygons.length; i++) {
     const plan = plans[i];
     const trianglePlan = trianglePlans[i];
+    const cornerShapePlan = cornerShapePlans[i];
     if (!plan) continue;
 
     const entry = packed.entries[i];
@@ -3682,6 +3938,9 @@ export function renderPolygonsWithTextureAtlas(
     } else if (!plan.texture && useProjectiveQuad && isProjectiveQuadPlan(plan)) {
       const element = createProjectiveSolidElement(plan, textureLighting, doc, options.solidPaintDefaults);
       rendered.push({ polygonIndex: i, element, kind: "solid", plan, dispose: () => {} });
+    } else if (!plan.texture && cornerShapePlan) {
+      const element = createCornerShapeSolidElement(plan, cornerShapePlan, textureLighting, doc, options.solidPaintDefaults);
+      rendered.push({ polygonIndex: i, element, kind: "corner", plan, dispose: () => {} });
     } else if (!plan.texture && useBorderShape) {
       const element = createBorderShapeSolidElement(plan, textureLighting, doc, options.solidPaintDefaults);
       rendered.push({ polygonIndex: i, element, kind: "border", plan, dispose: () => {} });
@@ -3742,8 +4001,10 @@ export async function renderPolygonsWithTextureAtlasAsync(
   const textureLighting = options.textureLighting ?? "baked";
   const disabled = new Set(options.strategies?.disable ?? []);
   const useFullRectSolid = !disabled.has("b");
-  const useProjectiveQuad = useFullRectSolid;
-  const useStableTriangle = !disabled.has("u") && solidTriangleSupported(doc);
+  const useProjectiveQuad = useFullRectSolid && projectiveQuadSupported(doc);
+  const solidTrianglePrimitive = resolveSolidTrianglePrimitive(doc, options.strategies);
+  const useStableTriangle = solidTrianglePrimitive !== null;
+  const useCornerShapeSolid = !disabled.has("i") && cornerShapeSupported(doc);
   const useBorderShape = !disabled.has("i") && borderShapeSupported(doc);
   await yieldToMainThread();
   if (shouldCancel()) return { rendered: [], solidPaintDefaults: {}, dispose: () => {} };
@@ -3759,19 +4020,30 @@ export async function renderPolygonsWithTextureAtlasAsync(
   }
 
   const solidPaintDefaults = options.solidPaintDefaults ??
-    getSolidPaintDefaultsForPlans(plans, textureLighting, doc, disabled);
+    getSolidPaintDefaultsForPlans(plans, textureLighting, doc, options.strategies);
   const trianglePlans: Array<SolidTrianglePlan | null> = new Array(plans.length);
+  const cornerShapePlans: Array<CornerShapeGeometry | null> = new Array(plans.length);
   const atlasPlans: Array<TextureAtlasPlan | null> = new Array(plans.length);
   for (let i = 0; i < plans.length; i++) {
     const plan = plans[i];
     const trianglePlan = plan && useStableTriangle && isSolidTrianglePlan(plan)
-      ? computeSolidTrianglePlan(plan.polygon, plan.index, { ...options, solidPaintDefaults })
+      ? computeSolidTrianglePlan(plan.polygon, plan.index, { ...options, solidPaintDefaults }, {
+          primitive: solidTrianglePrimitive ?? undefined,
+        })
       : null;
     trianglePlans[i] = trianglePlan;
+    const cornerShapePlan = plan &&
+        useCornerShapeSolid &&
+        !isSolidTrianglePlan(plan) &&
+        !(useFullRectSolid && isFullRectSolid(plan)) &&
+        !(useProjectiveQuad && isProjectiveQuadPlan(plan))
+      ? cornerShapeGeometryForPlan(plan)
+      : null;
+    cornerShapePlans[i] = cornerShapePlan;
     atlasPlans[i] = plan &&
       (plan.texture
         ? plan
-        : (!(useFullRectSolid && isFullRectSolid(plan)) && !trianglePlan && !(useProjectiveQuad && isProjectiveQuadPlan(plan)) && !useBorderShape) ? plan : null);
+        : (!(useFullRectSolid && isFullRectSolid(plan)) && !trianglePlan && !(useProjectiveQuad && isProjectiveQuadPlan(plan)) && !cornerShapePlan && !useBorderShape) ? plan : null);
     batchStarted = await yieldIfOverBudget(batchStarted);
     if (shouldCancel()) return { rendered: [], solidPaintDefaults, dispose: () => {} };
   }
@@ -3785,6 +4057,7 @@ export async function renderPolygonsWithTextureAtlasAsync(
   for (let i = 0; i < polygons.length; i++) {
     const plan = plans[i];
     const trianglePlan = trianglePlans[i];
+    const cornerShapePlan = cornerShapePlans[i];
     if (!plan) continue;
 
     const entry = packed.entries[i];
@@ -3801,6 +4074,9 @@ export async function renderPolygonsWithTextureAtlasAsync(
     } else if (!plan.texture && useProjectiveQuad && isProjectiveQuadPlan(plan)) {
       const element = createProjectiveSolidElement(plan, textureLighting, doc, solidPaintDefaults);
       rendered.push({ polygonIndex: i, element, kind: "solid", plan, dispose: () => {} });
+    } else if (!plan.texture && cornerShapePlan) {
+      const element = createCornerShapeSolidElement(plan, cornerShapePlan, textureLighting, doc, solidPaintDefaults);
+      rendered.push({ polygonIndex: i, element, kind: "corner", plan, dispose: () => {} });
     } else if (!plan.texture && useBorderShape) {
       const element = createBorderShapeSolidElement(plan, textureLighting, doc, solidPaintDefaults);
       rendered.push({ polygonIndex: i, element, kind: "border", plan, dispose: () => {} });
@@ -3874,6 +4150,7 @@ function applySolidTriangleElement(
   entry: SolidTrianglePlan,
 ): void {
   el.setAttribute("style", entry.styleText);
+  applySolidTrianglePrimitive(el, entry.primitive);
   const triangleEl = el as SolidTriangleElement;
   triangleEl.__polycssSolidTriangleBasis = entry.basis;
   triangleEl.__polycssSolidTriangleHidden = false;
@@ -3941,6 +4218,7 @@ function applySolidTriangleElementFast(
   colorUpdateAllowed?: boolean,
 ): void {
   const triangleEl = el as SolidTriangleElement;
+  applySolidTrianglePrimitive(el, entry.primitive);
   if (triangleEl.__polycssSolidTriangleBasis !== entry.basis) {
     triangleEl.__polycssSolidTriangleBasis = entry.basis;
   }
@@ -3966,6 +4244,7 @@ function applySolidTriangleElementTransformOnly(
   entry: SolidTrianglePlan,
 ): void {
   const triangleEl = el as SolidTriangleElement;
+  applySolidTrianglePrimitive(el, entry.primitive);
   if (triangleEl.__polycssSolidTriangleBasis !== entry.basis) {
     triangleEl.__polycssSolidTriangleBasis = entry.basis;
   }
@@ -3976,6 +4255,16 @@ function applySolidTriangleElementTransformOnly(
   }
 }
 
+function applySolidTrianglePrimitive(
+  el: HTMLElement,
+  primitive: SolidTrianglePrimitive,
+): void {
+  const triangleEl = el as SolidTriangleElement;
+  if (triangleEl.__polycssSolidTrianglePrimitive === primitive) return;
+  el.classList.toggle(SOLID_TRIANGLE_CORNER_CLASS, primitive === "corner-bevel");
+  triangleEl.__polycssSolidTrianglePrimitive = primitive;
+}
+
 function showSolidTriangleElement(el: HTMLElement): void {
   const triangleEl = el as SolidTriangleElement;
   if (!triangleEl.__polycssSolidTriangleHidden) return;
@@ -4250,7 +4539,8 @@ export function renderPolygonsWithStableTriangles(
 ): RenderTextureAtlasResult | null {
   const doc = options.doc ?? (typeof document !== "undefined" ? document : null);
   if (!doc) return { rendered: [], dispose: () => {} };
-  if (!solidTriangleSupported(doc)) return null;
+  const solidTrianglePrimitive = resolveSolidTrianglePrimitive(doc, options.strategies);
+  if (!solidTrianglePrimitive) return null;
   if (polygons.some((polygon) => polygon.texture || polygon.vertices.length !== 3)) {
     return null;
   }
@@ -4259,7 +4549,10 @@ export function renderPolygonsWithStableTriangles(
 
   for (let i = 0; i < polygons.length; i += 1) {
     const polygon = polygons[i];
-    const plan = computeSolidTrianglePlan(polygon, i, options, { matrixDecimals });
+    const plan = computeSolidTrianglePlan(polygon, i, options, {
+      matrixDecimals,
+      primitive: solidTrianglePrimitive,
+    });
     const element = plan
       ? createSolidTriangleElement(plan, doc)
       : createHiddenSolidTriangleElement(polygon, doc);
@@ -4279,7 +4572,8 @@ export function updatePolygonsWithStableTriangles(
 ): RenderTextureAtlasResult | null {
   const doc = options.doc ?? (typeof document !== "undefined" ? document : null);
   if (!doc) return { rendered, dispose: () => {} };
-  if (!solidTriangleSupported(doc)) return null;
+  const solidTrianglePrimitive = resolveSolidTrianglePrimitive(doc, options.strategies);
+  if (!solidTrianglePrimitive) return null;
   if (rendered.some((item) => item.kind !== "triangle")) return null;
   if (polygons.length !== rendered.length) return null;
   for (let i = 0; i < rendered.length; i++) {
@@ -4406,7 +4700,8 @@ export function updatePolygonsWithStableTopology(
   const textureLighting = options.textureLighting ?? "baked";
   const disabled = new Set(options.strategies?.disable ?? []);
   const useFullRectSolid = !disabled.has("b");
-  const useProjectiveQuad = useFullRectSolid;
+  const useProjectiveQuad = !!doc && useFullRectSolid && projectiveQuadSupported(doc);
+  const useCornerShapeSolid = !!doc && !disabled.has("i") && cornerShapeSupported(doc);
   const useBorderShape = !!doc && !disabled.has("i") && borderShapeSupported(doc);
   const projectiveQuadGuards = doc
     ? resolveProjectiveQuadGuards(doc)
@@ -4509,7 +4804,24 @@ export function updatePolygonsWithStableTopology(
         plan.texture ||
         !useBorderShape ||
         (useFullRectSolid && isFullRectSolid(plan)) ||
-        (useProjectiveQuad && isProjectiveQuadPlan(plan))
+        (useProjectiveQuad && isProjectiveQuadPlan(plan)) ||
+        (useCornerShapeSolid && !!cornerShapeGeometryForPlan(plan))
+      ) {
+        return false;
+      }
+      nextTexturePlans[i] = plan;
+      continue;
+    }
+    if (item.kind === "corner") {
+      const plan = computeTextureAtlasPlan(polygon, i, options, projectiveQuadGuards);
+      if (
+        !plan ||
+        plan.texture ||
+        !useCornerShapeSolid ||
+        isSolidTrianglePlan(plan) ||
+        (useFullRectSolid && isFullRectSolid(plan)) ||
+        (useProjectiveQuad && isProjectiveQuadPlan(plan)) ||
+        !cornerShapeGeometryForPlan(plan)
       ) {
         return false;
       }
@@ -4582,6 +4894,17 @@ export function updatePolygonsWithStableTopology(
       const plan = nextTexturePlans[i];
       if (!plan) return false;
       updateBorderShapeElementWithStablePlan(item.element, plan, textureLighting, internalOptions.solidPaintDefaults);
+    } else if (item.kind === "corner") {
+      const plan = nextTexturePlans[i];
+      const geometry = plan ? cornerShapeGeometryForPlan(plan) : null;
+      if (!plan || !geometry) return false;
+      updateCornerShapeElementWithStablePlan(
+        item.element,
+        plan,
+        geometry,
+        textureLighting,
+        internalOptions.solidPaintDefaults,
+      );
     }
   }
 
diff --git a/packages/polycss/src/styles/styles.ts b/packages/polycss/src/styles/styles.ts
index fc238cc3..09d3f399 100644
--- a/packages/polycss/src/styles/styles.ts
+++ b/packages/polycss/src/styles/styles.ts
@@ -125,7 +125,18 @@ const CORE_BASE_STYLES = `
   box-sizing: content-box;
   border: 0 solid transparent;
   border-color: transparent transparent currentColor transparent;
-  border-width: 0 32px 64px 32px;
+  border-width: 0 16px 32px 16px;
+}
+
+.polycss-scene u.polycss-corner-triangle {
+  width: 32px;
+  height: 32px;
+  background: currentColor;
+  border: 0;
+  border-top-left-radius: 50% 100%;
+  border-top-right-radius: 50% 100%;
+  corner-top-left-shape: bevel;
+  corner-top-right-shape: bevel;
 }
 
 /* <q> — dedicated shadow leaf. Same border-shape rendering trick as <i>
diff --git a/packages/react/package.json b/packages/react/package.json
index dd2348d8..fddcbd1d 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -31,7 +31,7 @@
     "build": "tsup",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "prepack": "node ../../tools/sync-package-readmes.mjs",
+    "prepack": "node ../../.github/scripts/sync-package-readmes.mjs",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {
diff --git a/packages/react/src/scene/PolyMesh.tsx b/packages/react/src/scene/PolyMesh.tsx
index a398a170..4d00f43c 100644
--- a/packages/react/src/scene/PolyMesh.tsx
+++ b/packages/react/src/scene/PolyMesh.tsx
@@ -499,6 +499,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
   // global CSS rule with default normals.
   const sceneCtx = usePolySceneContext();
   const effectiveTextureLighting = textureLighting ?? sceneCtx?.textureLighting ?? "baked";
+  const effectiveStrategies = sceneCtx?.strategies;
   const effectiveDirectional =
     effectiveTextureLighting === "dynamic" ? undefined : sceneCtx?.directionalLight;
   const effectiveAmbient =
@@ -556,10 +557,11 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
     atlasPlans,
     effectiveTextureLighting,
     textureQuality,
+    effectiveStrategies,
   );
   const solidPaintDefaults = useMemo(
-    () => !renderPolygon ? getSolidPaintDefaults(atlasPlans, effectiveTextureLighting) : {},
-    [renderPolygon, atlasPlans, effectiveTextureLighting],
+    () => !renderPolygon ? getSolidPaintDefaults(atlasPlans, effectiveTextureLighting, effectiveStrategies) : {},
+    [renderPolygon, atlasPlans, effectiveTextureLighting, effectiveStrategies],
   );
   const defaultPaintVars = useMemo(
     () => solidPaintVars(solidPaintDefaults),
@@ -632,6 +634,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
         directionalLight: bakedDirectional,
         ambientLight: effectiveAmbient,
         textureLighting: effectiveTextureLighting,
+        strategies: effectiveStrategies,
         colorFrame: ++stableTriangleColorFrameRef.current,
         colorSteps: 8,
         colorFreezeFrames: 12,
@@ -667,19 +670,21 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
               entry={entry}
               page={textureAtlas.pages[entry.pageIndex]}
               textureLighting={effectiveTextureLighting}
+              solidPaintDefaults={solidPaintDefaults}
             />
           );
         }
 
         const plan = atlasPlans[index];
         if (!plan || plan.texture) return null;
-        return isSolidTrianglePlan(plan)
+        return textureAtlas.solidTrianglePrimitive && isSolidTrianglePlan(plan)
           ? (
               <TextureTrianglePoly
                 key={plan.index}
                 entry={plan}
                 textureLighting={effectiveTextureLighting}
                 solidPaintDefaults={solidPaintDefaults}
+                solidTrianglePrimitive={textureAtlas.solidTrianglePrimitive}
               />
             )
           : (
diff --git a/packages/react/src/scene/PolyScene.test.tsx b/packages/react/src/scene/PolyScene.test.tsx
index bc14893f..925254e2 100644
--- a/packages/react/src/scene/PolyScene.test.tsx
+++ b/packages/react/src/scene/PolyScene.test.tsx
@@ -322,6 +322,21 @@ describe("PolyScene — strategies.disable", () => {
     expect(fallback).toBeTruthy();
   });
 
+  it("renders corner-shape triangles by default when supported", () => {
+    vi.stubGlobal("CSS", {
+      supports: vi.fn((property: string, value?: string) =>
+        value === "bevel" &&
+        (property === "corner-top-left-shape" || property === "corner-top-right-shape")
+      ),
+    });
+    const container = renderScene({
+      polygons: [TRIANGLE],
+    });
+    const poly = container.querySelector("u") as HTMLElement | null;
+    expect(poly).toBeTruthy();
+    expect(poly!.classList.contains("polycss-corner-triangle")).toBe(true);
+  });
+
   it("disabling b renders a rect through border-shape when supported", () => {
     vi.stubGlobal("CSS", {
       supports: vi.fn((property: string) => property === "border-shape"),
diff --git a/packages/react/src/scene/PolyScene.tsx b/packages/react/src/scene/PolyScene.tsx
index 9c1c730f..62eb1bb6 100644
--- a/packages/react/src/scene/PolyScene.tsx
+++ b/packages/react/src/scene/PolyScene.tsx
@@ -364,10 +364,17 @@ function PolySceneInner({
     // When "u" is disabled they fall to <i> (border-shape, if supported) or
     // <s> (atlas). The atlas path is handled above via packed.entries; the <i>
     // fallback lands here via TextureBorderShapePoly (same as non-rect solids).
-    const useU = !disabledStrategies?.has("u");
+    const useU = textureAtlas.solidTrianglePrimitive !== null;
     const useProjectiveSolid = !disabledStrategies?.has("b");
     if (useU && isSolidTrianglePlan(plan)) {
-      return <TextureTrianglePoly key={plan.index} entry={plan} textureLighting={textureLighting} />;
+      return (
+        <TextureTrianglePoly
+          key={plan.index}
+          entry={plan}
+          textureLighting={textureLighting}
+          solidTrianglePrimitive={textureAtlas.solidTrianglePrimitive}
+        />
+      );
     }
     if (useProjectiveSolid && isProjectiveQuadPlan(plan)) {
       return <TextureProjectiveSolidPoly key={plan.index} entry={plan} textureLighting={textureLighting} />;
@@ -381,8 +388,15 @@ function PolySceneInner({
   // while the scene's global CSS rule paints over it with the dynamic
   // calc — producing corrupt tints.
   const sceneCtxValue = useMemo(
-    () => ({ textureLighting, directionalLight, ambientLight, shadow, registerShadowCaster }),
-    [textureLighting, directionalLight, ambientLight, shadow, registerShadowCaster],
+    () => ({
+      textureLighting,
+      directionalLight,
+      ambientLight,
+      strategies,
+      shadow,
+      registerShadowCaster,
+    }),
+    [textureLighting, directionalLight, ambientLight, strategies, shadow, registerShadowCaster],
   );
 
   return (
diff --git a/packages/react/src/scene/sceneContext.ts b/packages/react/src/scene/sceneContext.ts
index a432b876..46f23bbc 100644
--- a/packages/react/src/scene/sceneContext.ts
+++ b/packages/react/src/scene/sceneContext.ts
@@ -12,6 +12,7 @@ import type {
   PolyTextureLightingMode,
   Polygon,
 } from "@layoutit/polycss-core";
+import type { PolyRenderStrategiesOption } from "./textureAtlas";
 
 export interface ShadowOptions {
   color?: string;
@@ -23,6 +24,7 @@ export interface PolySceneContextValue {
   textureLighting: PolyTextureLightingMode;
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
+  strategies?: PolyRenderStrategiesOption;
   shadow?: ShadowOptions;
   /**
    * Called by PolyMesh to register/unregister itself as a shadow caster.
diff --git a/packages/react/src/scene/textureAtlas.tsx b/packages/react/src/scene/textureAtlas.tsx
index a6945d6b..1fa091d8 100644
--- a/packages/react/src/scene/textureAtlas.tsx
+++ b/packages/react/src/scene/textureAtlas.tsx
@@ -14,6 +14,7 @@ import { parsePureColor } from "@layoutit/polycss-core";
 
 /** A render strategy tag that can be selectively disabled. */
 export type PolyRenderStrategy = "b" | "i" | "u";
+type SolidTrianglePrimitive = "border" | "corner-bevel";
 
 export interface PolyRenderStrategiesOption {
   /** Strategies to skip; polygons that would normally use them fall through
@@ -42,12 +43,14 @@ const DEFAULT_MATRIX_DECIMALS = 3;
 const DEFAULT_BORDER_SHAPE_DECIMALS = 2;
 const DEFAULT_ATLAS_CSS_DECIMALS = 4;
 const SOLID_QUAD_CANONICAL_SIZE = 64;
-const SOLID_TRIANGLE_CANONICAL_SIZE = 64;
+const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
 const ATLAS_CANONICAL_SIZE_EXPLICIT = 64;
 const ATLAS_CANONICAL_SIZE_AUTO_DESKTOP = 128;
 const BORDER_SHAPE_CENTER_PERCENT = 50;
 const BORDER_SHAPE_POINT_EPS = 1e-7;
 const BORDER_SHAPE_CANONICAL_SIZE = 16;
+const CORNER_SHAPE_POINT_EPS = 0.75;
+const CORNER_SHAPE_DUPLICATE_EPS = 0.2;
 const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
 const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = 4;
 const PROJECTIVE_QUAD_BLEED = 0.6;
@@ -98,6 +101,18 @@ interface ProjectiveQuadCoefficients {
   w3: number;
 }
 
+type CornerShapeCorner = "topLeft" | "topRight" | "bottomRight" | "bottomLeft";
+type CornerShapeSide = "left" | "right" | "top" | "bottom";
+
+interface CornerShapeRadius {
+  x: number;
+  y: number;
+}
+
+interface CornerShapeGeometry {
+  radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>>;
+}
+
 export interface TextureAtlasPlan {
   index: number;
   polygon: Polygon;
@@ -161,6 +176,7 @@ export interface TextureAtlasResult {
   entries: Array<PackedTextureAtlasEntry | null>;
   pages: TextureAtlasPage[];
   ready: boolean;
+  solidTrianglePrimitive: SolidTrianglePrimitive | null;
 }
 
 export interface SolidPaintDefaults {
@@ -525,9 +541,40 @@ function solidTriangleSupported(): boolean {
   const userAgent = (typeof window !== "undefined" ? window.navigator : globalThis.navigator)?.userAgent ?? "";
   if (!userAgent) return true;
 
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function cornerTriangleSupported(): boolean {
+  return !!globalThis.CSS?.supports?.("corner-top-left-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-top-right-shape", "bevel");
+}
+
+function cornerShapeSupported(): boolean {
+  return !!globalThis.CSS?.supports?.("corner-top-left-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-top-right-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-bottom-right-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-bottom-left-shape", "bevel");
+}
+
+function resolveSolidTrianglePrimitive(
+  strategies?: PolyRenderStrategiesOption,
+): SolidTrianglePrimitive | null {
+  if (strategies?.disable?.includes("u")) return null;
+  if (cornerTriangleSupported()) return "corner-bevel";
+  return solidTriangleSupported() ? "border" : null;
+}
+
+function projectiveQuadSupported(): boolean {
+  const userAgent = (typeof window !== "undefined" ? window.navigator : globalThis.navigator)?.userAgent ?? "";
+  if (!userAgent) return true;
+
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function safariCssProjectiveUnsupported(userAgent: string): boolean {
   const isChromiumFamily = /\b(?:Chrome|HeadlessChrome|Chromium|Edg|OPR)\//.test(userAgent);
   const isSafariFamily = /\bVersion\/[\d.]+.*\bSafari\//.test(userAgent);
-  return !isSafariFamily || isChromiumFamily;
+  return isSafariFamily && !isChromiumFamily;
 }
 
 function incrementCount(map: Map<string, number>, key: string): void {
@@ -577,15 +624,19 @@ function orderBrushInlineStyle(el: HTMLElement): void {
 export function getSolidPaintDefaults(
   plans: Array<TextureAtlasPlan | null>,
   textureLighting: PolyTextureLightingMode,
+  strategies?: PolyRenderStrategiesOption,
 ): SolidPaintDefaults {
   const paintCounts = new Map<string, number>();
   const dynamicCounts = new Map<string, number>();
   const dynamicColors = new Map<string, RGB>();
-  const useStableTriangle = solidTriangleSupported();
-  const useBorderShape = textureLighting !== "dynamic" && borderShapeSupported();
+  const disabled = new Set(strategies?.disable ?? []);
+  const useStableTriangle = resolveSolidTrianglePrimitive(strategies) !== null;
+  const useCornerShapeSolid = textureLighting !== "dynamic" && !disabled.has("i") && cornerShapeSupported();
+  const useBorderShape = textureLighting !== "dynamic" && !disabled.has("i") && borderShapeSupported();
 
   for (const plan of plans) {
     if (!plan || plan.texture) continue;
+    const usesCornerShape = useCornerShapeSolid && !!cornerShapeGeometryForPlan(plan);
 
     if (textureLighting === "dynamic") {
       if (!(useStableTriangle && isSolidTrianglePlan(plan)) && !isFullRectSolid(plan)) continue;
@@ -596,7 +647,12 @@ export function getSolidPaintDefaults(
       continue;
     }
 
-    if (!(useStableTriangle && isSolidTrianglePlan(plan)) && !isFullRectSolid(plan) && !useBorderShape) continue;
+    if (
+      !(useStableTriangle && isSolidTrianglePlan(plan)) &&
+      !isFullRectSolid(plan) &&
+      !usesCornerShape &&
+      !useBorderShape
+    ) continue;
     incrementCount(paintCounts, plan.shadedColor);
   }
 
@@ -649,6 +705,125 @@ export function cssBorderShapeForPlan(entry: TextureAtlasPlan): string {
   return `${cssPolygonShapeForPoints(points)} ${cssCollapsedInnerShapeForPoints(points)}`;
 }
 
+function simplifyCornerShapePoints(points: Array<[number, number]>): Array<[number, number]> {
+  const simplified: Array<[number, number]> = [];
+  for (const point of points) {
+    const previous = simplified[simplified.length - 1];
+    if (
+      previous &&
+      Math.hypot(previous[0] - point[0], previous[1] - point[1]) <= CORNER_SHAPE_DUPLICATE_EPS
+    ) {
+      continue;
+    }
+    simplified.push(point);
+  }
+  if (simplified.length > 1) {
+    const first = simplified[0];
+    const last = simplified[simplified.length - 1];
+    if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= CORNER_SHAPE_DUPLICATE_EPS) {
+      simplified.pop();
+    }
+  }
+  return simplified;
+}
+
+function cornerShapePointSides([x, y]: [number, number]): Set<CornerShapeSide> | null {
+  const sides = new Set<CornerShapeSide>();
+  if (Math.abs(x) <= CORNER_SHAPE_POINT_EPS) sides.add("left");
+  if (Math.abs(x - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("right");
+  if (Math.abs(y) <= CORNER_SHAPE_POINT_EPS) sides.add("top");
+  if (Math.abs(y - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("bottom");
+  return sides.size > 0 ? sides : null;
+}
+
+function sharedCornerShapeSide(a: Set<CornerShapeSide>, b: Set<CornerShapeSide>): boolean {
+  for (const side of a) {
+    if (b.has(side)) return true;
+  }
+  return false;
+}
+
+function cornerShapeDiagonal(
+  aPoint: [number, number],
+  aSides: Set<CornerShapeSide>,
+  bPoint: [number, number],
+  bSides: Set<CornerShapeSide>,
+): [CornerShapeCorner, CornerShapeRadius] | null {
+  const read = (
+    corner: CornerShapeCorner,
+    horizontal: CornerShapeSide,
+    vertical: CornerShapeSide,
+  ): [CornerShapeCorner, CornerShapeRadius] | null => {
+    const horizontalPoint = aSides.has(horizontal) ? aPoint : bSides.has(horizontal) ? bPoint : null;
+    const verticalPoint = aSides.has(vertical) ? aPoint : bSides.has(vertical) ? bPoint : null;
+    if (!horizontalPoint || !verticalPoint) return null;
+    const radius = (() => {
+      switch (corner) {
+        case "topLeft":
+          return { x: horizontalPoint[0], y: verticalPoint[1] };
+        case "topRight":
+          return { x: 100 - horizontalPoint[0], y: verticalPoint[1] };
+        case "bottomRight":
+          return { x: 100 - horizontalPoint[0], y: 100 - verticalPoint[1] };
+        case "bottomLeft":
+          return { x: horizontalPoint[0], y: 100 - verticalPoint[1] };
+      }
+    })();
+    return radius.x > CORNER_SHAPE_POINT_EPS &&
+        radius.y > CORNER_SHAPE_POINT_EPS &&
+        radius.x < 100 - CORNER_SHAPE_POINT_EPS &&
+        radius.y < 100 - CORNER_SHAPE_POINT_EPS
+      ? [corner, radius]
+      : null;
+  };
+
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("topLeft", "top", "left");
+  }
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("topRight", "top", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("bottomRight", "bottom", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("bottomLeft", "bottom", "left");
+  }
+  return null;
+}
+
+function cornerShapeGeometryForPlan(entry: TextureAtlasPlan): CornerShapeGeometry | null {
+  if (entry.texture || isSolidTrianglePlan(entry) || isFullRectSolid(entry)) return null;
+  const points = simplifyCornerShapePoints(borderShapePointsForPlan(entry));
+  if (points.length < 4) return null;
+
+  const sides = points.map(cornerShapePointSides);
+  if (sides.some((side) => !side)) return null;
+
+  const radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>> = {};
+  let diagonalCount = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const aSides = sides[i]!;
+    const bSides = sides[(i + 1) % points.length]!;
+    if (sharedCornerShapeSide(aSides, bSides)) continue;
+    const diagonal = cornerShapeDiagonal(points[i], aSides, points[(i + 1) % points.length], bSides);
+    if (!diagonal) return null;
+    const [corner, radius] = diagonal;
+    const previous = radii[corner];
+    if (
+      previous &&
+      (Math.abs(previous.x - radius.x) > CORNER_SHAPE_POINT_EPS ||
+        Math.abs(previous.y - radius.y) > CORNER_SHAPE_POINT_EPS)
+    ) {
+      return null;
+    }
+    radii[corner] = radius;
+    diagonalCount += 1;
+  }
+
+  return diagonalCount > 0 ? { radii } : null;
+}
+
 function formatMatrix3dValues(values: readonly number[], decimals = DEFAULT_MATRIX_DECIMALS): string {
   return values.map((value) => roundDecimal(value, decimals)).join(",");
 }
@@ -687,6 +862,31 @@ function formatSolidQuadMatrix(entry: TextureAtlasPlan): string {
   );
 }
 
+function cornerShapeRadiusStyle(geometry: CornerShapeGeometry): CSSProperties {
+  const style: CSSProperties = {};
+  for (const [corner, radius] of Object.entries(geometry.radii) as Array<[CornerShapeCorner, CornerShapeRadius]>) {
+    const property = `border${corner[0].toUpperCase()}${corner.slice(1)}Radius`;
+    (style as Record<string, string>)[property] = `${formatPercent(radius.x)} ${formatPercent(radius.y)}`;
+  }
+  return style;
+}
+
+const CORNER_SHAPE_PROPERTIES = [
+  "corner-top-left-shape",
+  "corner-top-right-shape",
+  "corner-bottom-right-shape",
+  "corner-bottom-left-shape",
+] as const;
+
+function applyCornerShapeProperties(el: HTMLElement, geometry: CornerShapeGeometry | null): void {
+  for (const property of CORNER_SHAPE_PROPERTIES) el.style.removeProperty(property);
+  if (!geometry) return;
+  for (const corner of Object.keys(geometry.radii) as CornerShapeCorner[]) {
+    const cssCorner = corner.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+    el.style.setProperty(`corner-${cssCorner}-shape`, "bevel");
+  }
+}
+
 function isConvexPolygonPoints(points: Array<[number, number]>): boolean {
   if (points.length < 3) return false;
   let sign = 0;
@@ -1210,6 +1410,7 @@ export interface StableTriangleDomUpdateOptions {
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
+  strategies?: PolyRenderStrategiesOption;
   colorFrame?: number;
   colorSteps?: number;
   colorFreezeFrames?: number;
@@ -1542,7 +1743,7 @@ export function updateStableTriangleDom(
   options: StableTriangleDomUpdateOptions = {},
 ): boolean {
   if ((options.textureLighting ?? "baked") !== "baked") return false;
-  if (!solidTriangleSupported()) return false;
+  if (!resolveSolidTrianglePrimitive(options.strategies)) return false;
   const leaves = Array.from(root.children).filter(
     (child): child is StableTriangleDomElement =>
       child instanceof HTMLElement && child.localName === "u",
@@ -2362,10 +2563,11 @@ export function useTextureAtlas(
 ): TextureAtlasResult {
   const disableB = strategies?.disable?.includes("b") ?? false;
   const disableI = strategies?.disable?.includes("i") ?? false;
-  const disableU = strategies?.disable?.includes("u") ?? false;
   const useFullRectSolid = !disableB;
-  const useProjectiveQuad = useFullRectSolid;
-  const useStableTriangle = !disableU && solidTriangleSupported();
+  const useProjectiveQuad = useFullRectSolid && projectiveQuadSupported();
+  const solidTrianglePrimitive = resolveSolidTrianglePrimitive(strategies);
+  const useStableTriangle = solidTrianglePrimitive !== null;
+  const useCornerShapeSolid = !disableI && textureLighting !== "dynamic" && cornerShapeSupported();
   const useBorderShape = !disableI && textureLighting !== "dynamic" && borderShapeSupported();
   const atlasPlans = useMemo(
     () => plans.map((plan) => {
@@ -2374,16 +2576,22 @@ export function useTextureAtlas(
       // Exclude solid triangles from atlas only when <u> is active.
       // When u is disabled they fall to <i> (if border-shape supported) or <s>.
       if (useStableTriangle && isSolidTrianglePlan(plan)) return null;
-      // Exclude full-rect solids (<b> path) and border-shape eligible polys (<i> path).
+      // Exclude full-rect solids (<b> path) and clipped-solid polys (<u>/<i> path).
       const fullRect = isFullRectSolid(plan);
+      const cornerShape = useCornerShapeSolid &&
+        !fullRect &&
+        !isSolidTrianglePlan(plan) &&
+        !(useProjectiveQuad && isProjectiveQuadPlan(plan)) &&
+        cornerShapeGeometryForPlan(plan);
       if (
         (useFullRectSolid && fullRect) ||
         (useProjectiveQuad && isProjectiveQuadPlan(plan)) ||
+        cornerShape ||
         (textureLighting !== "dynamic" && useBorderShape && (!fullRect || disableB))
       ) return null;
       return plan;
     }),
-    [plans, textureLighting, useFullRectSolid, useProjectiveQuad, useStableTriangle, useBorderShape],
+    [plans, textureLighting, useFullRectSolid, useProjectiveQuad, useStableTriangle, useCornerShapeSolid, useBorderShape, disableB],
   );
   const { packed, atlasScale } = useMemo(
     () => packTextureAtlasPlansWithScale(
@@ -2433,6 +2641,7 @@ export function useTextureAtlas(
     entries: packed.entries,
     pages,
     ready: pages.length === 0 || pages.every((page) => !!page.url),
+    solidTrianglePrimitive,
   };
 }
 
@@ -2460,16 +2669,21 @@ export function TextureBorderShapePoly({
   // the full-rect poly as <i> instead. The `disabledStrategies` set is only
   // populated when strategies.disable was explicitly set by the caller.
   const bDisabled = disabledStrategies?.has("b") ?? false;
+  const iDisabled = disabledStrategies?.has("i") ?? false;
   const useIForFullRect = bDisabled && borderShapeSupported();
-  const borderShape = (!fullRect || useIForFullRect) ? cssBorderShapeForPlan(entry) : null;
+  const cornerShape = !iDisabled && !fullRect && cornerShapeSupported()
+    ? cornerShapeGeometryForPlan(entry)
+    : null;
+  const borderShape = !cornerShape && (!fullRect || useIForFullRect) ? cssBorderShapeForPlan(entry) : null;
   const useDefaultPaint = entry.shadedColor === solidPaintDefaults?.paintColor;
   const setElementRef = useCallback((el: HTMLElement | null) => {
     if (!el) return;
     if (borderShape) el.style.setProperty("border-shape", borderShape);
     else el.style.removeProperty("border-shape");
+    applyCornerShapeProperties(el, cornerShape);
     orderBrushInlineStyle(el);
-  }, [borderShape]);
-  const transform = formatMatrix3d(borderShape ? formatBorderShapeMatrix(entry) : formatSolidQuadMatrix(entry));
+  }, [borderShape, cornerShape]);
+  const transform = formatMatrix3d(borderShape || cornerShape ? formatBorderShapeMatrix(entry) : formatSolidQuadMatrix(entry));
   const style: CSSProperties = fullRect
     ? {
         transform,
@@ -2477,6 +2691,19 @@ export function TextureBorderShapePoly({
         pointerEvents: pointerEvents === "none" ? "none" : undefined,
         ...styleProp,
       }
+    : cornerShape
+    ? {
+        transform,
+        width: `${BORDER_SHAPE_CANONICAL_SIZE}px`,
+        height: `${BORDER_SHAPE_CANONICAL_SIZE}px`,
+        border: 0,
+        boxSizing: "border-box",
+        background: "currentColor",
+        ...cornerShapeRadiusStyle(cornerShape),
+        color: useDefaultPaint ? undefined : entry.shadedColor,
+        pointerEvents: pointerEvents === "none" ? "none" : undefined,
+        ...styleProp,
+      }
     : {
         transform,
         color: useDefaultPaint ? undefined : entry.shadedColor,
@@ -2503,6 +2730,19 @@ export function TextureBorderShapePoly({
     );
   }
 
+  if (cornerShape) {
+    return (
+      <u
+        ref={setElementRef}
+        className={elementClassName}
+        style={style}
+        {...domEventHandlers}
+        {...dataAttrs}
+        {...domAttrs}
+      />
+    );
+  }
+
   return (
     <i
       ref={setElementRef}
@@ -2584,6 +2824,7 @@ export function TextureTrianglePoly({
   entry,
   textureLighting,
   solidPaintDefaults,
+  solidTrianglePrimitive,
   className,
   style: styleProp,
   domAttrs,
@@ -2593,13 +2834,19 @@ export function TextureTrianglePoly({
   entry: TextureAtlasPlan;
   textureLighting: PolyTextureLightingMode;
   solidPaintDefaults?: SolidPaintDefaults;
+  solidTrianglePrimitive?: SolidTrianglePrimitive | null;
   className?: string;
   style?: CSSProperties;
   domAttrs?: Record<string, unknown>;
   domEventHandlers?: React.DOMAttributes<Element>;
   pointerEvents?: "auto" | "none";
 }) {
-  const triangleStyle = solidTriangleStyle(entry, textureLighting, pointerEvents, solidPaintDefaults);
+  const triangleStyle = solidTriangleStyle(
+    entry,
+    textureLighting,
+    pointerEvents,
+    solidPaintDefaults,
+  );
   if (!triangleStyle) return null;
 
   const dataAttrs = entry.polygon.data
@@ -2607,7 +2854,10 @@ export function TextureTrianglePoly({
         Object.entries(entry.polygon.data).map(([k, v]) => [`data-${k}`, String(v)]),
       )
     : {};
-  const elementClassName = className?.trim() || undefined;
+  const elementClassName = [
+    className?.trim(),
+    solidTrianglePrimitive === "corner-bevel" ? "polycss-corner-triangle" : "",
+  ].filter(Boolean).join(" ") || undefined;
 
   return (
     <u
@@ -2624,6 +2874,7 @@ export function TextureAtlasPoly({
   entry,
   page,
   textureLighting,
+  solidPaintDefaults: _solidPaintDefaults,
   className,
   style: styleProp,
   domAttrs,
@@ -2633,6 +2884,7 @@ export function TextureAtlasPoly({
   entry: PackedTextureAtlasEntry;
   page: TextureAtlasPage | undefined;
   textureLighting: PolyTextureLightingMode;
+  solidPaintDefaults?: SolidPaintDefaults;
   className?: string;
   style?: CSSProperties;
   domAttrs?: Record<string, unknown>;
diff --git a/packages/react/src/shapes/Poly.test.tsx b/packages/react/src/shapes/Poly.test.tsx
index 38948fa6..c23ad45a 100644
--- a/packages/react/src/shapes/Poly.test.tsx
+++ b/packages/react/src/shapes/Poly.test.tsx
@@ -152,6 +152,23 @@ describe("Poly — non-horizontal geometry", () => {
     expect(poly.style.width).toBe("");
     expect(poly.style.height).toBe("");
   });
+
+  it("falls back to atlas for solid non-rect quads on Safari", () => {
+    const userAgent = vi.spyOn(window.navigator, "userAgent", "get").mockReturnValue(
+      "Mozilla/5.0 AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+    );
+    vi.stubGlobal("CSS", { supports: () => false });
+
+    try {
+      const container = renderPoly({ vertices: NON_RECT_QUAD_VERTS });
+      const poly = getPoly(container);
+      expect(poly.tagName.toLowerCase()).toBe("s");
+      expect(poly.style.getPropertyValue("border-shape")).toBe("");
+    } finally {
+      userAgent.mockRestore();
+      vi.unstubAllGlobals();
+    }
+  });
 });
 
 describe("Poly — texture without UVs", () => {
diff --git a/packages/react/src/styles/styles.test.ts b/packages/react/src/styles/styles.test.ts
index aae7533e..3d0b6238 100644
--- a/packages/react/src/styles/styles.test.ts
+++ b/packages/react/src/styles/styles.test.ts
@@ -52,7 +52,7 @@ describe("injectPolyBaseStyles", () => {
     expect(el.textContent).toContain("height: 64px;");
     expect(el.textContent).toContain("width: var(--polycss-atlas-size, 64px);");
     expect(el.textContent).toContain("height: var(--polycss-atlas-size, 64px);");
-    expect(el.textContent).toContain("border-width: 0 32px 64px 32px;");
+    expect(el.textContent).toContain("border-width: 0 16px 32px 16px;");
     expect(el.textContent).toContain("width: 0;");
     expect(el.textContent).toContain("height: 0;");
   });
diff --git a/packages/react/src/styles/styles.ts b/packages/react/src/styles/styles.ts
index c62cdc0b..01d622db 100644
--- a/packages/react/src/styles/styles.ts
+++ b/packages/react/src/styles/styles.ts
@@ -121,7 +121,18 @@ const CORE_BASE_STYLES = `
   box-sizing: content-box;
   border: 0 solid transparent;
   border-color: transparent transparent currentColor transparent;
-  border-width: 0 32px 64px 32px;
+  border-width: 0 16px 32px 16px;
+}
+
+.polycss-scene u.polycss-corner-triangle {
+  width: 32px;
+  height: 32px;
+  background: currentColor;
+  border: 0;
+  border-top-left-radius: 50% 100%;
+  border-top-right-radius: 50% 100%;
+  corner-top-left-shape: bevel;
+  corner-top-right-shape: bevel;
 }
 
 /* ── Gizmo override ─────────────────────────────────────────────────────── */
diff --git a/packages/vue/package.json b/packages/vue/package.json
index f67ad737..44715526 100644
--- a/packages/vue/package.json
+++ b/packages/vue/package.json
@@ -31,7 +31,7 @@
     "build": "tsup",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "prepack": "node ../../tools/sync-package-readmes.mjs",
+    "prepack": "node ../../.github/scripts/sync-package-readmes.mjs",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {
diff --git a/packages/vue/src/scene/PolyMesh.ts b/packages/vue/src/scene/PolyMesh.ts
index 41927e12..93cd8104 100644
--- a/packages/vue/src/scene/PolyMesh.ts
+++ b/packages/vue/src/scene/PolyMesh.ts
@@ -215,6 +215,7 @@ export const PolyMesh = defineComponent({
     const atlasTextureLighting = computed<PolyTextureLightingMode>(
       () => props.textureLighting ?? sceneCtx?.value.textureLighting ?? "baked",
     );
+    const atlasStrategies = computed(() => sceneCtx?.value.strategies);
     const atlasDirectional = computed(() =>
       atlasTextureLighting.value === "dynamic" ? undefined : sceneCtx?.value.directionalLight,
     );
@@ -270,9 +271,9 @@ export const PolyMesh = defineComponent({
       );
     });
     const atlasTextureQuality = computed(() => props.textureQuality);
-    const textureAtlas = useTextureAtlas(textureAtlasPlans, atlasTextureLighting, atlasTextureQuality);
+    const textureAtlas = useTextureAtlas(textureAtlasPlans, atlasTextureLighting, atlasTextureQuality, atlasStrategies);
     const solidPaintDefaults = computed<SolidPaintDefaults>(() =>
-      atlasAutoRender ? getSolidPaintDefaults(textureAtlasPlans.value, atlasTextureLighting.value) : {},
+      atlasAutoRender ? getSolidPaintDefaults(textureAtlasPlans.value, atlasTextureLighting.value, atlasStrategies.value) : {},
     );
     const defaultPaintVars = computed(() => solidPaintVars(solidPaintDefaults.value));
 
@@ -371,6 +372,7 @@ export const PolyMesh = defineComponent({
             directionalLight: bakedDirectional.value,
             ambientLight: atlasAmbient.value,
             textureLighting: atlasTextureLighting.value,
+            strategies: atlasStrategies.value,
             colorFrame: ++stableTriangleColorFrame.value,
             colorSteps: 8,
             colorFreezeFrames: 12,
@@ -623,15 +625,17 @@ export const PolyMesh = defineComponent({
                 entry,
                 page: textureAtlas.pages.value[entry.pageIndex],
                 textureLighting: atlasTextureLighting.value,
+                solidPaintDefaults: solidPaintDefaults.value,
               });
             }
             const plan = textureAtlasPlans.value[index];
             if (!plan || plan.texture) return null;
-            return isSolidTrianglePlan(plan)
+            return textureAtlas.solidTrianglePrimitive.value && isSolidTrianglePlan(plan)
               ? renderTextureTrianglePoly({
                   entry: plan,
                   textureLighting: atlasTextureLighting.value,
                   solidPaintDefaults: solidPaintDefaults.value,
+                  solidTrianglePrimitive: textureAtlas.solidTrianglePrimitive.value,
                 })
               : renderTextureBorderShapePoly({
                   entry: plan,
diff --git a/packages/vue/src/scene/PolyScene.test.ts b/packages/vue/src/scene/PolyScene.test.ts
index 63c7dd5d..2550a088 100644
--- a/packages/vue/src/scene/PolyScene.test.ts
+++ b/packages/vue/src/scene/PolyScene.test.ts
@@ -309,6 +309,21 @@ describe("PolyScene (Vue) — strategies", () => {
     expect(poly).toBeTruthy();
   });
 
+  it("renders corner-shape triangles by default when supported", () => {
+    vi.stubGlobal("CSS", {
+      supports: vi.fn((property: string, value?: string) =>
+        value === "bevel" &&
+        (property === "corner-top-left-shape" || property === "corner-top-right-shape")
+      ),
+    });
+    const { container } = renderScene({
+      polygons: [TRIANGLE],
+    });
+    const poly = container.querySelector("u") as HTMLElement | null;
+    expect(poly).toBeTruthy();
+    expect(poly!.classList.contains("polycss-corner-triangle")).toBe(true);
+  });
+
   it("disabling b renders a rect through border-shape when supported", () => {
     vi.stubGlobal("CSS", {
       supports: vi.fn((property: string) => property === "border-shape"),
diff --git a/packages/vue/src/scene/PolyScene.ts b/packages/vue/src/scene/PolyScene.ts
index 56103918..fe45e42a 100644
--- a/packages/vue/src/scene/PolyScene.ts
+++ b/packages/vue/src/scene/PolyScene.ts
@@ -157,6 +157,7 @@ export const PolyScene = defineComponent({
       textureLighting: props.textureLighting ?? "baked",
       directionalLight: props.directionalLight,
       ambientLight: props.ambientLight,
+      strategies: props.strategies,
       shadow: props.shadow,
       shadowRegistry,
     }));
@@ -382,6 +383,7 @@ export const PolyScene = defineComponent({
           return renderTextureTrianglePoly({
             entry: plan,
             textureLighting: ctx.textureLighting ?? "baked",
+            solidTrianglePrimitive: textureAtlas.solidTrianglePrimitive.value,
           });
         }
         if (textureAtlas.useProjectiveQuad.value && isProjectiveQuadPlan(plan)) {
diff --git a/packages/vue/src/scene/sceneContext.ts b/packages/vue/src/scene/sceneContext.ts
index b43b87da..1edcb80b 100644
--- a/packages/vue/src/scene/sceneContext.ts
+++ b/packages/vue/src/scene/sceneContext.ts
@@ -12,6 +12,7 @@ import type {
   PolyTextureLightingMode,
   Polygon,
 } from "@layoutit/polycss-core";
+import type { PolyRenderStrategiesOption } from "./textureAtlas";
 
 export interface PolyShadowOptions {
   color?: string;
@@ -34,6 +35,7 @@ export interface PolySceneContextValue {
   textureLighting: PolyTextureLightingMode;
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
+  strategies?: PolyRenderStrategiesOption;
   shadow?: PolyShadowOptions;
   shadowRegistry?: PolyShadowRegistry;
 }
diff --git a/packages/vue/src/scene/textureAtlas.ts b/packages/vue/src/scene/textureAtlas.ts
index c6ef3bee..d5415c8d 100644
--- a/packages/vue/src/scene/textureAtlas.ts
+++ b/packages/vue/src/scene/textureAtlas.ts
@@ -42,12 +42,14 @@ const DEFAULT_MATRIX_DECIMALS = 3;
 const DEFAULT_BORDER_SHAPE_DECIMALS = 2;
 const DEFAULT_ATLAS_CSS_DECIMALS = 4;
 const SOLID_QUAD_CANONICAL_SIZE = 64;
-const SOLID_TRIANGLE_CANONICAL_SIZE = 64;
+const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
 const ATLAS_CANONICAL_SIZE_EXPLICIT = 64;
 const ATLAS_CANONICAL_SIZE_AUTO_DESKTOP = 128;
 const BORDER_SHAPE_CENTER_PERCENT = 50;
 const BORDER_SHAPE_POINT_EPS = 1e-7;
 const BORDER_SHAPE_CANONICAL_SIZE = 16;
+const CORNER_SHAPE_POINT_EPS = 0.75;
+const CORNER_SHAPE_DUPLICATE_EPS = 0.2;
 const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
 const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = 4;
 const PROJECTIVE_QUAD_BLEED = 0.6;
@@ -57,6 +59,7 @@ const SOLID_TRIANGLE_BLEED = 0.6;
 export type TextureQuality = number | "auto";
 
 export type PolyRenderStrategy = "b" | "i" | "u";
+type SolidTrianglePrimitive = "border" | "corner-bevel";
 
 export interface PolyRenderStrategiesOption {
   /** Strategies to skip; polygons that would normally use them fall through
@@ -107,6 +110,18 @@ interface ProjectiveQuadCoefficients {
   w3: number;
 }
 
+type CornerShapeCorner = "topLeft" | "topRight" | "bottomRight" | "bottomLeft";
+type CornerShapeSide = "left" | "right" | "top" | "bottom";
+
+interface CornerShapeRadius {
+  x: number;
+  y: number;
+}
+
+interface CornerShapeGeometry {
+  radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>>;
+}
+
 export interface TextureAtlasPlan {
   index: number;
   polygon: Polygon;
@@ -173,6 +188,7 @@ export interface TextureAtlasResult {
   useFullRectSolid: ComputedRef<boolean>;
   useProjectiveQuad: ComputedRef<boolean>;
   useStableTriangle: ComputedRef<boolean>;
+  solidTrianglePrimitive: ComputedRef<SolidTrianglePrimitive | null>;
   useBorderShape: ComputedRef<boolean>;
 }
 
@@ -533,9 +549,40 @@ function solidTriangleSupported(): boolean {
   const userAgent = (typeof window !== "undefined" ? window.navigator : globalThis.navigator)?.userAgent ?? "";
   if (!userAgent) return true;
 
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function cornerTriangleSupported(): boolean {
+  return !!globalThis.CSS?.supports?.("corner-top-left-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-top-right-shape", "bevel");
+}
+
+function cornerShapeSupported(): boolean {
+  return !!globalThis.CSS?.supports?.("corner-top-left-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-top-right-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-bottom-right-shape", "bevel") &&
+    !!globalThis.CSS.supports("corner-bottom-left-shape", "bevel");
+}
+
+function resolveSolidTrianglePrimitive(
+  strategies?: PolyRenderStrategiesOption,
+): SolidTrianglePrimitive | null {
+  if (strategies?.disable?.includes("u")) return null;
+  if (cornerTriangleSupported()) return "corner-bevel";
+  return solidTriangleSupported() ? "border" : null;
+}
+
+function projectiveQuadSupported(): boolean {
+  const userAgent = (typeof window !== "undefined" ? window.navigator : globalThis.navigator)?.userAgent ?? "";
+  if (!userAgent) return true;
+
+  return !safariCssProjectiveUnsupported(userAgent);
+}
+
+function safariCssProjectiveUnsupported(userAgent: string): boolean {
   const isChromiumFamily = /\b(?:Chrome|HeadlessChrome|Chromium|Edg|OPR)\//.test(userAgent);
   const isSafariFamily = /\bVersion\/[\d.]+.*\bSafari\//.test(userAgent);
-  return !isSafariFamily || isChromiumFamily;
+  return isSafariFamily && !isChromiumFamily;
 }
 
 function incrementCount(map: Map<string, number>, key: string): void {
@@ -585,15 +632,19 @@ function orderBrushInlineStyle(el: HTMLElement): void {
 export function getSolidPaintDefaults(
   plans: Array<TextureAtlasPlan | null>,
   textureLighting: PolyTextureLightingMode,
+  strategies?: PolyRenderStrategiesOption,
 ): SolidPaintDefaults {
   const paintCounts = new Map<string, number>();
   const dynamicCounts = new Map<string, number>();
   const dynamicColors = new Map<string, RGB>();
-  const useStableTriangle = solidTriangleSupported();
-  const useBorderShape = textureLighting !== "dynamic" && borderShapeSupported();
+  const disabled = new Set(strategies?.disable ?? []);
+  const useStableTriangle = resolveSolidTrianglePrimitive(strategies) !== null;
+  const useCornerShapeSolid = textureLighting !== "dynamic" && !disabled.has("i") && cornerShapeSupported();
+  const useBorderShape = textureLighting !== "dynamic" && !disabled.has("i") && borderShapeSupported();
 
   for (const plan of plans) {
     if (!plan || plan.texture) continue;
+    const usesCornerShape = useCornerShapeSolid && !!cornerShapeGeometryForPlan(plan);
 
     if (textureLighting === "dynamic") {
       if (!(useStableTriangle && isSolidTrianglePlan(plan)) && !isFullRectSolid(plan)) continue;
@@ -604,7 +655,12 @@ export function getSolidPaintDefaults(
       continue;
     }
 
-    if (!(useStableTriangle && isSolidTrianglePlan(plan)) && !isFullRectSolid(plan) && !useBorderShape) continue;
+    if (
+      !(useStableTriangle && isSolidTrianglePlan(plan)) &&
+      !isFullRectSolid(plan) &&
+      !usesCornerShape &&
+      !useBorderShape
+    ) continue;
     incrementCount(paintCounts, plan.shadedColor);
   }
 
@@ -657,6 +713,125 @@ export function cssBorderShapeForPlan(entry: TextureAtlasPlan): string {
   return `${cssPolygonShapeForPoints(points)} ${cssCollapsedInnerShapeForPoints(points)}`;
 }
 
+function simplifyCornerShapePoints(points: Array<[number, number]>): Array<[number, number]> {
+  const simplified: Array<[number, number]> = [];
+  for (const point of points) {
+    const previous = simplified[simplified.length - 1];
+    if (
+      previous &&
+      Math.hypot(previous[0] - point[0], previous[1] - point[1]) <= CORNER_SHAPE_DUPLICATE_EPS
+    ) {
+      continue;
+    }
+    simplified.push(point);
+  }
+  if (simplified.length > 1) {
+    const first = simplified[0];
+    const last = simplified[simplified.length - 1];
+    if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= CORNER_SHAPE_DUPLICATE_EPS) {
+      simplified.pop();
+    }
+  }
+  return simplified;
+}
+
+function cornerShapePointSides([x, y]: [number, number]): Set<CornerShapeSide> | null {
+  const sides = new Set<CornerShapeSide>();
+  if (Math.abs(x) <= CORNER_SHAPE_POINT_EPS) sides.add("left");
+  if (Math.abs(x - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("right");
+  if (Math.abs(y) <= CORNER_SHAPE_POINT_EPS) sides.add("top");
+  if (Math.abs(y - 100) <= CORNER_SHAPE_POINT_EPS) sides.add("bottom");
+  return sides.size > 0 ? sides : null;
+}
+
+function sharedCornerShapeSide(a: Set<CornerShapeSide>, b: Set<CornerShapeSide>): boolean {
+  for (const side of a) {
+    if (b.has(side)) return true;
+  }
+  return false;
+}
+
+function cornerShapeDiagonal(
+  aPoint: [number, number],
+  aSides: Set<CornerShapeSide>,
+  bPoint: [number, number],
+  bSides: Set<CornerShapeSide>,
+): [CornerShapeCorner, CornerShapeRadius] | null {
+  const read = (
+    corner: CornerShapeCorner,
+    horizontal: CornerShapeSide,
+    vertical: CornerShapeSide,
+  ): [CornerShapeCorner, CornerShapeRadius] | null => {
+    const horizontalPoint = aSides.has(horizontal) ? aPoint : bSides.has(horizontal) ? bPoint : null;
+    const verticalPoint = aSides.has(vertical) ? aPoint : bSides.has(vertical) ? bPoint : null;
+    if (!horizontalPoint || !verticalPoint) return null;
+    const radius = (() => {
+      switch (corner) {
+        case "topLeft":
+          return { x: horizontalPoint[0], y: verticalPoint[1] };
+        case "topRight":
+          return { x: 100 - horizontalPoint[0], y: verticalPoint[1] };
+        case "bottomRight":
+          return { x: 100 - horizontalPoint[0], y: 100 - verticalPoint[1] };
+        case "bottomLeft":
+          return { x: horizontalPoint[0], y: 100 - verticalPoint[1] };
+      }
+    })();
+    return radius.x > CORNER_SHAPE_POINT_EPS &&
+        radius.y > CORNER_SHAPE_POINT_EPS &&
+        radius.x < 100 - CORNER_SHAPE_POINT_EPS &&
+        radius.y < 100 - CORNER_SHAPE_POINT_EPS
+      ? [corner, radius]
+      : null;
+  };
+
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("topLeft", "top", "left");
+  }
+  if ((aSides.has("top") || bSides.has("top")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("topRight", "top", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("right") || bSides.has("right"))) {
+    return read("bottomRight", "bottom", "right");
+  }
+  if ((aSides.has("bottom") || bSides.has("bottom")) && (aSides.has("left") || bSides.has("left"))) {
+    return read("bottomLeft", "bottom", "left");
+  }
+  return null;
+}
+
+function cornerShapeGeometryForPlan(entry: TextureAtlasPlan): CornerShapeGeometry | null {
+  if (entry.texture || isSolidTrianglePlan(entry) || isFullRectSolid(entry)) return null;
+  const points = simplifyCornerShapePoints(borderShapePointsForPlan(entry));
+  if (points.length < 4) return null;
+
+  const sides = points.map(cornerShapePointSides);
+  if (sides.some((side) => !side)) return null;
+
+  const radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>> = {};
+  let diagonalCount = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const aSides = sides[i]!;
+    const bSides = sides[(i + 1) % points.length]!;
+    if (sharedCornerShapeSide(aSides, bSides)) continue;
+    const diagonal = cornerShapeDiagonal(points[i], aSides, points[(i + 1) % points.length], bSides);
+    if (!diagonal) return null;
+    const [corner, radius] = diagonal;
+    const previous = radii[corner];
+    if (
+      previous &&
+      (Math.abs(previous.x - radius.x) > CORNER_SHAPE_POINT_EPS ||
+        Math.abs(previous.y - radius.y) > CORNER_SHAPE_POINT_EPS)
+    ) {
+      return null;
+    }
+    radii[corner] = radius;
+    diagonalCount += 1;
+  }
+
+  return diagonalCount > 0 ? { radii } : null;
+}
+
 function formatMatrix3dValues(values: readonly number[], decimals = DEFAULT_MATRIX_DECIMALS): string {
   return values.map((value) => roundDecimal(value, decimals)).join(",");
 }
@@ -695,6 +870,31 @@ function formatSolidQuadMatrix(entry: TextureAtlasPlan): string {
   );
 }
 
+function cornerShapeRadiusStyle(geometry: CornerShapeGeometry): CSSProperties {
+  const style: CSSProperties = {};
+  for (const [corner, radius] of Object.entries(geometry.radii) as Array<[CornerShapeCorner, CornerShapeRadius]>) {
+    const property = `border${corner[0].toUpperCase()}${corner.slice(1)}Radius`;
+    (style as Record<string, string>)[property] = `${formatPercent(radius.x)} ${formatPercent(radius.y)}`;
+  }
+  return style;
+}
+
+const CORNER_SHAPE_PROPERTIES = [
+  "corner-top-left-shape",
+  "corner-top-right-shape",
+  "corner-bottom-right-shape",
+  "corner-bottom-left-shape",
+] as const;
+
+function applyCornerShapeProperties(el: HTMLElement, geometry: CornerShapeGeometry | null): void {
+  for (const property of CORNER_SHAPE_PROPERTIES) el.style.removeProperty(property);
+  if (!geometry) return;
+  for (const corner of Object.keys(geometry.radii) as CornerShapeCorner[]) {
+    const cssCorner = corner.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+    el.style.setProperty(`corner-${cssCorner}-shape`, "bevel");
+  }
+}
+
 function isConvexPolygonPoints(points: Array<[number, number]>): boolean {
   if (points.length < 3) return false;
   let sign = 0;
@@ -1218,6 +1418,7 @@ export interface StableTriangleDomUpdateOptions {
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
+  strategies?: PolyRenderStrategiesOption;
   colorFrame?: number;
   colorSteps?: number;
   colorFreezeFrames?: number;
@@ -1550,7 +1751,7 @@ export function updateStableTriangleDom(
   options: StableTriangleDomUpdateOptions = {},
 ): boolean {
   if ((options.textureLighting ?? "baked") !== "baked") return false;
-  if (!solidTriangleSupported()) return false;
+  if (!resolveSolidTrianglePrimitive(options.strategies)) return false;
   const leaves = Array.from(root.children).filter(
     (child): child is StableTriangleDomElement =>
       child instanceof HTMLElement && child.localName === "u",
@@ -2374,8 +2575,12 @@ export function useTextureAtlas(
 ): TextureAtlasResult {
   const disabled = computed(() => new Set(strategies.value?.disable ?? []));
   const useFullRectSolid = computed(() => !disabled.value.has("b"));
-  const useProjectiveQuad = computed(() => useFullRectSolid.value);
-  const useStableTriangle = computed(() => !disabled.value.has("u") && solidTriangleSupported());
+  const useProjectiveQuad = computed(() => useFullRectSolid.value && projectiveQuadSupported());
+  const solidTrianglePrimitive = computed(() => resolveSolidTrianglePrimitive(strategies.value));
+  const useStableTriangle = computed(() => solidTrianglePrimitive.value !== null);
+  const useCornerShapeSolid = computed(() =>
+    !disabled.value.has("i") && textureLighting.value !== "dynamic" && cornerShapeSupported()
+  );
   const useBorderShape = computed(() => !disabled.value.has("i") && textureLighting.value !== "dynamic" && borderShapeSupported());
 
   const atlasState = computed(() => {
@@ -2383,9 +2588,16 @@ export function useTextureAtlas(
       if (!plan) return plan;
       if (plan.texture) return plan;
       if (useStableTriangle.value && isSolidTrianglePlan(plan)) return null;
+      const fullRect = isFullRectSolid(plan);
+      const cornerShape = useCornerShapeSolid.value &&
+        !fullRect &&
+        !isSolidTrianglePlan(plan) &&
+        !(useProjectiveQuad.value && isProjectiveQuadPlan(plan)) &&
+        cornerShapeGeometryForPlan(plan);
       if (
-        (useFullRectSolid.value && isFullRectSolid(plan)) ||
+        (useFullRectSolid.value && fullRect) ||
         (useProjectiveQuad.value && isProjectiveQuadPlan(plan)) ||
+        cornerShape ||
         (textureLighting.value !== "dynamic" && useBorderShape.value)
       ) return null;
       return plan;
@@ -2456,6 +2668,7 @@ export function useTextureAtlas(
     useFullRectSolid,
     useProjectiveQuad,
     useStableTriangle,
+    solidTrianglePrimitive,
     useBorderShape,
   };
 }
@@ -2464,6 +2677,7 @@ export function renderTextureAtlasPoly({
   entry,
   page,
   textureLighting,
+  solidPaintDefaults: _solidPaintDefaults,
   className,
   style: styleProp,
   domAttrs,
@@ -2472,6 +2686,7 @@ export function renderTextureAtlasPoly({
   entry: PackedTextureAtlasEntry;
   page: TextureAtlasPage | undefined;
   textureLighting: PolyTextureLightingMode;
+  solidPaintDefaults?: SolidPaintDefaults;
   className?: string;
   style?: CSSProperties;
   domAttrs?: Record<string, unknown>;
@@ -2566,9 +2781,10 @@ export function renderTextureBorderShapePoly({
 }): VNode {
   const fullRect = isFullRectSolid(entry);
   const useIForFullRect = fullRect && forceBorderShape && borderShapeSupported();
-  const borderShape = (!fullRect || useIForFullRect) ? cssBorderShapeForPlan(entry) : null;
+  const cornerShape = !fullRect && cornerShapeSupported() ? cornerShapeGeometryForPlan(entry) : null;
+  const borderShape = !cornerShape && (!fullRect || useIForFullRect) ? cssBorderShapeForPlan(entry) : null;
   const useDefaultPaint = entry.shadedColor === solidPaintDefaults?.paintColor;
-  const transform = formatMatrix3d(borderShape ? formatBorderShapeMatrix(entry) : formatSolidQuadMatrix(entry));
+  const transform = formatMatrix3d(borderShape || cornerShape ? formatBorderShapeMatrix(entry) : formatSolidQuadMatrix(entry));
   const style: CSSProperties = fullRect
     ? {
         transform,
@@ -2576,6 +2792,19 @@ export function renderTextureBorderShapePoly({
         pointerEvents: pointerEvents === "none" ? "none" : undefined,
         ...styleProp,
       }
+    : cornerShape
+    ? {
+        transform,
+        width: `${BORDER_SHAPE_CANONICAL_SIZE}px`,
+        height: `${BORDER_SHAPE_CANONICAL_SIZE}px`,
+        border: 0,
+        boxSizing: "border-box",
+        background: "currentColor",
+        ...cornerShapeRadiusStyle(cornerShape),
+        color: useDefaultPaint ? undefined : entry.shadedColor,
+        pointerEvents: pointerEvents === "none" ? "none" : undefined,
+        ...styleProp,
+      }
     : {
         transform,
         color: useDefaultPaint ? undefined : entry.shadedColor,
@@ -2595,10 +2824,11 @@ export function renderTextureBorderShapePoly({
     if (!el) return;
     if (borderShape) el.style.setProperty("border-shape", borderShape);
     else el.style.removeProperty("border-shape");
+    applyCornerShapeProperties(el, cornerShape);
     orderBrushInlineStyle(el);
   };
 
-  return h(fullRect && !useIForFullRect ? "b" : "i", {
+  return h(fullRect && !useIForFullRect ? "b" : cornerShape ? "u" : "i", {
     class: elementClassName,
     style,
     ...dataAttrs,
@@ -2672,6 +2902,7 @@ export function renderTextureTrianglePoly({
   entry,
   textureLighting,
   solidPaintDefaults,
+  solidTrianglePrimitive,
   className,
   style: styleProp,
   domAttrs,
@@ -2680,12 +2911,18 @@ export function renderTextureTrianglePoly({
   entry: TextureAtlasPlan;
   textureLighting: PolyTextureLightingMode;
   solidPaintDefaults?: SolidPaintDefaults;
+  solidTrianglePrimitive?: SolidTrianglePrimitive | null;
   className?: string;
   style?: CSSProperties;
   domAttrs?: Record<string, unknown>;
   pointerEvents?: "auto" | "none";
 }): VNode | null {
-  const triangleStyle = solidTriangleStyle(entry, textureLighting, pointerEvents, solidPaintDefaults);
+  const triangleStyle = solidTriangleStyle(
+    entry,
+    textureLighting,
+    pointerEvents,
+    solidPaintDefaults,
+  );
   if (!triangleStyle) return null;
 
   const dataAttrs = entry.polygon.data
@@ -2693,7 +2930,10 @@ export function renderTextureTrianglePoly({
         Object.entries(entry.polygon.data).map(([k, v]) => [`data-${k}`, String(v)]),
       )
     : {};
-  const elementClassName = className?.trim() || undefined;
+  const elementClassName = [
+    className?.trim(),
+    solidTrianglePrimitive === "corner-bevel" ? "polycss-corner-triangle" : "",
+  ].filter(Boolean).join(" ") || undefined;
 
   return h("u", {
     class: elementClassName,
diff --git a/packages/vue/src/shapes/Poly.test.ts b/packages/vue/src/shapes/Poly.test.ts
index 1f23d9da..26fd94b2 100644
--- a/packages/vue/src/shapes/Poly.test.ts
+++ b/packages/vue/src/shapes/Poly.test.ts
@@ -142,6 +142,23 @@ describe("Poly (Vue) — non-horizontal geometry", () => {
     expect(poly.style.width).toBe("");
     expect(poly.style.height).toBe("");
   });
+
+  it("falls back to atlas for solid non-rect quads on Safari", () => {
+    const userAgent = vi.spyOn(window.navigator, "userAgent", "get").mockReturnValue(
+      "Mozilla/5.0 AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+    );
+    vi.stubGlobal("CSS", { supports: () => false });
+
+    try {
+      const container = renderPoly({ vertices: NON_RECT_QUAD });
+      const poly = getPoly(container);
+      expect(poly.tagName.toLowerCase()).toBe("s");
+      expect(poly.style.getPropertyValue("border-shape")).toBe("");
+    } finally {
+      userAgent.mockRestore();
+      vi.unstubAllGlobals();
+    }
+  });
 });
 
 describe("Poly (Vue) — texture without UVs", () => {
diff --git a/packages/vue/src/styles/styles.test.ts b/packages/vue/src/styles/styles.test.ts
index e2c3464f..d163db85 100644
--- a/packages/vue/src/styles/styles.test.ts
+++ b/packages/vue/src/styles/styles.test.ts
@@ -51,7 +51,7 @@ describe("injectPolyBaseStyles", () => {
     expect(el.textContent).toContain("height: 64px;");
     expect(el.textContent).toContain("width: var(--polycss-atlas-size, 64px);");
     expect(el.textContent).toContain("height: var(--polycss-atlas-size, 64px);");
-    expect(el.textContent).toContain("border-width: 0 32px 64px 32px;");
+    expect(el.textContent).toContain("border-width: 0 16px 32px 16px;");
     expect(el.textContent).toContain("width: 0;");
     expect(el.textContent).toContain("height: 0;");
   });
diff --git a/packages/vue/src/styles/styles.ts b/packages/vue/src/styles/styles.ts
index 6b64394e..65fe7e52 100644
--- a/packages/vue/src/styles/styles.ts
+++ b/packages/vue/src/styles/styles.ts
@@ -121,7 +121,18 @@ const CORE_BASE_STYLES = `
   box-sizing: content-box;
   border: 0 solid transparent;
   border-color: transparent transparent currentColor transparent;
-  border-width: 0 32px 64px 32px;
+  border-width: 0 16px 32px 16px;
+}
+
+.polycss-scene u.polycss-corner-triangle {
+  width: 32px;
+  height: 32px;
+  background: currentColor;
+  border: 0;
+  border-top-left-radius: 50% 100%;
+  border-top-right-radius: 50% 100%;
+  corner-top-left-shape: bevel;
+  corner-top-right-shape: bevel;
 }
 
 /* ── Dynamic lighting cascade vars (scene root → polygons) ─────────────── */
diff --git a/website/public/gallery/vox-manifest.json b/website/public/gallery/vox-manifest.json
index 69a7e63f..0aed0681 100644
--- a/website/public/gallery/vox-manifest.json
+++ b/website/public/gallery/vox-manifest.json
@@ -4,8 +4,14 @@
   "vox/alien_engi1a.vox",
   "vox/alien_eye1a.vox",
   "vox/alien_lift.vox",
+  "vox/AncientCrashSite.vox",
+  "vox/apple.vox",
+  "vox/arachnoid.vox",
   "vox/armchair.vox",
+  "vox/army.vox",
   "vox/bowl_bone.vox",
+  "vox/Building03.vox",
+  "vox/bus.vox",
   "vox/cart_full.vox",
   "vox/cat_02.vox",
   "vox/cat_03.vox",
@@ -50,17 +56,28 @@
   "vox/chr_zombie4.vox",
   "vox/christmas_tree.vox",
   "vox/couch.vox",
+  "vox/desert.vox",
+  "vox/desert2.vox",
   "vox/dog.vox",
   "vox/door.vox",
   "vox/dual.vox",
   "vox/ff1.vox",
   "vox/ff2.vox",
   "vox/ff3.vox",
+  "vox/floooh/cassette.vox",
+  "vox/floooh/kc85-computer.vox",
+  "vox/floooh/kc85-keyboard.vox",
+  "vox/floooh/lcr-c.vox",
+  "vox/Garden.vox",
   "vox/gifts.vox",
   "vox/horse.vox",
+  "vox/house.vox",
+  "vox/HUT.vox",
   "vox/lantern.vox",
   "vox/mailbox.vox",
   "vox/man.vox",
+  "vox/mecha.vox",
+  "vox/MechaGolem.vox",
   "vox/mob_bear.vox",
   "vox/mob_cat1.vox",
   "vox/mob_cat2.vox",
@@ -90,8 +107,19 @@
   "vox/obj_trashcan4.vox",
   "vox/obj_tree1.vox",
   "vox/obj_tree2.vox",
+  "vox/opengameart-buildings/building-01.vox",
+  "vox/opengameart-buildings/building-02.vox",
+  "vox/opengameart-buildings/mini-building-01.vox",
+  "vox/opengameart-buildings/mini-building-02.vox",
+  "vox/opengameart-buildings/tower-01.vox",
+  "vox/openhv/battleship.vox",
+  "vox/openhv/dropship.vox",
+  "vox/openhv/firetruck.vox",
+  "vox/openhv/saucer.vox",
+  "vox/openhv/turtle.vox",
   "vox/paperboy.vox",
   "vox/piano.vox",
+  "vox/Plane_03.vox",
   "vox/pyramid.vox",
   "vox/santa.vox",
   "vox/scene_army.vox",
@@ -120,8 +148,13 @@
   "vox/scene_vehicles1.vox",
   "vox/scene_vehicles2.vox",
   "vox/scene_zombies.vox",
+  "vox/skyscraper.vox",
   "vox/snowman.vox",
   "vox/spacesuit.vox",
+  "vox/StarMarineTrooper.vox",
+  "vox/tank.vox",
+  "vox/Treasure.vox",
+  "vox/tree.vox",
   "vox/veh_ambulance.vox",
   "vox/veh_bus.vox",
   "vox/veh_cab1.vox",
diff --git a/website/public/gallery/vox/floooh/cassette.vox b/website/public/gallery/vox/floooh/cassette.vox
new file mode 100644
index 0000000000000000000000000000000000000000..5817480f6ebdde7c47b1569d75415dcf81a60001
GIT binary patch
literal 1312
zcmXBS&5aW=9ES0KGWkN<OKv%$v|x$*q9C*fKmrB97T^}rLMlLV3n^jKf=eLc#5H#=
zn4ir|9((4EKc2Du_0zZ4KO*A8<I_h~JS-!=JUzdA=r68USYd{5-=Cj;s{8c@>xiA|
zB__-<!y;a^-L0os&DE<Z{_4Nm$k&Tlt+2!b6XuxpTDxhAKQm*@XR({Gz!EF0<r_@K
zTK0BxeK28xB}}+lW5Z?9+hN9I!*9cLq2Ff711l`Cz=XgYGkkvk_R)8YtBtEF3o=q`
zzoWGtRYjFod6idrZ&u{RLy;GGk@v1yp5@s~mS?%DC3%u3c@iYKUkiE2Lmu*o|I;d~
ziK;=X0jkDBMN#=wK9x`9GxYdWK9x`9Q~3;KK9x`9Q~6Xr<1_eFK9x`9Q~C5yt9&Y-
z%BS+FeAo?>qAYw0pTcJ>0iQykn5-DM7-TGqKZ}RLr|>C!#!~Sqd<vh!r|=oe$EWZq
zd<vh!r!Q&YQ}`4<g-_u#mU*m9x9N9+ye~bU%qR27d@`T09egsMOd^{w8+>e$PFaKO
zCG*LA#<uavd@`TRC-doBnfYWsnNQ}E`HbxyyVO^v+w@!Bx13MnllUY)iO)C&d=j6;
zC-F&q#?j!D_#{4wNHXa-E(S|FCXJFH@$rM4PvVpKBtByF6VrF8uS~ab_oK!q_ynKe
z6TjsB`0)uo!6*0xA45XUC-?-P;A0xd`2?Tf6J$&cxdB7x(C{w2;ff2+IN^u`_Shos
zxZ#Qm&N$(S1NPV=?zrKK3(h#<hy(W6w)_3wZns;zUa#$PxwP~7+)k%cJ06eia5%L6
Me&4p+t+vtr0UpzSga7~l

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/floooh/kc85-computer.vox b/website/public/gallery/vox/floooh/kc85-computer.vox
new file mode 100644
index 0000000000000000000000000000000000000000..a75bb934acf74744a3a6c1e57cf61cd21247221a
GIT binary patch
literal 35452
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
C`eD)l

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/floooh/kc85-keyboard.vox b/website/public/gallery/vox/floooh/kc85-keyboard.vox
new file mode 100644
index 0000000000000000000000000000000000000000..5738d4d873daf043c25307677cb6fc79c5fb6e45
GIT binary patch
literal 3144
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
K_U)V4(EJY%){vI~

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/floooh/lcr-c.vox b/website/public/gallery/vox/floooh/lcr-c.vox
new file mode 100644
index 0000000000000000000000000000000000000000..57e679062aede1ea200c320cc2cb5d1a8a4a6dba
GIT binary patch
literal 13848
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

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/opengameart-buildings/building-01.vox b/website/public/gallery/vox/opengameart-buildings/building-01.vox
new file mode 100644
index 0000000000000000000000000000000000000000..23485b560cfdbee0e862941d59ace11b28b19268
GIT binary patch
literal 89583
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
O{dYa@^!IvE;r|cxa-X*V

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/opengameart-buildings/building-02.vox b/website/public/gallery/vox/opengameart-buildings/building-02.vox
new file mode 100644
index 0000000000000000000000000000000000000000..28b231c52b3cbb1bcbf3c81c14ad49199f6b31ad
GIT binary patch
literal 110691
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

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/opengameart-buildings/mini-building-01.vox b/website/public/gallery/vox/opengameart-buildings/mini-building-01.vox
new file mode 100644
index 0000000000000000000000000000000000000000..d59ebedb9ae7c0370fe6ae2fe67a98b39fb7198b
GIT binary patch
literal 36911
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
CVQ~fk

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/opengameart-buildings/mini-building-02.vox b/website/public/gallery/vox/opengameart-buildings/mini-building-02.vox
new file mode 100644
index 0000000000000000000000000000000000000000..736d001cf02c6760a715879235588088700b4020
GIT binary patch
literal 37643
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
VTht9%x?=s>l}k?V`n9?6{{o}Ull1@q

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/opengameart-buildings/tower-01.vox b/website/public/gallery/vox/opengameart-buildings/tower-01.vox
new file mode 100644
index 0000000000000000000000000000000000000000..4aacafc7628defab436f3327a99f23d4e5bbb844
GIT binary patch
literal 164735
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
E0#-i%(*OVf

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/openhv/battleship.vox b/website/public/gallery/vox/openhv/battleship.vox
new file mode 100644
index 0000000000000000000000000000000000000000..116e6193b8426dd30b8a3fbd1a7874efe09d762c
GIT binary patch
literal 109810
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
Q;%|iFPAJ+GKeN9-3Pi%M=l}o!

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/openhv/dropship.vox b/website/public/gallery/vox/openhv/dropship.vox
new file mode 100644
index 0000000000000000000000000000000000000000..8d74bbd5908aab86c8c938123038f1e06018cde2
GIT binary patch
literal 40567
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

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/openhv/firetruck.vox b/website/public/gallery/vox/openhv/firetruck.vox
new file mode 100644
index 0000000000000000000000000000000000000000..c5f3b123cbf32ffb40cdd4eb552c237cde1dbce0
GIT binary patch
literal 31663
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
L$oH|hZI}N9k$2z|

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/openhv/saucer.vox b/website/public/gallery/vox/openhv/saucer.vox
new file mode 100644
index 0000000000000000000000000000000000000000..a4117c8ecdcd0ca94758728c450a8530de9cdb61
GIT binary patch
literal 31597
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
HrY-*scc%Rj

literal 0
HcmV?d00001

diff --git a/website/public/gallery/vox/openhv/turtle.vox b/website/public/gallery/vox/openhv/turtle.vox
new file mode 100644
index 0000000000000000000000000000000000000000..abe924284edfe7b1e64a13df00a9f0d9761851f5
GIT binary patch
literal 43906
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
I2X^^C0S7|p+5i9m

literal 0
HcmV?d00001

diff --git a/website/src/components/BuilderWorkbench/hooks/useSidebarItems.ts b/website/src/components/BuilderWorkbench/hooks/useSidebarItems.ts
index 5a3ed30e..3c5acaf5 100644
--- a/website/src/components/BuilderWorkbench/hooks/useSidebarItems.ts
+++ b/website/src/components/BuilderWorkbench/hooks/useSidebarItems.ts
@@ -18,13 +18,24 @@ export function useSidebarItems(): UseSidebarItemsResult {
   const presetItems = useMemo(
     () => PRESETS
       .filter((p) => BUILDER_KIT_CATEGORIES.includes(p.category))
-      .map((p) => ({ id: p.id, label: stripParenthesizedText(p.label), category: p.category })),
+      .map((p) => {
+        const label = stripParenthesizedText(p.label);
+        return {
+          id: p.id,
+          label,
+          category: p.category,
+          searchText: [label, p.label, p.category, p.kind, p.attribution?.creator, p.attribution?.license]
+            .filter(Boolean)
+            .join(" ")
+            .toLowerCase(),
+        };
+      }),
     [],
   );
   const trimmedSearch = modelSearch.trim().toLowerCase();
   const modelCategories = useMemo(() => {
     const filtered = trimmedSearch
-      ? presetItems.filter((p) => p.label.toLowerCase().includes(trimmedSearch))
+      ? presetItems.filter((p) => p.searchText.includes(trimmedSearch))
       : presetItems;
     const byCat = new Map<string, typeof filtered>();
     for (const p of filtered) {
diff --git a/website/src/components/Dock/folders/useRenderingFolder.ts b/website/src/components/Dock/folders/useRenderingFolder.ts
index 41596853..96f74aa7 100644
--- a/website/src/components/Dock/folders/useRenderingFolder.ts
+++ b/website/src/components/Dock/folders/useRenderingFolder.ts
@@ -17,7 +17,10 @@
  */
 import { useEffect, useRef } from "react";
 import type { GUI } from "lil-gui";
-import type { MeshResolution, PolyTextureLightingMode } from "@layoutit/polycss-react";
+import type {
+  MeshResolution,
+  PolyTextureLightingMode,
+} from "@layoutit/polycss-react";
 
 import { useFolder, useOption, useSlider, useToggle } from "../primitives";
 
diff --git a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
index 6089d8d5..9750695b 100644
--- a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
+++ b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
@@ -71,10 +71,21 @@ import type { ObjParseOptions, GltfParseOptions, VoxParseOptions } from "@layout
 type AnimationClip = NonNullable<LoadedModel["animation"]>["clips"][number];
 
 function presetPickerItem(preset: PresetModel, local = false) {
+  const label = local ? `Dropped: ${stripParenthesizedText(preset.label)}` : stripParenthesizedText(preset.label);
+  const category = galleryBucketForPreset(preset);
   return {
     id: preset.id,
-    label: local ? `Dropped: ${stripParenthesizedText(preset.label)}` : stripParenthesizedText(preset.label),
-    category: galleryBucketForPreset(preset),
+    label,
+    category,
+    searchText: [
+      label,
+      preset.label,
+      category,
+      preset.category,
+      preset.kind,
+      preset.attribution?.creator,
+      preset.attribution?.license,
+    ].filter(Boolean).join(" ").toLowerCase(),
   };
 }
 
@@ -310,8 +321,7 @@ export default function GalleryWorkbench() {
   const filteredPresetItems = useMemo(() => {
     if (!trimmedModelSearch) return pickerItems;
     return pickerItems.filter((preset) =>
-      preset.label.toLowerCase().includes(trimmedModelSearch) ||
-      preset.category.toLowerCase().includes(trimmedModelSearch),
+      preset.searchText.includes(trimmedModelSearch),
     );
   }, [pickerItems, trimmedModelSearch]);
   const modelCategories = useMemo(() => {
diff --git a/website/src/components/GalleryWorkbench/presets/attributions.ts b/website/src/components/GalleryWorkbench/presets/attributions.ts
index 52eb2050..8db9d3fc 100644
--- a/website/src/components/GalleryWorkbench/presets/attributions.ts
+++ b/website/src/components/GalleryWorkbench/presets/attributions.ts
@@ -49,6 +49,12 @@ export const KENNEY_MINIGOLF_ATTRIBUTION: ModelAttribution = {
   sourceUrl: "https://kenney.nl/assets/minigolf-kit",
 };
 
+export const KENNEY_CITY_KIT_ATTRIBUTION: ModelAttribution = {
+  creator: "Kenney",
+  license: "CC0 1.0",
+  sourceUrl: "https://poly.pizza/bundle/City-Kit-0CkvGrBJ0u",
+};
+
 export const KANGAROOZ_STING_ATTRIBUTION: ModelAttribution = {
   creator: "KangaroOz 3D",
   license: "CC-BY 4.0",
@@ -86,14 +92,50 @@ export const POLY_PIZZA_SAXOPHONE_ATTRIBUTION: ModelAttribution = {
   tris: 812,
 };
 
-export function polyPizzaJeremyAttribution(publicId: string): ModelAttribution {
+export const POLYCSS_GENERATED_PRIMITIVE_ATTRIBUTION: ModelAttribution = {
+  creator: "Generated by polycss",
+};
+
+export const POLYCSS_LOCAL_FIXTURE_ATTRIBUTION: ModelAttribution = {
+  creator: "Local polycss fixture",
+};
+
+export const QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION: ModelAttribution = {
+  creator: "Quaternius",
+  license: "CC0 1.0",
+  sourceUrl: "https://poly.pizza/bundle/Medieval-Village-Pack-NsHhjhlrfY",
+};
+
+const POLY_PIZZA_CITY_PACK_URL = "https://poly.pizza/bundle/City-Pack-kJqRAIGsw0";
+
+function polyPizzaCityPackAttribution(creator: string, license: string): ModelAttribution {
+  return {
+    creator,
+    license,
+    sourceUrl: POLY_PIZZA_CITY_PACK_URL,
+  };
+}
+
+export function polyPizzaAttribution(
+  creator: string,
+  publicId: string,
+  license = "Creative Commons Attribution",
+  tris?: number,
+): ModelAttribution {
   return {
-    creator: "jeremy",
-    license: "CC-BY 3.0",
+    creator,
+    license,
     sourceUrl: `https://poly.pizza/m/${publicId}`,
+    ...(typeof tris === "number" ? { tris } : {}),
   };
 }
 
+export const PARFAITUWU_TREE_ATTRIBUTION = polyPizzaAttribution("ParfaitUwU", "MSuchZNT2G");
+
+export function polyPizzaJeremyAttribution(publicId: string): ModelAttribution {
+  return polyPizzaAttribution("jeremy", publicId, "CC-BY 3.0");
+}
+
 export const MINI_MIKES_METRO_MINIS_ATTRIBUTION: ModelAttribution = {
   creator: "Mike Judge",
   license: "CC-BY 4.0",
@@ -160,6 +202,29 @@ export const SONA_SAR_VOXEL_ANIMALS_ITEMS_ATTRIBUTION: ModelAttribution = {
   sourceUrl: "https://sona-sar.itch.io/voxel-animals-items-pack-free-assets",
 };
 
+export const MAGICAVOXEL_TEST_MODELS_ATTRIBUTION: ModelAttribution = {
+  creator: "ephtracy / MagicaVoxel",
+  sourceUrl: "https://github.com/ephtracy/voxel-model",
+};
+
+export const OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION: ModelAttribution = {
+  creator: "mehrasaur",
+  license: "CC0 1.0",
+  sourceUrl: "https://opengameart.org/content/voxel-buildings",
+};
+
+export const OPENHV_VOXELS_ATTRIBUTION: ModelAttribution = {
+  creator: "OpenHV contributors",
+  license: "CC-BY-SA 4.0",
+  sourceUrl: "https://github.com/Dzierzan/OpenHV/tree/master-placeholder/sources/voxels",
+};
+
+export const FLOOOH_VOXEL_DATA_ATTRIBUTION: ModelAttribution = {
+  creator: "Andre Weissflog",
+  license: "MIT",
+  sourceUrl: "https://github.com/floooh/voxel-data",
+};
+
 export const UTAH_TEAPOT_ATTRIBUTION: ModelAttribution = {
   creator: "Martin Newell / University of Utah",
   sourceUrl: "https://graphics.cs.utah.edu/teapot/",
@@ -195,8 +260,11 @@ export const GLB_PRESET_ATTRIBUTIONS: Record<string, ModelAttribution> = {
   "AnimatedWizard.glb": QUATERNIUS_ANIMATED_MONSTERS_ATTRIBUTION,
   "Bat.glb": WEBXR_CAVE_BAT_ATTRIBUTION,
   "Bear.glb": polyPizzaJeremyAttribution("evjB26aGfTh"),
+  "Cat.glb": polyPizzaJeremyAttribution("4Pp1CY3bC43"),
   "Cheetah.glb": polyPizzaJeremyAttribution("ew0sr-amXFo"),
+  "Deer.glb": polyPizzaJeremyAttribution("fAVxGd9dP21"),
   "Dinosaur.glb": polyPizzaJeremyAttribution("5iV5SPhBu26"),
+  "Dog.glb": polyPizzaJeremyAttribution("a0GNnW8q2IH"),
   "Dolphin.glb": GOOGLE_POLY_AMBER_ATTRIBUTION,
   "Dragon.glb": polyPizzaJeremyAttribution("3ZuMS3IRb0C"),
   "Duck.glb": POLY_PIZZA_DUCK_ATTRIBUTION,
@@ -205,6 +273,7 @@ export const GLB_PRESET_ATTRIBUTIONS: Record<string, ModelAttribution> = {
   "Frog.glb": polyPizzaJeremyAttribution("07-wJ9bkzul"),
   "Gorilla.glb": polyPizzaJeremyAttribution("1aReOCuu0TY"),
   "Hippo.glb": polyPizzaJeremyAttribution("6fQJsxfOGUP"),
+  "Horse.glb": polyPizzaJeremyAttribution("2lIMvzwQBV3"),
   "Koala.glb": GOOGLE_POLY_VIDEOLAB_ATTRIBUTION,
   "Lobster.glb": GOOGLE_POLY_AMBER_ATTRIBUTION,
   "Octopus.glb": polyPizzaJeremyAttribution("6KQsV8qo5E0"),
@@ -215,9 +284,12 @@ export const GLB_PRESET_ATTRIBUTIONS: Record<string, ModelAttribution> = {
   "Robin.glb": polyPizzaJeremyAttribution("53HOg-b1F4r"),
   "Scorpion.glb": polyPizzaJeremyAttribution("cJfrRPiSgA4"),
   "Saxophone.glb": POLY_PIZZA_SAXOPHONE_ATTRIBUTION,
+  "Shark.glb": polyPizzaJeremyAttribution("1SaSTXCFsgo"),
   "Snail.glb": polyPizzaJeremyAttribution("abd7jfOGZ94"),
+  "Wolf.glb": polyPizzaJeremyAttribution("2PDe5PSncTC"),
   "Zebra.glb": polyPizzaJeremyAttribution("cKi5RxMBUxO"),
   "Dump truck.glb": polyPizzaJeremyAttribution("1BpGYg14QGD"),
+  "Policecar.glb": polyPizzaJeremyAttribution("3oBDp9Z3OFH"),
   "Taxi.glb": polyPizzaJeremyAttribution("coQbjlCqWY9"),
   "Truck.glb": polyPizzaJeremyAttribution("cPVFA5uTr9l"),
   "Acousticguitar.glb": polyPizzaJeremyAttribution("afr6GCpce_I"),
@@ -225,10 +297,61 @@ export const GLB_PRESET_ATTRIBUTIONS: Record<string, ModelAttribution> = {
   "Trumpet.glb": polyPizzaJeremyAttribution("0Mj5XgeGtKJ"),
   "Violin.glb": polyPizzaJeremyAttribution("fhj0GK-0kJu"),
   "apple.glb": polyPizzaJeremyAttribution("4tOmpD9-xsV"),
+  "BottleChampagne.glb": polyPizzaJeremyAttribution("fCWg2Z6OSku"),
+  "Eggplant.glb": polyPizzaJeremyAttribution("e_6auCzeiCC"),
   "Grapes.glb": polyPizzaJeremyAttribution("csU4Smr2_aV"),
   "Hot dog.glb": polyPizzaJeremyAttribution("eiPR4iwcYpa"),
   "Watermelon.glb": polyPizzaJeremyAttribution("5NXaNnNIzfC"),
+  "Cactus.glb": polyPizzaJeremyAttribution("fr1vXosiRgr"),
   "Campfire.glb": polyPizzaJeremyAttribution("dxxHpVXHLZg"),
   "Drill.glb": polyPizzaJeremyAttribution("93nEcwogYE0"),
   "Globe.glb": polyPizzaJeremyAttribution("2445qv4neDQ"),
+  "tree.glb": PARFAITUWU_TREE_ATTRIBUTION,
+
+  "medieval/Bags.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Barrel.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Bell.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Bonfire.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Cart.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Cauldron.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Crate.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Package.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Package-kYvD6QCQRd.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Path Straight.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Rocks.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Sawmill Saw.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Smoke.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Well.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Window.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+  "medieval/Window-EY1zrFcme9.glb": QUATERNIUS_MEDIEVAL_VILLAGE_ATTRIBUTION,
+
+  "city/Skyscraper.glb": KENNEY_CITY_KIT_ATTRIBUTION,
+  "city/Large Building.glb": KENNEY_CITY_KIT_ATTRIBUTION,
+  "city/Small Building.glb": KENNEY_CITY_KIT_ATTRIBUTION,
+
+  "urban/Road Bits.glb": polyPizzaCityPackAttribution("Kay Lousberg", "CC0 1.0"),
+  "urban/Manhole Cover.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Car.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/SUV.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Van.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Pickup Truck.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Bus.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Sports Car.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Police Car.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Motorcycle.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Stop sign.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Billboard.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Rock band poster.glb": polyPizzaCityPackAttribution("jeremy", "Creative Commons Attribution"),
+  "urban/Dumpster.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Mailbox.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Fire hydrant.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/Cone.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Box.glb": polyPizzaCityPackAttribution("Kay Lousberg", "CC0 1.0"),
+  "urban/Power Box.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Air conditioner.glb": polyPizzaCityPackAttribution("Poly by Google", "Creative Commons Attribution"),
+  "urban/ATM.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Planter & Bushes.glb": polyPizzaCityPackAttribution("J-Toastie", "Creative Commons Attribution"),
+  "urban/Man.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Adventurer.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
+  "urban/Animated Woman.glb": polyPizzaCityPackAttribution("Quaternius", "CC0 1.0"),
 };
diff --git a/website/src/components/GalleryWorkbench/presets/presetBuilders.ts b/website/src/components/GalleryWorkbench/presets/presetBuilders.ts
index e8128ab9..2fc496cc 100644
--- a/website/src/components/GalleryWorkbench/presets/presetBuilders.ts
+++ b/website/src/components/GalleryWorkbench/presets/presetBuilders.ts
@@ -21,6 +21,23 @@ export function labelFromFile(file: string): string {
     .replace(/\.[^.]+$/, "")
     .replace(/([a-z])([A-Z])/g, "$1 $2")
     .replace(/[_-]+/g, " ");
+  return labelFromBase(base);
+}
+
+function voxLabelFromFile(file: string): string {
+  const base = file
+    .split("/")
+    .pop()!
+    .replace(/\.[^.]+$/, "")
+    .replace(/^(?:chr|mob|obj|veh|scene)_/i, "")
+    .replace(/([a-z])([0-9])/gi, "$1 $2")
+    .replace(/([0-9])([a-z])/gi, "$1 $2")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ");
+  return labelFromBase(base);
+}
+
+function labelFromBase(base: string): string {
   return base
     .split(" ")
     .filter(Boolean)
@@ -71,7 +88,7 @@ export function objPreset(input: ObjGalleryPresetFile): PresetModel {
 export function voxPreset(input: GalleryPresetFile): PresetModel {
   return {
     id: presetIdFromFile("vox", input.file),
-    label: input.label ?? labelFromFile(input.file),
+    label: input.label ?? voxLabelFromFile(input.file),
     category: input.category,
     kind: "vox",
     url: galleryFileUrl("vox", input.file),
diff --git a/website/src/components/GalleryWorkbench/presets/presetFiles.ts b/website/src/components/GalleryWorkbench/presets/presetFiles.ts
index 84692451..a7e278ec 100644
--- a/website/src/components/GalleryWorkbench/presets/presetFiles.ts
+++ b/website/src/components/GalleryWorkbench/presets/presetFiles.ts
@@ -10,13 +10,17 @@ import {
   MONOGON_VOXEL_MECHAS_ATTRIBUTION,
   MONOGON_VOXEL_SPACESHIPS_ATTRIBUTION,
   SONA_SAR_VOXEL_ANIMALS_ITEMS_ATTRIBUTION,
+  MAGICAVOXEL_TEST_MODELS_ATTRIBUTION,
+  OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  OPENHV_VOXELS_ATTRIBUTION,
+  FLOOOH_VOXEL_DATA_ATTRIBUTION,
   QUATERNIUS_ULTIMATE_SPACESHIPS_ATTRIBUTION,
   openGameArtAttribution,
   quaterniusAttribution,
 } from "./attributions";
 
 export const GLB_PRESET_FILES: GalleryPresetFile[] = [
-  { file: "FishAnimated.glb", label: "Fish", category: "Animated" },
+  { file: "FishAnimated.glb", label: "Animated Fish", category: "Animated" },
   {
     file: "opengameart/animated-pliers.glb",
     label: "Pliers",
@@ -89,7 +93,7 @@ export const GLB_PRESET_FILES: GalleryPresetFile[] = [
   { file: "medieval/Bonfire.glb", category: "Medieval Village" },
   { file: "medieval/Cart.glb", category: "Medieval Village" },
   { file: "medieval/Cauldron.glb", category: "Medieval Village" },
-  { file: "medieval/Crate.glb", category: "Medieval Village" },
+  { file: "medieval/Crate.glb", label: "Medieval Crate", category: "Medieval Village" },
   { file: "medieval/Package.glb", category: "Medieval Village" },
   { file: "medieval/Package-kYvD6QCQRd.glb", label: "Package (Small)", category: "Medieval Village" },
   { file: "medieval/Path Straight.glb", label: "Path Straight", category: "Medieval Village" },
@@ -116,9 +120,9 @@ export const GLB_PRESET_FILES: GalleryPresetFile[] = [
   { file: "urban/SUV.glb", category: "Urban Pack" },
   { file: "urban/Van.glb", category: "Urban Pack" },
   { file: "urban/Pickup Truck.glb", label: "Pickup Truck", category: "Urban Pack" },
-  { file: "urban/Bus.glb", category: "Urban Pack" },
+  { file: "urban/Bus.glb", label: "City Bus", category: "Urban Pack" },
   { file: "urban/Sports Car.glb", label: "Sports Car", category: "Urban Pack" },
-  { file: "urban/Police Car.glb", label: "Police Car", category: "Urban Pack" },
+  { file: "urban/Police Car.glb", label: "Police Cruiser", category: "Urban Pack" },
   { file: "urban/Motorcycle.glb", category: "Urban Pack" },
   { file: "urban/Stop sign.glb", label: "Stop Sign", category: "Urban Pack" },
   { file: "urban/Billboard.glb", category: "Urban Pack" },
@@ -128,12 +132,12 @@ export const GLB_PRESET_FILES: GalleryPresetFile[] = [
   { file: "urban/Mailbox.glb", category: "Urban Pack" },
   { file: "urban/Fire hydrant.glb", label: "Fire Hydrant", category: "Urban Pack" },
   { file: "urban/Cone.glb", label: "Traffic Cone", category: "Urban Pack" },
-  { file: "urban/Box.glb", category: "Urban Pack" },
+  { file: "urban/Box.glb", label: "Urban Box", category: "Urban Pack" },
   { file: "urban/Power Box.glb", label: "Power Box", category: "Urban Pack" },
   { file: "urban/Air conditioner.glb", label: "Air Conditioner", category: "Urban Pack" },
   { file: "urban/ATM.glb", category: "Urban Pack" },
   { file: "urban/Planter & Bushes.glb", label: "Planter & Bushes", category: "Urban Pack" },
-  { file: "urban/Man.glb", category: "Urban Pack" },
+  { file: "urban/Man.glb", label: "Urban Man", category: "Urban Pack" },
   { file: "urban/Adventurer.glb", category: "Urban Pack" },
   { file: "urban/Animated Woman.glb", label: "Woman", category: "Urban Pack" },
 ];
@@ -174,7 +178,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/animated-robot.glb",
-    label: "Robot",
+    label: "Animated Robot",
     category: "Animated",
     attribution: {
       creator: "Quaternius",
@@ -209,7 +213,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/animated-shark.glb",
-    label: "Shark",
+    label: "Animated Shark",
     category: "Animated",
     attribution: quaterniusAttribution("https://poly.pizza/m/sZR8AMLMz5", 1310),
   },
@@ -249,7 +253,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/fish.glb",
-    label: "Fish",
+    label: "Low Poly Fish",
     category: "Animals",
     attribution: {
       creator: "Kenney",
@@ -337,7 +341,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/rock.glb",
-    label: "Rock",
+    label: "Low Poly Rock",
     category: "Environment",
     attribution: {
       creator: "Kenney",
@@ -360,7 +364,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/box.glb",
-    label: "Box",
+    label: "Cardboard Box",
     category: "Objects",
     galleryBucket: "Textured",
     attribution: {
@@ -416,7 +420,7 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
   {
     file: "poly-pizza/man.glb",
-    label: "Man",
+    label: "Animated Man",
     category: "Characters",
     attribution: {
       creator: "Quaternius",
@@ -460,6 +464,111 @@ export const POLY_PIZZA_PRESET_FILES: GalleryPresetFile[] = [
   },
 ];
 
+function voxFiles(
+  files: string[],
+  attribution: GalleryPresetFile["attribution"],
+): GalleryPresetFile[] {
+  return files.map((file) => ({ file, category: "VOX", attribution }));
+}
+
+const MINI_MIKES_METRO_MINIS_VOX_FILES: string[] = [
+  "alien_bot1.vox",
+  "alien_engi1a.vox",
+  "alien_eye1a.vox",
+  "chr_chef.vox",
+  "chr_cop1.vox",
+  "chr_hazmat1.vox",
+  "chr_janitor.vox",
+  "chr_paramedic2.vox",
+  "chr_punk.vox",
+  "chr_riotcop.vox",
+  "chr_scientist.vox",
+  "chr_super1.vox",
+  "chr_thief.vox",
+  "chr_zombie4.vox",
+  "mob_cat1.vox",
+  "mob_penguin.vox",
+  "obj_arcade1.vox",
+  "obj_boxingring.vox",
+  "obj_busstop.vox",
+  "obj_candle.vox",
+  "obj_cart1a.vox",
+  "obj_container4.vox",
+  "obj_pumpkin.vox",
+  "piano.vox",
+  "scene_checkpoint.vox",
+  "scene_coffee.vox",
+  "scene_hazmat.vox",
+  "scene_protest.vox",
+  "scene_zombies.vox",
+  "veh_ambulance.vox",
+  "veh_cab1.vox",
+  "veh_car1.vox",
+  "veh_fire.vox",
+  "veh_lunch1.vox",
+  "veh_mini1.vox",
+  "veh_police1.vox",
+  "veh_suv1.vox",
+  "veh_train.vox",
+  "veh_truck1.vox",
+];
+
+const MAGICAVOXEL_TEST_MODEL_FILES: string[] = [
+  "chr_knight.vox",
+];
+
+const OPENGAMEART_BUILDING_VOX_FILES: GalleryPresetFile[] = [
+  {
+    file: "opengameart-buildings/building-01.vox",
+    label: "Building 01",
+    category: "VOX",
+    attribution: OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  },
+  {
+    file: "opengameart-buildings/building-02.vox",
+    label: "Building 02",
+    category: "VOX",
+    attribution: OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  },
+  {
+    file: "opengameart-buildings/tower-01.vox",
+    label: "Tower",
+    category: "VOX",
+    attribution: OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  },
+  {
+    file: "opengameart-buildings/mini-building-01.vox",
+    label: "Small Building 01",
+    category: "VOX",
+    targetSize: 45,
+    zoom: 0.55,
+    attribution: OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  },
+  {
+    file: "opengameart-buildings/mini-building-02.vox",
+    label: "Small Building 02",
+    category: "VOX",
+    targetSize: 45,
+    zoom: 0.55,
+    attribution: OPENGAMEART_VOXEL_BUILDINGS_ATTRIBUTION,
+  },
+];
+
+const OPENHV_VOX_FILES: GalleryPresetFile[] = [
+  { file: "openhv/battleship.vox", label: "Battleship", category: "VOX", attribution: OPENHV_VOXELS_ATTRIBUTION },
+  { file: "openhv/dropship.vox", label: "Dropship", category: "VOX", attribution: OPENHV_VOXELS_ATTRIBUTION },
+  { file: "openhv/firetruck.vox", label: "Fire Truck", category: "VOX", attribution: OPENHV_VOXELS_ATTRIBUTION },
+  { file: "openhv/saucer.vox", label: "Saucer", category: "VOX", attribution: OPENHV_VOXELS_ATTRIBUTION },
+  { file: "openhv/turtle.vox", label: "Turtle", category: "VOX", attribution: OPENHV_VOXELS_ATTRIBUTION },
+];
+
+const FLOOOH_VOX_FILES: GalleryPresetFile[] = [
+  { file: "floooh/cassette.vox", label: "Cassette", category: "VOX", targetSize: 35, zoom: 0.7, attribution: FLOOOH_VOXEL_DATA_ATTRIBUTION },
+  { file: "floooh/kc85-computer.vox", label: "KC85 Computer", category: "VOX", attribution: FLOOOH_VOXEL_DATA_ATTRIBUTION },
+  { file: "floooh/kc85-keyboard.vox", label: "KC85 Keyboard", category: "VOX", targetSize: 35, zoom: 0.6, attribution: FLOOOH_VOXEL_DATA_ATTRIBUTION },
+  { file: "floooh/lcr-c.vox", label: "LCR-C", category: "VOX", targetSize: 45, zoom: 0.5, attribution: FLOOOH_VOXEL_DATA_ATTRIBUTION },
+];
+
 export const VOX_PRESET_FILES: GalleryPresetFile[] = [
   {
     file: "AncientCrashSite.vox",
@@ -473,22 +582,32 @@ export const VOX_PRESET_FILES: GalleryPresetFile[] = [
   { file: "desert.vox", label: "Desert", category: "VOX", attribution: MONOGON_DESERT_TOWN_ATTRIBUTION },
   { file: "desert2.vox", label: "Desert 2", category: "VOX", attribution: MONOGON_DESERT_TOWN_ATTRIBUTION },
   { file: "Garden.vox", category: "VOX", attribution: MONOGON_TINY_VOXEL_DUNGEON_ATTRIBUTION },
-  { file: "Building03.vox", label: "Building 03", category: "VOX", attribution: MONOGON_DESERT_TOWN_ATTRIBUTION },
+  { file: "Building03.vox", label: "Desert Building", category: "VOX", attribution: MONOGON_DESERT_TOWN_ATTRIBUTION },
   { file: "HUT.vox", label: "Hut", category: "VOX", attribution: MONOGON_COUNTRY_SIDE_ATTRIBUTION },
   { file: "house.vox", label: "House", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
   { file: "pyramid.vox", label: "Pyramid", category: "VOX", attribution: MONOGON_ANCIENT_ENVIRONMENT_ATTRIBUTION },
-  { file: "skyscraper.vox", label: "Skyscraper", category: "VOX", attribution: MONOGON_CYBERPUNK_CITY_ATTRIBUTION },
-  { file: "Plane_03.vox", label: "Plane 03", category: "VOX", attribution: MONOGON_VOXEL_PLANE_ATTRIBUTION },
-  { file: "bus.vox", label: "Bus", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  { file: "skyscraper.vox", label: "Voxel Skyscraper", category: "VOX", attribution: MONOGON_CYBERPUNK_CITY_ATTRIBUTION },
+  { file: "Plane_03.vox", label: "Voxel Plane", category: "VOX", attribution: MONOGON_VOXEL_PLANE_ATTRIBUTION },
+  { file: "bus.vox", label: "Voxel Bus", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
   { file: "tank.vox", label: "Tank", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
   { file: "arachnoid.vox", label: "Arachnoid", category: "VOX", attribution: MONOGON_VOXEL_MECHAS_ATTRIBUTION },
   { file: "MechaGolem.vox", label: "Mecha Golem", category: "VOX", attribution: MONOGON_VOXEL_MECHAS_ATTRIBUTION },
   { file: "mecha.vox", label: "Mecha", category: "VOX", attribution: MONOGON_VOXEL_MECHAS_ATTRIBUTION },
   { file: "StarMarineTrooper.vox", label: "Star Marine Trooper", category: "VOX", attribution: MONOGON_VOXEL_SPACESHIPS_ATTRIBUTION },
-  { file: "apple.vox", label: "Apple", category: "VOX", attribution: SONA_SAR_VOXEL_ANIMALS_ITEMS_ATTRIBUTION },
-  { file: "dual.vox", label: "Dual", category: "VOX", attribution: MONOGON_VOXEL_SPACESHIPS_ATTRIBUTION },
+  { file: "apple.vox", label: "Voxel Apple", category: "VOX", attribution: SONA_SAR_VOXEL_ANIMALS_ITEMS_ATTRIBUTION },
+  { file: "dual.vox", label: "Dual Ship", category: "VOX", attribution: MONOGON_VOXEL_SPACESHIPS_ATTRIBUTION },
   { file: "Treasure.vox", category: "VOX", attribution: MONOGON_ANCIENT_ENVIRONMENT_ATTRIBUTION },
-  { file: "tree.vox", label: "Tree", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  { file: "tree.vox", label: "Voxel Tree", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  ...OPENGAMEART_BUILDING_VOX_FILES,
+  ...OPENHV_VOX_FILES,
+  ...FLOOOH_VOX_FILES,
+  { file: "chr_robot.vox", label: "Voxel Robot", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  { file: "horse.vox", label: "Voxel Horse", category: "VOX", attribution: MAGICAVOXEL_TEST_MODELS_ATTRIBUTION },
+  { file: "mob_bear.vox", label: "Voxel Bear", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  { file: "obj_campfire.vox", label: "Voxel Campfire", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  { file: "scene_train.vox", label: "Train Scene", category: "VOX", attribution: MINI_MIKES_METRO_MINIS_ATTRIBUTION },
+  ...voxFiles(MINI_MIKES_METRO_MINIS_VOX_FILES, MINI_MIKES_METRO_MINIS_ATTRIBUTION),
+  ...voxFiles(MAGICAVOXEL_TEST_MODEL_FILES, MAGICAVOXEL_TEST_MODELS_ATTRIBUTION),
 ];
 
 const ULTIMATE_SPACESHIPS_ROOT = "quaternius/ultimate-spaceships";
diff --git a/website/src/components/GalleryWorkbench/presets/presetList.ts b/website/src/components/GalleryWorkbench/presets/presetList.ts
index 5ae55f6d..6e3a10b2 100644
--- a/website/src/components/GalleryWorkbench/presets/presetList.ts
+++ b/website/src/components/GalleryWorkbench/presets/presetList.ts
@@ -8,137 +8,88 @@ import {
   GOOGLE_POLY_FLYING_SAUCER_ATTRIBUTION,
   UTAH_TEAPOT_ATTRIBUTION,
   KENNEY_MINIGOLF_ATTRIBUTION,
+  PARFAITUWU_TREE_ATTRIBUTION,
+  POLYCSS_GENERATED_PRIMITIVE_ATTRIBUTION,
+  POLYCSS_LOCAL_FIXTURE_ATTRIBUTION,
 } from "./attributions";
 import { GLB_PRESET_FILES, POLY_PIZZA_PRESET_FILES, VOX_PRESET_FILES, OBJ_PRESET_FILES } from "./presetFiles";
 import { glbPreset, objPreset, voxPreset } from "./presetBuilders";
 import {
-  boxPolygons, planePolygons, ringPolygons,
-  spherePolygons, tetrahedronPolygons, octahedronPolygons, icosahedronPolygons, dodecahedronPolygons,
-  cylinderPolygons, conePolygons, torusPolygons,
+  boxPolygons,
+  spherePolygons,
+  tetrahedronPolygons,
+  octahedronPolygons,
+  icosahedronPolygons,
+  dodecahedronPolygons,
+  cylinderPolygons,
+  conePolygons,
+  torusPolygons,
 } from "@layoutit/polycss";
 
 const COLOR = "#ff6644";
+const PRIMITIVE_PRESET_DEFAULTS = {
+  category: "Primitives",
+  kind: "primitive",
+  galleryBucket: "Primitives",
+  zoom: 0.05,
+  rotX: 65,
+  rotY: 45,
+  attribution: POLYCSS_GENERATED_PRIMITIVE_ATTRIBUTION,
+} satisfies Pick<PresetModel, "category" | "kind" | "galleryBucket" | "zoom" | "rotX" | "rotY" | "attribution">;
 
 export const PRESETS: PresetModel[] = [
   {
     id: "primitive-box",
     label: "Box",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => boxPolygons({ size: 100, color: COLOR }),
   },
-  {
-    id: "primitive-plane",
-    label: "Plane",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
-    generatePolygons: () => planePolygons({ axis: 2, size: 50, offset: 0, color: COLOR }),
-  },
-  {
-    id: "primitive-ring",
-    label: "Ring",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
-    generatePolygons: () => ringPolygons({ axis: 2, radius: 50, halfThickness: 10, segments: 32, color: COLOR }),
-  },
   {
     id: "primitive-sphere",
     label: "Sphere",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => spherePolygons({ radius: 50, subdivisions: 1, color: COLOR }),
   },
   {
     id: "primitive-tetrahedron",
     label: "Tetrahedron",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => tetrahedronPolygons({ size: 80, color: COLOR }),
   },
   {
     id: "primitive-octahedron",
     label: "Octahedron",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => octahedronPolygons({ center: [0, 0, 0], size: 70, color: COLOR }),
   },
   {
     id: "primitive-icosahedron",
     label: "Icosahedron",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => icosahedronPolygons({ size: 80, color: COLOR }),
   },
   {
     id: "primitive-dodecahedron",
     label: "Dodecahedron",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => dodecahedronPolygons({ size: 80, color: COLOR }),
   },
   {
     id: "primitive-cylinder",
     label: "Cylinder",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => cylinderPolygons({ radius: 40, height: 100, radialSegments: 12, color: COLOR }),
   },
   {
     id: "primitive-cone",
     label: "Cone",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => conePolygons({ radius: 50, height: 100, radialSegments: 12, color: COLOR }),
   },
   {
     id: "primitive-torus",
     label: "Torus",
-    category: "Primitives",
-    kind: "primitive",
-    galleryBucket: "Primitives",
-    zoom: 0.05,
-    rotX: 65,
-    rotY: 45,
+    ...PRIMITIVE_PRESET_DEFAULTS,
     generatePolygons: () => torusPolygons({ radius: 50, tube: 15, radialSegments: 12, tubularSegments: 16, color: COLOR }),
   },
 
@@ -357,6 +308,7 @@ export const PRESETS: PresetModel[] = [
     zoom: 0.3,
     rotX: 65,
     rotY: 45,
+    attribution: PARFAITUWU_TREE_ATTRIBUTION,
   },
   {
     id: "saucer",
@@ -370,18 +322,6 @@ export const PRESETS: PresetModel[] = [
     rotY: 42.3,
     attribution: GOOGLE_POLY_FLYING_SAUCER_ATTRIBUTION,
   },
-  {
-    id: "wheelbarrow",
-    label: "Wheelbarrow",
-    category: "Objects",
-    kind: "obj",
-    url: "/gallery/obj/wheelbarrow.obj",
-    mtlUrl: "/gallery/obj/wheelbarrow.mtl",
-    options: { targetSize: 60 },
-    zoom: 0.2,
-    rotX: 66.2,
-    rotY: 36.1,
-  },
   {
     id: "teapot",
     label: "Teapot",
@@ -416,6 +356,7 @@ export const PRESETS: PresetModel[] = [
     zoom: 0.15,
     rotX: 65,
     rotY: 45,
+    attribution: POLYCSS_LOCAL_FIXTURE_ATTRIBUTION,
   },
   ...OBJ_PRESET_FILES.map(objPreset),
   ...GLB_PRESET_FILES.map(glbPreset),
diff --git a/website/src/components/VanillaScene/VanillaScene.tsx b/website/src/components/VanillaScene/VanillaScene.tsx
index 79ad2e99..5f76d427 100644
--- a/website/src/components/VanillaScene/VanillaScene.tsx
+++ b/website/src/components/VanillaScene/VanillaScene.tsx
@@ -50,6 +50,7 @@ interface StableTriangleTransformCache {
   leafCount: number;
   filled: number;
   disabled: boolean;
+  canRefreshColor: boolean;
   lastAppliedFrameIndex: number;
 }
 
@@ -60,6 +61,7 @@ function createStableTriangleTransformCache(): StableTriangleTransformCache {
     leafCount: 0,
     filled: 0,
     disabled: false,
+    canRefreshColor: false,
     lastAppliedFrameIndex: -1,
   };
 }
@@ -69,11 +71,12 @@ function resetStableTriangleTransformCache(cache: StableTriangleTransformCache):
   cache.leaves = null;
   cache.leafCount = 0;
   cache.filled = 0;
+  cache.canRefreshColor = false;
   cache.lastAppliedFrameIndex = -1;
 }
 
-function directStableTriangleLeaves(handle: VanillaPolyMeshHandle): HTMLElement[] {
-  return Array.from(handle.element.querySelectorAll<HTMLElement>(":scope > u"));
+function directStableAnimationLeaves(handle: VanillaPolyMeshHandle): HTMLElement[] {
+  return Array.from(handle.element.querySelectorAll<HTMLElement>(":scope > u,:scope > s"));
 }
 
 function captureStableTriangleTransformFrame(
@@ -82,7 +85,7 @@ function captureStableTriangleTransformFrame(
   frameIndex: number,
 ): void {
   if (cache.disabled) return;
-  const leaves = directStableTriangleLeaves(handle);
+  const leaves = directStableAnimationLeaves(handle);
   const expectedCount = handle.polygons.length;
   if (
     expectedCount <= 0 ||
@@ -92,11 +95,16 @@ function captureStableTriangleTransformFrame(
     resetStableTriangleTransformCache(cache);
     return;
   }
-  if (cache.leafCount !== 0 && leaves.length !== cache.leafCount) {
+  const canRefreshColor = leaves.every((leaf) => leaf.tagName === "U");
+  if (
+    cache.leafCount !== 0 &&
+    (leaves.length !== cache.leafCount || cache.canRefreshColor !== canRefreshColor)
+  ) {
     resetStableTriangleTransformCache(cache);
   }
   cache.leaves = leaves;
   cache.leafCount = leaves.length;
+  cache.canRefreshColor = canRefreshColor;
   if (!cache.frames[frameIndex]) cache.filled += 1;
   cache.frames[frameIndex] = leaves.map((leaf) => ({
     transform: leaf.style.transform || "none",
@@ -120,18 +128,24 @@ function applyStableTriangleTransformFrame(
   ) {
     return true;
   }
-  const leaves = cache.leaves ?? directStableTriangleLeaves(handle);
+  const leaves = cache.leaves ?? directStableAnimationLeaves(handle);
   if (leaves.length !== frame.length) {
     resetStableTriangleTransformCache(cache);
     return false;
   }
+  const previousFrame = cache.lastAppliedFrameIndex >= 0
+    ? cache.frames[cache.lastAppliedFrameIndex]
+    : undefined;
   cache.leaves = leaves;
   cache.leafCount = leaves.length;
   for (let i = 0; i < leaves.length; i += 1) {
     const leaf = leaves[i];
     const next = frame[i];
-    leaf.style.transform = next.transform;
-    if (leaf.style.visibility !== next.visibility) {
+    const previous = previousFrame?.[i];
+    if (previous?.transform !== next.transform) {
+      leaf.style.transform = next.transform;
+    }
+    if (previous?.visibility !== next.visibility) {
       leaf.style.visibility = next.visibility;
     }
   }
@@ -593,6 +607,7 @@ export function VanillaScene({
           : -1;
         const shouldRefreshColor =
           canUseTransformCache &&
+          transformCache.canRefreshColor &&
           animationFrameCount % ANIMATION_STABLE_TRIANGLE_COLOR_FREEZE_FRAMES === 0;
         const samples = debugTarget.__polycssGalleryAnimationSamples;
         let sampleMs = 0;
@@ -685,8 +700,8 @@ export function VanillaScene({
     ambientLight,
   ]);
 
-  // Effect 2b — strategy toggles. Kept separate from Effect 2 because
-  // `setOptions({ strategies })` triggers a full mesh re-render in
+  // Effect 2b — render strategy toggles. Kept separate from Effect 2 because
+  // these options trigger a full mesh re-render in
   // createPolyScene; folding it into the camera/lighting effect would
   // re-render on every rotation/zoom tick.
   useEffect(() => {
diff --git a/website/src/content/docs/api/types.mdx b/website/src/content/docs/api/types.mdx
index 97990d02..c3bfe20d 100644
--- a/website/src/content/docs/api/types.mdx
+++ b/website/src/content/docs/api/types.mdx
@@ -95,8 +95,10 @@ One-shot DOM diagnostic snapshot returned by `collectPolyRenderStats`.
 ```ts
 interface PolyRenderSurfaceLeafCounts {
   quad: number;
+  /** Border-shape `<i>` leaves. */
   clippedSolid: number;
   atlas: number;
+  /** `<u>` leaves, including triangles and exact corner-shape solids. */
   stableTriangle: number;
 }
 

From 8f57ba59bbf03ba30a9c2d39bb2a9a496cd12f99 Mon Sep 17 00:00:00 2001
From: agustin-littlehat <minotopo@gmail.com>
Date: Thu, 21 May 2026 18:33:47 -0300
Subject: [PATCH 4/5] test: trim corner shape corpus check

---
 packages/polycss/src/render/polyDOM.test.ts | 20 ++------------------
 1 file changed, 2 insertions(+), 18 deletions(-)

diff --git a/packages/polycss/src/render/polyDOM.test.ts b/packages/polycss/src/render/polyDOM.test.ts
index f554878b..78451770 100644
--- a/packages/polycss/src/render/polyDOM.test.ts
+++ b/packages/polycss/src/render/polyDOM.test.ts
@@ -19,25 +19,9 @@ const SOLID_QUAD_CANONICAL_SIZE = 64;
 
 const CORNER_SHAPE_CORPUS = [
   ["Bear.glb"],
-  ["Cat.glb"],
-  ["Wolf.glb"],
-  ["Frog.glb"],
-  ["Bat.glb"],
-  ["apple.glb"],
-  ["Grapes.glb"],
-  ["Watermelon.glb"],
-  ["urban", "Adventurer.glb"],
   ["urban", "Car.glb"],
-  ["urban", "Bus.glb"],
-  ["urban", "Box.glb"],
   ["urban", "Fire hydrant.glb"],
-  ["urban", "Cone.glb"],
-  ["urban", "Mailbox.glb"],
-  ["urban", "ATM.glb"],
-  ["city", "Small Building.glb"],
   ["city", "Large Building.glb"],
-  ["tree.glb"],
-  ["poly-pizza", "cardboard-box-closed.glb"],
 ] as const;
 
 const FLAT_TRIANGLE: Polygon = {
@@ -752,7 +736,7 @@ describe("renderPolygonsWithTextureAtlas", () => {
     result.dispose();
   });
 
-  it("replaces a subset of border-shape leaves with u leaves across a 20-model corpus", () => {
+  it("replaces a subset of border-shape leaves with u leaves across a gallery corpus", () => {
     const beforeDoc = supportDoc({ borderShape: true, cornerShape: false });
     const afterDoc = supportDoc({ borderShape: true, cornerShape: true });
     let beforeI = 0;
@@ -760,7 +744,7 @@ describe("renderPolygonsWithTextureAtlas", () => {
     let afterI = 0;
     let afterU = 0;
 
-    expect(CORNER_SHAPE_CORPUS).toHaveLength(20);
+    expect(CORNER_SHAPE_CORPUS).toHaveLength(4);
 
     for (const fixture of CORNER_SHAPE_CORPUS) {
       const parsed = parseGltf(loadGalleryGlb(...fixture));

From ba61c274cfa6d1375a6b474f5cb4183406b0985e Mon Sep 17 00:00:00 2001
From: agustin-littlehat <minotopo@gmail.com>
Date: Fri, 22 May 2026 18:51:33 -0300
Subject: [PATCH 5/5] feat: make seam repair default

---
 AGENTS.md                                     |    3 +-
 README.md                                     |    3 +-
 bench/seam-gap-bench.mjs                      |  845 ++++++++
 package.json                                  |    2 +
 packages/core/README.md                       |    5 +-
 packages/core/src/atlas/constants.ts          |    1 +
 packages/core/src/atlas/edgeRepair.ts         |  234 +++
 packages/core/src/atlas/matrix.ts             |    9 +-
 packages/core/src/atlas/plan.ts               |   38 +-
 packages/core/src/atlas/solidTriangle.ts      |   66 +
 packages/core/src/atlas/solidTrianglePlan.ts  |   51 +-
 packages/core/src/atlas/types.ts              |   20 +
 packages/core/src/index.ts                    |   38 +-
 .../core/src/merge/optimizePolygons.test.ts   |   13 +-
 packages/core/src/merge/optimizePolygons.ts   |   11 +-
 packages/core/src/merge/seamRepair.ts         | 1706 +++++++++++++++++
 packages/core/src/parser/loadMesh.ts          |   13 +-
 packages/polycss/README.md                    |    5 +-
 .../polycss/src/api/createPolyScene.test.ts   |   29 +-
 packages/polycss/src/api/createPolyScene.ts   |   45 +-
 .../src/elements/PolyAxesHelperElement.ts     |    2 +-
 .../PolyDirectionalLightHelperElement.ts      |    1 +
 .../src/elements/PolySceneElement.test.ts     |   18 +
 .../polycss/src/elements/PolySceneElement.ts  |    8 +
 .../polycss/src/elements/PolyShapeElements.ts |    1 +
 packages/polycss/src/index.ts                 |    1 +
 packages/polycss/src/render/atlas/index.ts    |    3 +-
 .../src/render/atlas/renderPolygons.ts        |   86 +-
 .../src/render/atlas/stableTriangle.test.ts   |   20 +
 .../src/render/atlas/stableTriangle.ts        |   61 +-
 packages/polycss/src/render/atlas/types.ts    |    2 +-
 packages/polycss/src/render/polyDOM.test.ts   |  113 ++
 packages/polycss/src/render/textureAtlas.ts   |    3 +
 packages/react/README.md                      |    5 +-
 packages/react/src/index.ts                   |   18 +
 packages/react/src/scene/PolyMesh.tsx         |   29 +-
 packages/react/src/scene/PolyScene.tsx        |   29 +-
 packages/react/src/scene/atlas/index.tsx      |    3 +
 .../src/scene/atlas/solidTriangleStyle.ts     |   48 +-
 .../src/scene/atlas/stableTriangleDom.ts      |    2 +
 packages/react/src/scene/index.ts             |    2 +-
 packages/react/src/scene/sceneContext.ts      |    3 +-
 packages/vue/README.md                        |    5 +-
 packages/vue/src/index.ts                     |   19 +-
 packages/vue/src/scene/PolyMesh.ts            |   27 +-
 packages/vue/src/scene/PolyScene.ts           |   24 +-
 packages/vue/src/scene/atlas/index.ts         |    3 +
 .../vue/src/scene/atlas/solidTriangleStyle.ts |  111 +-
 .../vue/src/scene/atlas/stableTriangleDom.ts  |    2 +
 packages/vue/src/scene/sceneContext.ts        |    3 +-
 .../BuilderWorkbench/BuilderWorkbench.tsx     |    3 +-
 .../BuilderWorkbench/builder-workbench.css    |   24 +
 .../components/BuilderDock.tsx                |    2 +-
 .../components/BuilderScene.tsx               |   46 +-
 .../components/BuilderWorkbench/defaults.ts   |    2 +-
 .../hooks/usePlacementMode.ts                 |    4 +-
 .../BuilderWorkbench/hooks/usePlacements.ts   |   10 +-
 .../BuilderWorkbench/hooks/useSceneLoader.ts  |   14 +-
 .../BuilderWorkbench/hooks/useSceneRender.ts  |   39 +-
 .../src/components/BuilderWorkbench/types.ts  |    4 +-
 .../Dock/folders/useRenderingFolder.ts        |   34 +-
 website/src/components/Dock/primitives.tsx    |    9 +-
 website/src/components/DocsHeader.astro       |    1 -
 .../GalleryWorkbench/GalleryWorkbench.tsx     |   46 +-
 .../GalleryWorkbench/gallery-workbench.css    |   39 +-
 .../hooks/useScenePolygons.ts                 |   55 +-
 .../src/components/ReactScene/ReactScene.tsx  |   46 +-
 .../components/VanillaScene/VanillaScene.tsx  |   62 +-
 .../interiorShell.ts}                         |  456 +++--
 website/src/components/types.ts               |   14 +-
 website/src/content/docs/api/headless.mdx     |    2 +-
 website/src/content/docs/api/types.mdx        |    2 +-
 .../content/docs/components/poly-scene.mdx    |    2 +
 73 files changed, 4217 insertions(+), 488 deletions(-)
 create mode 100644 bench/seam-gap-bench.mjs
 create mode 100644 packages/core/src/merge/seamRepair.ts
 rename website/src/components/{GalleryWorkbench/helpers/interiorFill.ts => helpers/interiorShell.ts} (57%)

diff --git a/AGENTS.md b/AGENTS.md
index 7eb8460d..47828261 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -39,7 +39,7 @@ Voxel-shaped meshes are the exception to "all polygons stay mounted": meshes wit
 
 Strategies are ordered cheapest → most expensive. The mesher's job is to maximise `<b>` / `<u>` / `<i>` and minimise `<s>` (see "Meshing implications" below).
 
-Callers can opt out of specific strategies via `strategies: { disable: ["b" | "i" | "u"] }` on `RenderTextureAtlasOptions`. Disabled or unsupported strategies fall through the chain (`b → i → s`, `u → i → s`, `i → s`). Disabling `"i"` also disables the exact corner-shape solid branch even though that branch emits a bare `<u>`, because it belongs to the non-triangle clipped-solid family. `<s>` is the universal fallback and cannot be disabled.
+Callers can opt out of specific strategies via `strategies: { disable: ["b" | "i" | "u"] }` on `RenderTextureAtlasOptions`. Disabled or unsupported strategies fall through the chain (`b → i → s`, `u → i → s`, `i → s`). Disabling `"i"` also disables the exact corner-shape solid branch even though that branch emits a bare `<u>`, because it belongs to the non-triangle clipped-solid family. `<s>` is the universal fallback and cannot be disabled. Solid seam bleed defaults to `1.5` CSS px on detected shared edges; callers can set `seamBleed`, where `"auto"` computes a fitted amount from each polygon plan and numeric values clamp the per-side CSS-pixel overscan. The renderer applies bleed only to detected shared seam edges of solid primitives, rather than inflating every side of each participating polygon.
 
 The `.vox` fast path emits plain `<b>` elements directly inside the mesh wrapper. They intentionally reuse the cheap quad tag, but they are exact voxel quads with one `matrix3d(...)` per visible quad, ordered by projected tile4 scanline order. Desktop-class documents use a canonical 1px primitive for the cheapest transform shape; mobile-class documents (`pointer: coarse` or `hover: none`) use an 8px primitive and divide the in-plane matrix scale by 8 to preserve identical CSS-space geometry while avoiding large GPU filtering gaps.
 
@@ -53,6 +53,7 @@ All solid/atlas tags work in both modes. The `.vox` direct-matrix fast path is b
 ### Meshing implications (what generators must respect)
 
 - **Polygon count is the dominant cost.** Each polygon is one DOM node, one `matrix3d`, one paint. Halving the polygon count is almost always worth a more complex mesher.
+- **Lossy optimization includes bounded seam repair.** The default `"lossy"` path merges compatible polygons, then repairs high-risk seams with targeted overlap and a small split budget. This can add a few triangles back when it prevents visible cracks; the goal is lower visible seam risk, not a strict guarantee that lossy always has fewer polygons than lossless.
 - **Fill ratio matters.** A textured polygon's atlas slice equals its local-2D bounding rect. Empty space inside that slice is wasted bitmap pixels. Prefer shapes with high `area / boundingRect.area`:
   - axis-aligned rectangle = 1.0 (and hits the fastest path)
   - right-isosceles triangle = 0.5
diff --git a/README.md b/README.md
index 81cca276..4a722b51 100644
--- a/README.md
+++ b/README.md
@@ -71,6 +71,7 @@ export default function App() {
 - `directionalLight` and `ambientLight` control scene lighting.
 - `textureLighting` chooses `"baked"` or `"dynamic"`.
 - `textureQuality` controls atlas raster budget.
+- Seam bleed defaults to `1.5` CSS px on detected shared solid edges; `seamBleed="auto"` fits the amount from each polygon plan.
 - `strategies` can disable selected render strategies for diagnostics.
 - `autoCenter` rotates around the rendered mesh bounds instead of world origin.
 
@@ -160,7 +161,7 @@ polycss renders in the DOM, so performance is mostly determined by how many poly
 - Textured polygons are packed into generated texture atlases.
 - Dynamic lighting runs through CSS custom properties instead of per-frame JavaScript.
 - Voxel-shaped meshes mount only camera-facing leaves when the mesh is eligible.
-- `meshResolution: "lossy"` can merge compatible polygons to reduce DOM node count.
+- `meshResolution: "lossy"` merges compatible polygons, then may spend a small split budget to repair high-risk seams.
 
 ## Packages
 
diff --git a/bench/seam-gap-bench.mjs b/bench/seam-gap-bench.mjs
new file mode 100644
index 00000000..08e7d403
--- /dev/null
+++ b/bench/seam-gap-bench.mjs
@@ -0,0 +1,845 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { transform } from "esbuild";
+import {
+  optimizeMeshPolygons,
+  parseGltf,
+  parseMtl,
+  parseObj,
+} from "../packages/core/dist/index.js";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const requireFromWebsite = createRequire(resolve(repoRoot, "website/package.json"));
+const DEFAULT_AMOUNT_PX = 2;
+const DEFAULT_LIMIT = 6;
+const DEFAULT_RENDER_URL = "http://localhost:4322/gallery/";
+const BASE_TILE = 50;
+
+const FIXTURES = [
+  {
+    id: "chicken",
+    label: "Chicken",
+    kind: "obj",
+    file: "website/public/gallery/obj/chicken.obj",
+    mtl: "website/public/gallery/obj/chicken.mtl",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#cccccc" },
+  },
+  {
+    id: "bear",
+    label: "Bear",
+    kind: "glb",
+    file: "website/public/gallery/glb/Bear.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+  {
+    id: "cheetah",
+    label: "Cheetah",
+    kind: "glb",
+    file: "website/public/gallery/glb/Cheetah.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+  {
+    id: "apple",
+    label: "Apple",
+    kind: "glb",
+    file: "website/public/gallery/glb/apple.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+  {
+    id: "atm",
+    label: "ATM",
+    kind: "glb",
+    file: "website/public/gallery/glb/urban/ATM.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+  {
+    id: "dog",
+    label: "Dog",
+    kind: "glb",
+    file: "website/public/gallery/glb/Dog.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+  {
+    id: "bags",
+    label: "Bags",
+    kind: "glb",
+    file: "website/public/gallery/glb/medieval/Bags.glb",
+    options: { targetSize: 60, gridShift: 1, defaultColor: "#8b95a1" },
+  },
+];
+
+const EXPECTED = {
+  chicken: { beforeTrueGaps: 2, afterTrueGaps: 0, changedPolygons: 4 },
+  bear: { beforeTrueGaps: 0, afterTrueGaps: 0, changedPolygons: 0 },
+  cheetah: { beforeTrueGaps: 0, afterTrueGaps: 0, changedPolygons: 0 },
+};
+
+function parseArgs(argv) {
+  const args = {
+    amountPx: DEFAULT_AMOUNT_PX,
+    limit: DEFAULT_LIMIT,
+    models: null,
+    json: "",
+    assert: true,
+    render: false,
+    renderSplit: false,
+    renderUrl: DEFAULT_RENDER_URL,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--") continue;
+    if (arg === "--help" || arg === "-h") args.help = true;
+    else if (arg === "--amount") args.amountPx = Number(argv[++i]);
+    else if (arg.startsWith("--amount=")) args.amountPx = Number(arg.slice("--amount=".length));
+    else if (arg === "--limit") args.limit = Number(argv[++i]);
+    else if (arg.startsWith("--limit=")) args.limit = Number(arg.slice("--limit=".length));
+    else if (arg === "--models") args.models = splitList(argv[++i]);
+    else if (arg.startsWith("--models=")) args.models = splitList(arg.slice("--models=".length));
+    else if (arg === "--json") args.json = argv[++i] ?? "";
+    else if (arg.startsWith("--json=")) args.json = arg.slice("--json=".length);
+    else if (arg === "--render") args.render = true;
+    else if (arg === "--render-split") args.renderSplit = true;
+    else if (arg === "--render-url") args.renderUrl = argv[++i] ?? DEFAULT_RENDER_URL;
+    else if (arg.startsWith("--render-url=")) args.renderUrl = arg.slice("--render-url=".length);
+    else if (arg === "--no-assert") args.assert = false;
+    else throw new Error(`Unknown option ${arg}`);
+  }
+
+  if (!Number.isFinite(args.amountPx) || args.amountPx < 0) {
+    throw new Error("--amount must be a non-negative number");
+  }
+  args.limit = Number.isFinite(args.limit) ? Math.max(0, Math.floor(args.limit)) : DEFAULT_LIMIT;
+  return args;
+}
+
+function splitList(value = "") {
+  return value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+}
+
+function printHelp() {
+  console.log(`Usage: node bench/seam-gap-bench.mjs [--models chicken,cheetah,bear] [--json file]
+
+Measures object-space seam gap candidates before and after the current seam
+repair helper. It separates real disconnected same-material gaps from connected
+facet edges and material-boundary false positives.
+
+Options:
+  --amount <px>     Repair request in CSS px. Default: ${DEFAULT_AMOUNT_PX}
+  --models <list>   Comma-separated fixture ids/labels. Default: chicken,bear,cheetah
+  --limit <n>       Candidate rows to print per model. Default: ${DEFAULT_LIMIT}
+  --json <file>     Write full machine-readable rows.
+  --render          Also measure rendered exact-edge cracks in a browser.
+  --render-split    Alias for --render; the gallery now always uses the default seam path.
+  --render-url <u>  Gallery URL for --render. Default: ${DEFAULT_RENDER_URL}
+  --no-assert       Do not fail when fixture expectations drift.
+`);
+}
+
+function readBytes(path) {
+  const bytes = readFileSync(path);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+async function loadSeamHelper() {
+  const sourcePath = resolve(repoRoot, "packages/core/src/merge/seamRepair.ts");
+  const source = readFileSync(sourcePath, "utf8");
+  const { code } = await transform(source, {
+    loader: "ts",
+    format: "esm",
+    target: "node22",
+  });
+  return import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`);
+}
+
+function selectedFixtures(models) {
+  if (!models?.length) return FIXTURES;
+  return FIXTURES.filter((fixture) => {
+    const haystack = `${fixture.id} ${fixture.label}`.toLowerCase();
+    return models.some((needle) => haystack.includes(needle));
+  });
+}
+
+function loadFixture(fixture) {
+  const file = resolve(repoRoot, fixture.file);
+  if (fixture.kind === "obj") {
+    const objText = readFileSync(file, "utf8");
+    const mtl = fixture.mtl
+      ? parseMtl(readFileSync(resolve(repoRoot, fixture.mtl), "utf8"))
+      : { colors: {}, textures: {} };
+    return parseObj(objText, {
+      ...fixture.options,
+      materialColors: mtl.colors,
+    }).polygons;
+  }
+
+  return parseGltf(readBytes(file), {
+    ...fixture.options,
+    baseUrl: pathToFileURL(file).href,
+  }).polygons;
+}
+
+function cssPoint(vertex) {
+  return [vertex[1] * BASE_TILE, vertex[0] * BASE_TILE, vertex[2] * BASE_TILE];
+}
+
+function pointKey(point) {
+  return `${point[0]},${point[1]},${point[2]}`;
+}
+
+function edgeKey(a, b) {
+  const ak = pointKey(a);
+  const bk = pointKey(b);
+  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
+}
+
+function materialKey(polygon) {
+  return polygon.material?.key ?? polygon.color ?? "";
+}
+
+function hasTexture(polygon) {
+  return !!(polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length);
+}
+
+function exactSharedSameMaterialEdges(polygons) {
+  const ownersByKey = new Map();
+  for (let polygonIndex = 0; polygonIndex < polygons.length; polygonIndex += 1) {
+    const polygon = polygons[polygonIndex];
+    if (hasTexture(polygon)) continue;
+    const points = polygon.vertices.map(cssPoint);
+    for (let edgeIndex = 0; edgeIndex < points.length; edgeIndex += 1) {
+      const a = points[edgeIndex];
+      const b = points[(edgeIndex + 1) % points.length];
+      const key = edgeKey(a, b);
+      const owners = ownersByKey.get(key);
+      const owner = {
+        polygon: polygonIndex,
+        edge: edgeIndex,
+        color: polygon.color,
+        materialKey: materialKey(polygon),
+        a,
+        b,
+      };
+      if (owners) owners.push(owner);
+      else ownersByKey.set(key, [owner]);
+    }
+  }
+
+  const edges = [];
+  for (const owners of ownersByKey.values()) {
+    if (owners.length !== 2) continue;
+    const [a, b] = owners;
+    if (a.materialKey !== b.materialKey || a.color !== b.color) continue;
+    edges.push({
+      aPolygon: a.polygon,
+      aEdge: a.edge,
+      bPolygon: b.polygon,
+      bEdge: b.edge,
+      color: a.color,
+      materialKey: a.materialKey,
+      p0: a.a,
+      p1: a.b,
+    });
+  }
+  return edges;
+}
+
+function edgePairPlanKey(aPolygon, aEdge, bPolygon, bEdge) {
+  const a = `${aPolygon}:${aEdge}`;
+  const b = `${bPolygon}:${bEdge}`;
+  return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+
+function splitPlanLookup(report) {
+  const out = new Map();
+  for (const candidate of report?.candidates ?? []) {
+    out.set(
+      edgePairPlanKey(candidate.aPolygon, candidate.aEdge, candidate.bPolygon, candidate.bEdge),
+      candidate,
+    );
+  }
+  return out;
+}
+
+function countChangedPolygons(before, after) {
+  let changed = 0;
+  for (let i = 0; i < before.length; i += 1) {
+    if (before[i] !== after[i]) changed += 1;
+  }
+  return changed;
+}
+
+function vertexDelta(before, after) {
+  let added = 0;
+  let removed = 0;
+  for (let i = 0; i < before.length; i += 1) {
+    const delta = (after[i]?.vertices.length ?? 0) - before[i].vertices.length;
+    if (delta > 0) added += delta;
+    else removed -= delta;
+  }
+  return { added, removed };
+}
+
+function candidatesByKind(report, kind) {
+  return report.candidates.filter((candidate) => candidate.kind === kind);
+}
+
+function summarizeReport(report) {
+  const trueGaps = candidatesByKind(report, "true-gap");
+  const connectedFacets = candidatesByKind(report, "connected-facet");
+  const materialBoundaries = candidatesByKind(report, "material-boundary");
+  return {
+    exactPairs: report.diagnostics.exactPairs,
+    trueGapPairs: trueGaps.length,
+    connectedFacetPairs: connectedFacets.length,
+    materialBoundaryPairs: materialBoundaries.length,
+    maxTrueGapPx: maxOf(trueGaps, "gapPx"),
+    maxResidualGapPx: maxOf(trueGaps, "residualGapPx"),
+    maxAppliedClosurePx: maxOf(trueGaps, "appliedClosurePx"),
+    trueGapSpanPx: sumOf(trueGaps, "spanPx"),
+  };
+}
+
+function maxOf(items, key) {
+  return items.reduce((max, item) => Math.max(max, item[key] ?? 0), 0);
+}
+
+function sumOf(items, key) {
+  return items.reduce((sum, item) => sum + (item[key] ?? 0), 0);
+}
+
+function analyzeFixture(fixture, seam, amountPx, limit) {
+  const raw = loadFixture(fixture);
+  const optimized = optimizeMeshPolygons(raw, { meshResolution: "lossless" });
+  const baselineReport = seam.seamOverlapReport(optimized, amountPx);
+  const repaired = seam.repairMeshSeams
+    ? seam.repairMeshSeams(optimized)
+    : seam.seamOverlapPolygons(seam.seamFacetSplitPolygons(optimized, amountPx), amountPx);
+  const repairedReport = seam.seamOverlapReport(repaired, amountPx);
+  const changedPolygons = countChangedPolygons(optimized, repaired);
+  const vertices = vertexDelta(optimized, repaired);
+
+  const baseline = summarizeReport(baselineReport);
+  const after = summarizeReport(repairedReport);
+  return {
+    id: fixture.id,
+    label: fixture.label,
+    file: relative(repoRoot, resolve(repoRoot, fixture.file)),
+    sourcePolygons: raw.length,
+    polygons: optimized.length,
+    changedPolygons,
+    vertexDelta: vertices,
+    baseline,
+    after,
+    topTrueGaps: topCandidates(candidatesByKind(baselineReport, "true-gap"), limit),
+    topConnectedFacets: topCandidates(candidatesByKind(baselineReport, "connected-facet"), limit),
+    topMaterialBoundaries: topCandidates(candidatesByKind(baselineReport, "material-boundary"), limit),
+  };
+}
+
+function topCandidates(candidates, limit) {
+  return [...candidates]
+    .sort((a, b) => b.gapPx - a.gapPx || b.spanPx - a.spanPx)
+    .slice(0, limit)
+    .map((candidate) => ({
+      kind: candidate.kind,
+      gapPx: round(candidate.gapPx),
+      spanPx: round(candidate.spanPx),
+      appliedClosurePx: round(candidate.appliedClosurePx),
+      residualGapPx: round(candidate.residualGapPx),
+      a: `${candidate.aPolygon}:${candidate.aEdge}`,
+      b: `${candidate.bPolygon}:${candidate.bEdge}`,
+      colors: candidate.aColor === candidate.bColor
+        ? candidate.aColor ?? ""
+        : `${candidate.aColor ?? ""}/${candidate.bColor ?? ""}`,
+    }));
+}
+
+function round(value, digits = 3) {
+  return Number.isFinite(value) ? Number(value.toFixed(digits)) : 0;
+}
+
+function fmt(value, digits = 2) {
+  return Number.isFinite(value) ? value.toFixed(digits) : "0.00";
+}
+
+function printReport(rows, amountPx, limit, failures) {
+  console.log("# Seam Gap Bench\n");
+  console.log(`Repair amount: ${fmt(amountPx, 2)} CSS px`);
+  console.log("Coordinates are measured in the same CSS-space units the renderer uses for polygon plans.\n");
+  console.log("| Model | Polys | Exact shared | True gaps before -> after | Max true gap px | Rejects connected/material | Changed polys | Added verts |");
+  console.log("| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |");
+  for (const row of rows) {
+    console.log([
+      `| ${row.label}`,
+      row.polygons,
+      row.baseline.exactPairs,
+      `${row.baseline.trueGapPairs} -> ${row.after.trueGapPairs}`,
+      `${fmt(row.baseline.maxTrueGapPx)} -> ${fmt(row.after.maxTrueGapPx)}`,
+      `${row.baseline.connectedFacetPairs}/${row.baseline.materialBoundaryPairs}`,
+      row.changedPolygons,
+      `${row.vertexDelta.added} |`,
+    ].join(" | "));
+  }
+
+  for (const row of rows) {
+    console.log(`\n## ${row.label}`);
+    printCandidateSection("True gaps", row.topTrueGaps, limit);
+    printCandidateSection("Connected facet rejects", row.topConnectedFacets, limit);
+    printCandidateSection("Material-boundary rejects", row.topMaterialBoundaries, limit);
+  }
+
+  if (failures.length > 0) {
+    console.log("\n## Assertion Failures");
+    for (const failure of failures) console.log(`- ${failure}`);
+  }
+}
+
+function printCandidateSection(title, candidates, limit) {
+  if (limit === 0) return;
+  console.log(`\n${title}:`);
+  if (candidates.length === 0) {
+    console.log("- none");
+    return;
+  }
+  for (const candidate of candidates) {
+    console.log(
+      `- ${candidate.a} <-> ${candidate.b} gap=${fmt(candidate.gapPx)}px span=${fmt(candidate.spanPx)}px ` +
+      `applied=${fmt(candidate.appliedClosurePx)}px residual=${fmt(candidate.residualGapPx)}px color=${candidate.colors}`,
+    );
+  }
+}
+
+async function runRenderBench(fixtures, seam, amountPx, renderUrl, limit, mode = "bleed") {
+  const { chromium } = await import("playwright");
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const rows = [];
+    for (const fixture of fixtures) {
+      rows.push(await measureRenderedFixture(browser, fixture, seam, amountPx, renderUrl, limit, mode));
+    }
+    return rows;
+  } finally {
+    await browser.close();
+  }
+}
+
+async function measureRenderedFixture(browser, fixture, seam, amountPx, renderUrl, limit, mode) {
+  const raw = loadFixture(fixture);
+  const optimized = optimizeMeshPolygons(raw, { meshResolution: "lossless" });
+  const repaired = optimizeMeshPolygons(raw, { meshResolution: "lossy" });
+  const splitPlan = seam.seamFacetSplitReport
+    ? splitPlanLookup(seam.seamFacetSplitReport(optimized, amountPx))
+    : undefined;
+  const page = await browser.newPage({ viewport: { width: 768, height: 768 }, deviceScaleFactor: 1 });
+  try {
+    await openGalleryModel(page, renderUrl, fixture.label);
+    const rendered = await measureRenderedState(page, repaired, limit, splitPlan);
+    return {
+      id: fixture.id,
+      label: fixture.label,
+      mode: "default",
+      rendered,
+    };
+  } finally {
+    await page.close();
+  }
+}
+
+async function openGalleryModel(page, renderUrl, label) {
+  await page.goto(renderUrl, { waitUntil: "load" });
+  await page.waitForTimeout(1800);
+  await page.getByPlaceholder("Search models").fill(label);
+  await page.waitForTimeout(300);
+  await page.getByRole("button", { name: label, exact: true }).click();
+  await page.waitForTimeout(1800);
+}
+
+async function measureRenderedState(page, polygons, limit, splitPlan) {
+  await page.waitForTimeout(1200);
+  const edges = exactSharedSameMaterialEdges(polygons);
+  const tags = await renderedLeafTags(page);
+  const screenEdges = await projectEdges(page, edges, tags);
+  const screenshot = await page.screenshot({ fullPage: false });
+  const image = await decodeScreenshot(screenshot);
+  return {
+    ...measureScreenEdges(screenEdges, image, limit, splitPlan),
+  };
+}
+
+async function renderedLeafTags(page) {
+  return page.evaluate(() =>
+    [...document.querySelectorAll(".polycss-scene b,.polycss-scene i,.polycss-scene u,.polycss-scene s")]
+      .map((el) => el.tagName.toLowerCase())
+  );
+}
+
+async function projectEdges(page, edges, tags) {
+  const pointIndex = new Map();
+  const points = [];
+  const indexFor = (point) => {
+    const key = pointKey(point);
+    const current = pointIndex.get(key);
+    if (current !== undefined) return current;
+    const next = points.length;
+    pointIndex.set(key, next);
+    points.push(point);
+    return next;
+  };
+  const edgeRefs = edges.map((edge) => ({
+    edge,
+    p0: indexFor(edge.p0),
+    p1: indexFor(edge.p1),
+  }));
+
+  const projected = await page.evaluate((pts) => {
+    const host = document.querySelector(".polycss-mesh.dn-model-mesh") ??
+      document.querySelector(".polycss-scene");
+    if (!host) throw new Error("No rendered mesh host found");
+
+    const markers = pts.map((point) => {
+      const marker = document.createElement("em");
+      marker.style.position = "absolute";
+      marker.style.left = "0";
+      marker.style.top = "0";
+      marker.style.width = "1px";
+      marker.style.height = "1px";
+      marker.style.transformOrigin = "0 0";
+      marker.style.transformStyle = "preserve-3d";
+      marker.style.pointerEvents = "none";
+      marker.style.background = "transparent";
+      marker.style.transform = `translate3d(${point[0]}px,${point[1]}px,${point[2]}px)`;
+      host.appendChild(marker);
+      return marker;
+    });
+
+    const out = markers.map((marker) => {
+      const rect = marker.getBoundingClientRect();
+      marker.remove();
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+      };
+    });
+    return out;
+  }, points);
+
+  return edgeRefs.map(({ edge, p0, p1 }) => ({
+    ...edge,
+    tagA: tags[edge.aPolygon] ?? "?",
+    tagB: tags[edge.bPolygon] ?? "?",
+    s0: projected[p0],
+    s1: projected[p1],
+  }));
+}
+
+async function decodeScreenshot(buffer) {
+  const sharp = requireFromWebsite("sharp");
+  const { data, info } = await sharp(buffer).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return { data, width: info.width, height: info.height, channels: info.channels };
+}
+
+function measureScreenEdges(edges, image, limit, splitPlan) {
+  const measured = [];
+  const selectedClean = [];
+  let visibleEdges = 0;
+  let crackedEdges = 0;
+  let crackSamples = 0;
+  let visibleSamples = 0;
+  let maxRunPx = 0;
+  let selectedVisibleEdges = 0;
+  let selectedCrackedEdges = 0;
+  let selectedCleanEdges = 0;
+  let selectedCrackSamples = 0;
+  let selectedVisibleSamples = 0;
+  const crackedTagPairs = new Map();
+
+  for (const edge of edges) {
+    const result = measureScreenEdge(edge, image);
+    if (result.visibleSamples === 0) continue;
+    const plan = splitPlan?.get(edgePairPlanKey(edge.aPolygon, edge.aEdge, edge.bPolygon, edge.bEdge));
+    visibleEdges += 1;
+    visibleSamples += result.visibleSamples;
+    crackSamples += result.crackSamples;
+    maxRunPx = Math.max(maxRunPx, result.maxRunPx);
+    if (plan?.selected) {
+      selectedVisibleEdges += 1;
+      selectedVisibleSamples += result.visibleSamples;
+      selectedCrackSamples += result.crackSamples;
+      if (result.crackSamples > 0) selectedCrackedEdges += 1;
+      else {
+        selectedCleanEdges += 1;
+        selectedClean.push({ ...edge, ...result, splitPlan: plan });
+      }
+    }
+    if (result.crackSamples > 0) {
+      crackedEdges += 1;
+      const tagPair = [edge.tagA, edge.tagB].sort().join("/");
+      const group = crackedTagPairs.get(tagPair) ?? { edges: 0, crackSamples: 0 };
+      group.edges += 1;
+      group.crackSamples += result.crackSamples;
+      crackedTagPairs.set(tagPair, group);
+      measured.push({ ...edge, ...result, splitPlan: plan });
+    }
+  }
+
+  measured.sort((a, b) => b.crackSamples - a.crackSamples || b.maxRunPx - a.maxRunPx);
+  selectedClean.sort((a, b) => (b.splitPlan?.score ?? 0) - (a.splitPlan?.score ?? 0));
+  return {
+    exactSameMaterialEdges: edges.length,
+    visibleEdges,
+    crackedEdges,
+    crackSamples,
+    visibleSamples,
+    crackRatio: visibleSamples > 0 ? crackSamples / visibleSamples : 0,
+    maxRunPx,
+    crackedTagPairs: [...crackedTagPairs.entries()]
+      .map(([tagPair, group]) => ({ tagPair, ...group }))
+      .sort((a, b) => b.crackSamples - a.crackSamples || b.edges - a.edges),
+    selectedPlan: {
+      visibleEdges: selectedVisibleEdges,
+      crackedEdges: selectedCrackedEdges,
+      cleanEdges: selectedCleanEdges,
+      crackSamples: selectedCrackSamples,
+      visibleSamples: selectedVisibleSamples,
+      crackRatio: round(selectedVisibleSamples > 0 ? selectedCrackSamples / selectedVisibleSamples : 0, 4),
+    },
+    topCracks: measured.slice(0, limit).map((edge) => ({
+      a: `${edge.aPolygon}:${edge.aEdge}`,
+      b: `${edge.bPolygon}:${edge.bEdge}`,
+      tags: [edge.tagA, edge.tagB].join("/"),
+      color: edge.color ?? "",
+      lengthPx: round(edge.lengthPx),
+      crackSamples: edge.crackSamples,
+      visibleSamples: edge.visibleSamples,
+      crackRatio: round(edge.visibleSamples > 0 ? edge.crackSamples / edge.visibleSamples : 0, 4),
+      maxRunPx: edge.maxRunPx,
+      splitPlan: edge.splitPlan
+        ? {
+            selected: edge.splitPlan.selected,
+            reason: edge.splitPlan.reason,
+            component: edge.splitPlan.component,
+            cost: edge.splitPlan.marginalCost,
+            score: round(edge.splitPlan.score),
+          }
+        : undefined,
+    })),
+    topSelectedClean: selectedClean.slice(0, limit).map((edge) => ({
+      a: `${edge.aPolygon}:${edge.aEdge}`,
+      b: `${edge.bPolygon}:${edge.bEdge}`,
+      tags: [edge.tagA, edge.tagB].join("/"),
+      color: edge.color ?? "",
+      lengthPx: round(edge.lengthPx),
+      visibleSamples: edge.visibleSamples,
+      splitPlan: edge.splitPlan
+        ? {
+            reason: edge.splitPlan.reason,
+            component: edge.splitPlan.component,
+            cost: edge.splitPlan.marginalCost,
+            score: round(edge.splitPlan.score),
+          }
+        : undefined,
+    })),
+  };
+}
+
+function measureScreenEdge(edge, image) {
+  const dx = edge.s1.x - edge.s0.x;
+  const dy = edge.s1.y - edge.s0.y;
+  const lengthPx = Math.hypot(dx, dy);
+  if (lengthPx < 6) {
+    return { lengthPx, visibleSamples: 0, crackSamples: 0, maxRunPx: 0 };
+  }
+
+  const nx = -dy / lengthPx;
+  const ny = dx / lengthPx;
+  let visibleSamples = 0;
+  let crackSamples = 0;
+  let currentRun = 0;
+  let maxRunPx = 0;
+  const start = 2;
+  const end = Math.max(start, lengthPx - 2);
+
+  for (let distance = start; distance <= end; distance += 1) {
+    const x = edge.s0.x + (dx * distance) / lengthPx;
+    const y = edge.s0.y + (dy * distance) / lengthPx;
+    const samples = [-3, -2, -1, 0, 1, 2, 3].map((offset) =>
+      samplePixel(image, x + nx * offset, y + ny * offset)
+    );
+    if (samples.some((sample) => sample === null)) {
+      currentRun = 0;
+      continue;
+    }
+
+    const sideA = isFilled(samples[0]) || isFilled(samples[1]);
+    const sideB = isFilled(samples[5]) || isFilled(samples[6]);
+    if (!sideA || !sideB) {
+      currentRun = 0;
+      continue;
+    }
+
+    visibleSamples += 1;
+    const darkCenter = isBlack(samples[2]) || isBlack(samples[3]) || isBlack(samples[4]);
+    if (darkCenter) {
+      crackSamples += 1;
+      currentRun += 1;
+      maxRunPx = Math.max(maxRunPx, currentRun);
+    } else {
+      currentRun = 0;
+    }
+  }
+
+  return { lengthPx, visibleSamples, crackSamples, maxRunPx };
+}
+
+function samplePixel(image, x, y) {
+  const px = Math.round(x);
+  const py = Math.round(y);
+  if (px < 0 || py < 0 || px >= image.width || py >= image.height) return null;
+  const i = (py * image.width + px) * image.channels;
+  return {
+    r: image.data[i],
+    g: image.data[i + 1],
+    b: image.data[i + 2],
+    a: image.data[i + 3],
+  };
+}
+
+function isBlack(pixel) {
+  return pixel.a > 240 && pixel.r < 34 && pixel.g < 34 && pixel.b < 34;
+}
+
+function isFilled(pixel) {
+  return pixel.a > 240 && Math.max(pixel.r, pixel.g, pixel.b) > 55 && !isBlack(pixel);
+}
+
+function printRenderReport(rows) {
+  console.log("\n# Rendered Seam Pixel Bench (Default Seam Path)\n");
+  console.log("This samples exact shared same-material edges after browser projection; a crack sample is a black center pixel with filled pixels on both sides.\n");
+  console.log("| Model | Exact edges | Visible edges | Cracked edges | Crack samples | Max run |");
+  console.log("| --- | ---: | ---: | ---: | ---: | ---: |");
+  for (const row of rows) {
+    const rendered = row.rendered;
+    console.log([
+      `| ${row.label}`,
+      rendered.exactSameMaterialEdges,
+      rendered.visibleEdges,
+      rendered.crackedEdges,
+      rendered.crackSamples,
+      `${rendered.maxRunPx} |`,
+    ].join(" | "));
+  }
+
+  for (const row of rows) {
+    const rendered = row.rendered;
+    console.log(`\n## ${row.label} Rendered Cracks`);
+    printTagPairSection("Strategy pairs", rendered.crackedTagPairs);
+    printSelectedPlanSection("Selected split plan", rendered.selectedPlan);
+    printRenderedCrackSection("Cracks", rendered.topCracks);
+    printSelectedCleanSection("Selected clean", rendered.topSelectedClean);
+  }
+}
+
+function printTagPairSection(title, pairs) {
+  console.log(`\n${title}:`);
+  if (pairs.length === 0) {
+    console.log("- none");
+    return;
+  }
+  for (const pair of pairs.slice(0, 8)) {
+    console.log(`- ${pair.tagPair}: edges=${pair.edges} samples=${pair.crackSamples}`);
+  }
+}
+
+function printRenderedCrackSection(title, cracks) {
+  console.log(`\n${title}:`);
+  if (cracks.length === 0) {
+    console.log("- none");
+    return;
+  }
+  for (const crack of cracks) {
+    const plan = crack.splitPlan
+      ? ` plan=${crack.splitPlan.selected ? "selected" : "skipped"}/${crack.splitPlan.reason}` +
+        ` c=${crack.splitPlan.component} cost=${crack.splitPlan.cost} score=${fmt(crack.splitPlan.score)}`
+      : "";
+    console.log(
+      `- ${crack.a} <-> ${crack.b} crack=${crack.crackSamples}/${crack.visibleSamples} ` +
+      `run=${crack.maxRunPx}px len=${fmt(crack.lengthPx)}px tags=${crack.tags} color=${crack.color}${plan}`,
+    );
+  }
+}
+
+function printSelectedPlanSection(title, plan) {
+  if (!plan || plan.visibleEdges === 0) return;
+  console.log(`\n${title}:`);
+  console.log(
+    `- visible=${plan.visibleEdges} cracked=${plan.crackedEdges} clean=${plan.cleanEdges} ` +
+    `samples=${plan.crackSamples}/${plan.visibleSamples} ratio=${fmt(plan.crackRatio)}`,
+  );
+}
+
+function printSelectedCleanSection(title, cracks) {
+  if (!cracks?.length) return;
+  console.log(`\n${title}:`);
+  for (const crack of cracks) {
+    const plan = crack.splitPlan
+      ? ` plan=${crack.splitPlan.reason} c=${crack.splitPlan.component} cost=${crack.splitPlan.cost} score=${fmt(crack.splitPlan.score)}`
+      : "";
+    console.log(
+      `- ${crack.a} <-> ${crack.b} visible=${crack.visibleSamples} ` +
+      `len=${fmt(crack.lengthPx)}px tags=${crack.tags} color=${crack.color}${plan}`,
+    );
+  }
+}
+
+function assertionFailures(rows) {
+  const failures = [];
+  for (const row of rows) {
+    const expected = EXPECTED[row.id];
+    if (!expected) continue;
+    if (row.baseline.trueGapPairs !== expected.beforeTrueGaps) {
+      failures.push(`${row.label}: expected ${expected.beforeTrueGaps} baseline true gaps, got ${row.baseline.trueGapPairs}`);
+    }
+    if (row.after.trueGapPairs !== expected.afterTrueGaps) {
+      failures.push(`${row.label}: expected ${expected.afterTrueGaps} post-repair true gaps, got ${row.after.trueGapPairs}`);
+    }
+    if (row.changedPolygons !== expected.changedPolygons) {
+      failures.push(`${row.label}: expected ${expected.changedPolygons} changed polygons, got ${row.changedPolygons}`);
+    }
+  }
+  return failures;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+  printHelp();
+  process.exit(0);
+}
+
+const fixtures = selectedFixtures(args.models);
+if (fixtures.length === 0) {
+  throw new Error("No seam fixtures matched --models");
+}
+
+const seam = await loadSeamHelper();
+const rows = fixtures.map((fixture) => analyzeFixture(fixture, seam, args.amountPx, args.limit));
+const failures = args.assert ? assertionFailures(rows) : [];
+printReport(rows, args.amountPx, args.limit, failures);
+const renderRows = args.render
+  ? await runRenderBench(fixtures, seam, args.amountPx, args.renderUrl, args.limit, "bleed")
+  : args.renderSplit
+    ? await runRenderBench(fixtures, seam, args.amountPx, args.renderUrl, args.limit, "split")
+  : [];
+if (args.render || args.renderSplit) printRenderReport(renderRows);
+
+if (args.json) {
+  const path = resolve(repoRoot, args.json);
+  writeFileSync(path, `${JSON.stringify({ amountPx: args.amountPx, rows, renderRows }, null, 2)}\n`);
+  console.log(`\nWrote ${relative(repoRoot, path)}`);
+}
+
+if (failures.length > 0) process.exitCode = 1;
diff --git a/package.json b/package.json
index f82a0320..87079288 100644
--- a/package.json
+++ b/package.json
@@ -34,6 +34,8 @@
     "bench:trace": "node bench/build.mjs && node bench/trace-analysis.mjs",
     "bench:lossy": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-optimizer-bench.mjs",
     "bench:lossy:corpus": "pnpm --filter @layoutit/polycss-core build && node bench/lossy-corpus-bench.mjs",
+    "bench:seams": "pnpm --filter @layoutit/polycss-core build && node bench/seam-gap-bench.mjs",
+    "bench:seams:render": "pnpm --filter @layoutit/polycss-core build && node bench/seam-gap-bench.mjs --render",
     "bench:voxel-report": "node bench/voxel-report.mjs",
     "bench:visual": "node bench/build.mjs && node bench/perf-visual.mjs"
   },
diff --git a/packages/core/README.md b/packages/core/README.md
index ad8a69f3..6af2b1e9 100644
--- a/packages/core/README.md
+++ b/packages/core/README.md
@@ -88,6 +88,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `directionalLight` and `ambientLight` control scene lighting.
 - `textureLighting` chooses `"baked"` or `"dynamic"`.
 - `textureQuality` controls atlas raster budget.
+- `seamBleed="auto"` computes solid-primitive overscan from each polygon plan; numeric values clamp detected shared seam edges.
 - `strategies` can disable selected render strategies for diagnostics.
 - `autoCenter` rotates around the rendered mesh bounds instead of world origin.
 
@@ -98,7 +99,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `polygons` accepts pre-parsed geometry.
 - `position`, `scale`, and `rotation` transform the mesh wrapper.
 - `autoCenter` shifts the mesh bbox center to local origin.
-- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization.
+- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization. Lossy also applies bounded seam repair.
 - `castShadow` emits CSS-projected shadows in dynamic lighting mode.
 
 ### Controls
@@ -177,7 +178,7 @@ polycss renders in the DOM, so performance is mostly determined by how many poly
 - Textured polygons are packed into generated texture atlases.
 - Dynamic lighting runs through CSS custom properties instead of per-frame JavaScript.
 - Voxel-shaped meshes mount only camera-facing leaves when the mesh is eligible.
-- `meshResolution: "lossy"` can merge compatible polygons to reduce DOM node count.
+- `meshResolution: "lossy"` merges compatible polygons, then may spend a small split budget to repair high-risk seams.
 
 For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, which returns mounted polygon leaf counts, shadow counts, surface categories, and bucket counts for an already-rendered scene.
 
diff --git a/packages/core/src/atlas/constants.ts b/packages/core/src/atlas/constants.ts
index 9b11a091..5bd2e306 100644
--- a/packages/core/src/atlas/constants.ts
+++ b/packages/core/src/atlas/constants.ts
@@ -58,3 +58,4 @@ export const CORNER_SHAPE_DUPLICATE_EPS = 0.2;
 export const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
 export const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = Number.POSITIVE_INFINITY;
 export const PROJECTIVE_QUAD_BLEED = 0.6;
+export const DEFAULT_SEAM_BLEED = 1.5;
diff --git a/packages/core/src/atlas/edgeRepair.ts b/packages/core/src/atlas/edgeRepair.ts
index 3f63be11..cd7390bb 100644
--- a/packages/core/src/atlas/edgeRepair.ts
+++ b/packages/core/src/atlas/edgeRepair.ts
@@ -1,5 +1,8 @@
 import type { Polygon } from "../types";
 import type { Vec3 } from "../types";
+import { DEFAULT_TILE, RECT_EPS } from "./constants";
+import type { PolySeamBleed, SeamBleedInsets } from "./types";
+import { computeSurfaceNormal, cssPoints } from "./solidTriangle";
 
 function pointKey(point: Vec3): string {
   return `${point[0]},${point[1]},${point[2]}`;
@@ -36,3 +39,234 @@ export function buildTextureEdgeRepairSets(polygons: Polygon[]): Array<Set<numbe
   }
   return repairEdges.map((edges) => edges.size > 0 ? edges : undefined);
 }
+
+export function resolveSeamBleed(value: unknown, fallback: number): number {
+  return value === "auto"
+    ? fallback
+    : typeof value === "number" && Number.isFinite(value)
+      ? Math.max(0, value)
+      : fallback;
+}
+
+export function normalizedSeamBleed(value: unknown): PolySeamBleed | undefined {
+  if (value === "auto") return "auto";
+  return typeof value === "number" && Number.isFinite(value) && value > 0
+    ? value
+    : undefined;
+}
+
+export function safePlanSeamBleedAmount(
+  screenPts: number[],
+  edgeIndex: number,
+  requested: number,
+): number {
+  if (requested <= 0 || screenPts.length < 6 || screenPts.length % 2 !== 0) return 0;
+  const count = screenPts.length / 2;
+  if (edgeIndex < 0 || edgeIndex >= count) return 0;
+  const points: Array<[number, number]> = [];
+  for (let i = 0; i < screenPts.length; i += 2) {
+    points.push([screenPts[i], screenPts[i + 1]]);
+  }
+  const [ax, ay] = points[edgeIndex];
+  const [bx, by] = points[(edgeIndex + 1) % count];
+  const dx = bx - ax;
+  const dy = by - ay;
+  const length = Math.hypot(dx, dy);
+  if (length <= RECT_EPS) return 0;
+
+  const limits: number[] = [];
+  let oppositeClearance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < count; i += 1) {
+    if (i === edgeIndex || i === (edgeIndex + 1) % count) continue;
+    const [px, py] = points[i];
+    const distance = Math.abs((px - ax) * dy - (py - ay) * dx) / length;
+    if (distance > RECT_EPS) oppositeClearance = Math.min(oppositeClearance, distance);
+  }
+  if (Number.isFinite(oppositeClearance)) limits.push(oppositeClearance * 0.5);
+
+  const previous = points[(edgeIndex + count - 1) % count];
+  const next = points[(edgeIndex + 2) % count];
+  const previousDx = previous[0] - ax;
+  const previousDy = previous[1] - ay;
+  const nextDx = next[0] - bx;
+  const nextDy = next[1] - by;
+  const previousLength = Math.hypot(previousDx, previousDy);
+  const nextLength = Math.hypot(nextDx, nextDy);
+  if (previousLength > RECT_EPS) {
+    const sin = Math.abs(dx * previousDy - dy * previousDx) / (length * previousLength);
+    if (sin > RECT_EPS) limits.push(previousLength * sin);
+  }
+  if (nextLength > RECT_EPS) {
+    const sin = Math.abs((-dx) * nextDy - (-dy) * nextDx) / (length * nextLength);
+    if (sin > RECT_EPS) limits.push(nextLength * sin);
+  }
+
+  const finiteLimits = limits.filter((limit) => Number.isFinite(limit) && limit > 0);
+  if (finiteLimits.length === 0) return Number.isFinite(requested) ? Math.max(0, requested) : 0;
+  const fit = Math.min(...finiteLimits);
+  return Math.max(0, Math.min(Number.isFinite(requested) ? requested : fit, fit));
+}
+
+export function computePlanSeamBleedEdgeAmounts(
+  screenPts: number[],
+  seamEdges: ReadonlySet<number> | undefined,
+  seamBleed: PolySeamBleed | undefined,
+): Map<number, number> | undefined {
+  if (!seamEdges?.size || seamBleed === undefined) return undefined;
+  const amounts = new Map<number, number>();
+  const request = seamBleed === "auto" ? Number.POSITIVE_INFINITY : seamBleed;
+  for (const edgeIndex of seamEdges) {
+    const amount = safePlanSeamBleedAmount(screenPts, edgeIndex, request);
+    if (amount > 0) amounts.set(edgeIndex, amount);
+  }
+  return amounts.size > 0 ? amounts : undefined;
+}
+
+export function seamBleedAmountArray(
+  vertexCount: number,
+  edgeAmounts: ReadonlyMap<number, number> | undefined,
+): number[] | null {
+  if (vertexCount < 3 || !edgeAmounts?.size) return null;
+  return Array.from({ length: vertexCount }, (_, edgeIndex) =>
+    Math.max(0, edgeAmounts.get(edgeIndex) ?? 0)
+  );
+}
+
+export function computeSeamBleedInsets(
+  screenPts: number[],
+  edgeAmounts: ReadonlyMap<number, number> | undefined,
+): SeamBleedInsets | undefined {
+  if (!edgeAmounts?.size || screenPts.length < 6 || screenPts.length % 2 !== 0) {
+    return undefined;
+  }
+
+  const count = screenPts.length / 2;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < screenPts.length; i += 2) {
+    const x = screenPts[i];
+    const y = screenPts[i + 1];
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  if (!Number.isFinite(minX + minY + maxX + maxY)) return undefined;
+
+  const tol = Math.max(RECT_EPS * 8, 0.25);
+  const insets: SeamBleedInsets = { left: 0, right: 0, top: 0, bottom: 0 };
+  for (const [edgeIndex, edgeBleed] of edgeAmounts) {
+    const bleed = Math.max(0, edgeBleed);
+    if (bleed <= 0) continue;
+    if (edgeIndex < 0 || edgeIndex >= count) continue;
+    const aOffset = edgeIndex * 2;
+    const bOffset = ((edgeIndex + 1) % count) * 2;
+    const ax = screenPts[aOffset];
+    const ay = screenPts[aOffset + 1];
+    const bx = screenPts[bOffset];
+    const by = screenPts[bOffset + 1];
+    if (Math.abs(ax - bx) <= tol) {
+      if (Math.abs(ax - minX) <= tol && Math.abs(bx - minX) <= tol) {
+        insets.left = Math.max(insets.left, bleed);
+      } else if (Math.abs(ax - maxX) <= tol && Math.abs(bx - maxX) <= tol) {
+        insets.right = Math.max(insets.right, bleed);
+      }
+    } else if (Math.abs(ay - by) <= tol) {
+      if (Math.abs(ay - minY) <= tol && Math.abs(by - minY) <= tol) {
+        insets.top = Math.max(insets.top, bleed);
+      } else if (Math.abs(ay - maxY) <= tol && Math.abs(by - maxY) <= tol) {
+        insets.bottom = Math.max(insets.bottom, bleed);
+      }
+    }
+  }
+
+  return insets.left || insets.right || insets.top || insets.bottom
+    ? insets
+    : undefined;
+}
+
+interface SeamBleedSurfaceInfo {
+  normal: Vec3;
+  planeD: number;
+}
+
+interface SeamBleedDetectionOptions {
+  tileSize?: number;
+  layerElevation?: number;
+  directionalLight?: unknown;
+  ambientLight?: unknown;
+}
+
+function dotVec(a: Vec3, b: Vec3): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+function seamBleedSurfaceInfo(
+  polygon: Polygon,
+  tile: number,
+  elev: number,
+): SeamBleedSurfaceInfo | null {
+  if (!polygon.vertices || polygon.vertices.length < 3) return null;
+  const pts = cssPoints(polygon.vertices, tile, elev);
+  const normal = computeSurfaceNormal(pts);
+  if (!normal) return null;
+  return { normal, planeD: dotVec(normal, pts[0]) };
+}
+
+function compatibleSeamBleedMaterials(a: Polygon, b: Polygon): boolean {
+  return (a.material?.key ?? a.color ?? "") === (b.material?.key ?? b.color ?? "") &&
+    a.color === b.color;
+}
+
+export function buildSeamBleedPolygonSet(
+  polygons: Polygon[],
+  options: SeamBleedDetectionOptions = {},
+): Set<number> {
+  return new Set(buildSeamBleedPolygonEdges(polygons, options).keys());
+}
+
+export function buildSeamBleedPolygonEdges(
+  polygons: Polygon[],
+  options: SeamBleedDetectionOptions = {},
+): Map<number, Set<number>> {
+  const tile = options.tileSize ?? DEFAULT_TILE;
+  const elev = options.layerElevation ?? tile;
+  const infos = polygons.map((polygon) => seamBleedSurfaceInfo(polygon, tile, elev));
+  const edgeOwners = new Map<string, Array<{ polygon: number; edge: number }>>();
+  for (let polygonIndex = 0; polygonIndex < polygons.length; polygonIndex++) {
+    const vertices = polygons[polygonIndex].vertices;
+    if (!vertices || vertices.length < 3) continue;
+    for (let edgeIndex = 0; edgeIndex < vertices.length; edgeIndex++) {
+      const key = edgeKey(vertices[edgeIndex], vertices[(edgeIndex + 1) % vertices.length]);
+      const owners = edgeOwners.get(key);
+      const owner = { polygon: polygonIndex, edge: edgeIndex };
+      if (owners) owners.push(owner);
+      else edgeOwners.set(key, [owner]);
+    }
+  }
+
+  const seamEdges = new Map<number, Set<number>>();
+  const addSeamEdge = (polygonIndex: number, edgeIndex: number): void => {
+    const edges = seamEdges.get(polygonIndex);
+    if (edges) edges.add(edgeIndex);
+    else seamEdges.set(polygonIndex, new Set([edgeIndex]));
+  };
+  for (const owners of edgeOwners.values()) {
+    if (owners.length < 2) continue;
+    for (let i = 0; i < owners.length; i++) {
+      for (let j = i + 1; j < owners.length; j++) {
+        const aOwner = owners[i];
+        const bOwner = owners[j];
+        const a = aOwner.polygon;
+        const b = bOwner.polygon;
+        if (!infos[a] || !infos[b]) continue;
+        if (!compatibleSeamBleedMaterials(polygons[a], polygons[b])) continue;
+        addSeamEdge(a, aOwner.edge);
+        addSeamEdge(b, bOwner.edge);
+      }
+    }
+  }
+  return seamEdges;
+}
diff --git a/packages/core/src/atlas/matrix.ts b/packages/core/src/atlas/matrix.ts
index e0fb6024..b9403b33 100644
--- a/packages/core/src/atlas/matrix.ts
+++ b/packages/core/src/atlas/matrix.ts
@@ -171,10 +171,15 @@ export function formatBorderShapeMatrix(
 }
 
 export function formatSolidQuadMatrix(entry: TextureAtlasPlan): string {
+  const bleed = entry.seamBleedInsets ?? { left: 0, right: 0, top: 0, bottom: 0 };
+  const canvasW = entry.canvasW || 1;
+  const canvasH = entry.canvasH || 1;
   return formatScaledMatrixFromPlan(
     entry,
-    (entry.canvasW || 1) / SOLID_QUAD_CANONICAL_SIZE,
-    (entry.canvasH || 1) / SOLID_QUAD_CANONICAL_SIZE,
+    (canvasW + bleed.left + bleed.right) / SOLID_QUAD_CANONICAL_SIZE,
+    (canvasH + bleed.top + bleed.bottom) / SOLID_QUAD_CANONICAL_SIZE,
+    -bleed.left,
+    -bleed.top,
   );
 }
 
diff --git a/packages/core/src/atlas/plan.ts b/packages/core/src/atlas/plan.ts
index 88fe6006..f284f3d9 100644
--- a/packages/core/src/atlas/plan.ts
+++ b/packages/core/src/atlas/plan.ts
@@ -44,9 +44,16 @@ import {
   computeSurfaceNormal,
   isConvexPolygonPoints,
   offsetConvexPolygonPoints,
+  offsetConvexPolygonPointsByEdgeAmounts,
   stableBasisFromPlan,
 } from "./solidTriangle";
 import { textureTintFactors, shadePolygon } from "./paintDefaults";
+import {
+  computePlanSeamBleedEdgeAmounts,
+  computeSeamBleedInsets,
+  seamBleedAmountArray,
+  normalizedSeamBleed,
+} from "./edgeRepair";
 
 function finiteNumber(value: unknown, fallback: number): number {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
@@ -126,6 +133,7 @@ export function computeProjectiveQuadMatrix(
   ty: number,
   tz: number,
   guards: ProjectiveQuadGuardSettings,
+  seamBleedEdgeAmounts?: ReadonlyMap<number, number>,
 ): string | null {
   if (screenPts.length !== 8) return null;
   const rawQ: Array<[number, number]> = [
@@ -136,7 +144,10 @@ export function computeProjectiveQuadMatrix(
   ];
   if (!computeProjectiveQuadCoefficients(rawQ, guards)) return null;
 
-  const expandedPts = offsetConvexPolygonPoints(screenPts, guards.bleed);
+  const edgeAmounts = seamBleedAmountArray(4, seamBleedEdgeAmounts);
+  const expandedPts = edgeAmounts
+    ? offsetConvexPolygonPointsByEdgeAmounts(screenPts, edgeAmounts)
+    : offsetConvexPolygonPoints(screenPts, guards.bleed);
   const q: Array<[number, number]> = [
     [expandedPts[0], expandedPts[1]],
     [expandedPts[2], expandedPts[3]],
@@ -771,6 +782,19 @@ export function computeTextureAtlasPlan(
     normal[0], normal[1], normal[2], 0,
     tx, ty, tz, 1,
   ]);
+  const seamBleedRequest = normalizedSeamBleed(options.seamBleed);
+  const seamBleedEdgeAmounts = computePlanSeamBleedEdgeAmounts(
+    screenPts,
+    options.seamEdges ?? basisHint?.seamEdges,
+    seamBleedRequest,
+  );
+  const seamBleedEdges = seamBleedEdgeAmounts
+    ? new Set(seamBleedEdgeAmounts.keys())
+    : undefined;
+  const seamBleed = seamBleedEdgeAmounts
+    ? Math.max(...seamBleedEdgeAmounts.values())
+    : undefined;
+  const seamBleedInsets = computeSeamBleedInsets(screenPts, seamBleedEdgeAmounts);
   const projectiveMatrix = !texture && vertices.length === 4
     ? computeProjectiveQuadMatrix(
         screenPts,
@@ -781,6 +805,7 @@ export function computeTextureAtlasPlan(
         ty,
         tz,
         projectiveQuadGuards,
+        seamBleedEdgeAmounts,
       )
     : null;
 
@@ -834,6 +859,10 @@ export function computeTextureAtlasPlan(
     textureTriangles,
     textureEdgeRepairEdges,
     textureEdgeRepair,
+    seamBleed,
+    seamBleedEdges,
+    seamBleedEdgeAmounts,
+    seamBleedInsets,
     normal,
     textureTint,
     shadedColor,
@@ -861,8 +890,11 @@ export function computeTextureAtlasPlanPublic(
   projectiveQuadOverrides?: ProjectiveQuadGuardOverrides,
 ): TextureAtlasPlan | null {
   const projectiveQuadGuards = resolveProjectiveQuadGuards(projectiveQuadOverrides);
-  const basisHint: BasisHint | undefined = options.textureEdgeRepairEdges?.size
-    ? { seamEdges: new Set<number>(), textureEdgeRepairEdges: options.textureEdgeRepairEdges }
+  const basisHint: BasisHint | undefined = options.textureEdgeRepairEdges?.size || options.seamEdges?.size
+    ? {
+        seamEdges: options.seamEdges ?? new Set<number>(),
+        textureEdgeRepairEdges: options.textureEdgeRepairEdges,
+      }
     : undefined;
   return computeTextureAtlasPlan(polygon, index, options, projectiveQuadGuards, basisHint);
 }
diff --git a/packages/core/src/atlas/solidTriangle.ts b/packages/core/src/atlas/solidTriangle.ts
index 080bd489..3e90ac69 100644
--- a/packages/core/src/atlas/solidTriangle.ts
+++ b/packages/core/src/atlas/solidTriangle.ts
@@ -177,6 +177,72 @@ export function offsetConvexPolygonPoints(points: number[], amount: number): num
   return expanded;
 }
 
+export function offsetConvexPolygonPointsByEdgeAmounts(
+  points: number[],
+  amounts: readonly number[],
+): number[] {
+  if (points.length < 6 || points.length % 2 !== 0) return points;
+  const count = points.length / 2;
+  if (amounts.length !== count) return points;
+  const cleanAmounts = amounts.map((amount) =>
+    typeof amount === "number" && Number.isFinite(amount)
+      ? Math.max(0, amount)
+      : 0
+  );
+  const maxAmount = Math.max(0, ...cleanAmounts);
+  if (maxAmount <= 0) return points;
+  if (cleanAmounts.every((amount) => Math.abs(amount - cleanAmounts[0]) <= BASIS_EPS)) {
+    return offsetConvexPolygonPoints(points, cleanAmounts[0]);
+  }
+
+  const q: Array<[number, number]> = [];
+  for (let i = 0; i < points.length; i += 2) q.push([points[i], points[i + 1]]);
+  if (!isConvexPolygonPoints(q)) return points;
+
+  const area = signedArea2D(q);
+  if (Math.abs(area) <= BASIS_EPS) return points;
+  const outwardSign = area > 0 ? 1 : -1;
+  const offsetLines: Array<{ a: [number, number]; b: [number, number] }> = [];
+  for (let i = 0; i < q.length; i++) {
+    const a = q[i];
+    const b = q[(i + 1) % q.length];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const length = Math.hypot(dx, dy);
+    if (length <= BASIS_EPS) return points;
+    const amount = cleanAmounts[i];
+    const ox = outwardSign * (dy / length) * amount;
+    const oy = outwardSign * (-dx / length) * amount;
+    offsetLines.push({
+      a: [a[0] + ox, a[1] + oy],
+      b: [b[0] + ox, b[1] + oy],
+    });
+  }
+
+  const expanded: number[] = [];
+  const maxMiter = Math.max(2, maxAmount * 4);
+  for (let i = 0; i < q.length; i++) {
+    const prev = offsetLines[(i + q.length - 1) % q.length];
+    const next = offsetLines[i];
+    const intersection = intersect2DLines(prev.a, prev.b, next.a, next.b);
+    if (!intersection) return points;
+
+    const original = q[i];
+    const dx = intersection[0] - original[0];
+    const dy = intersection[1] - original[1];
+    const miter = Math.hypot(dx, dy);
+    if (miter > maxMiter) {
+      expanded.push(
+        original[0] + (dx / miter) * maxMiter,
+        original[1] + (dy / miter) * maxMiter,
+      );
+    } else {
+      expanded.push(intersection[0], intersection[1]);
+    }
+  }
+  return expanded;
+}
+
 export function offsetTrianglePoints(
   x0: number,
   y0: number,
diff --git a/packages/core/src/atlas/solidTrianglePlan.ts b/packages/core/src/atlas/solidTrianglePlan.ts
index 7a523aad..8f1ed1fc 100644
--- a/packages/core/src/atlas/solidTrianglePlan.ts
+++ b/packages/core/src/atlas/solidTrianglePlan.ts
@@ -29,11 +29,43 @@ import {
 } from "./paintDefaults";
 import {
   cssPoints,
+  offsetConvexPolygonPointsByEdgeAmounts,
   offsetStableTrianglePoints,
   stableTriangleMatrixDecimals,
 } from "./solidTriangle";
+import {
+  resolveSeamBleed,
+  safePlanSeamBleedAmount,
+} from "./edgeRepair";
 import { formatAffineMatrix3dTransformScalars } from "./matrix";
 
+function triangleEdgeIndexForPair(a: number, b: number): number | undefined {
+  if ((a + 1) % 3 === b) return a;
+  if ((b + 1) % 3 === a) return b;
+  return undefined;
+}
+
+function stableTriangleEdgeAmounts(
+  seamEdges: ReadonlySet<number> | undefined,
+  seamBleed: SolidTrianglePlanOptions["seamBleed"],
+  fallback: number,
+  a: number,
+  b: number,
+  c: number,
+  screenPts: number[],
+): number[] | null {
+  if (!seamEdges?.size) return null;
+  const seamAmount = seamBleed === "auto"
+    ? Number.POSITIVE_INFINITY
+    : resolveSeamBleed(seamBleed, fallback);
+  const edgePairs: Array<[number, number]> = [[c, a], [a, b], [b, c]];
+  return edgePairs.map(([from, to], localEdgeIndex) => {
+    const edgeIndex = triangleEdgeIndexForPair(from, to);
+    const requested = edgeIndex !== undefined && seamEdges.has(edgeIndex) ? seamAmount : 0;
+    return safePlanSeamBleedAmount(screenPts, localEdgeIndex, requested);
+  });
+}
+
 export function computeSolidTriangleColorPlanFromNormal(
   polygon: Polygon,
   index: number,
@@ -308,7 +340,24 @@ export function computeSolidTrianglePlanFromCssPoints(
 
   const left = Math.max(0, Math.min(baseLength, apexX));
   const right = Math.max(0, baseLength - left);
-  const expanded = offsetStableTrianglePoints(left, right, height, SOLID_TRIANGLE_BLEED);
+  const screenPts = [left, 0, 0, height, left + right, height];
+  const edgeAmounts = stableTriangleEdgeAmounts(
+    options.seamEdges,
+    options.seamBleed,
+    SOLID_TRIANGLE_BLEED,
+    a,
+    b,
+    c,
+    screenPts,
+  );
+  const expanded = edgeAmounts
+    ? offsetConvexPolygonPointsByEdgeAmounts(screenPts, edgeAmounts)
+    : offsetStableTrianglePoints(
+        left,
+        right,
+        height,
+        resolveSeamBleed(options.seamBleed, SOLID_TRIANGLE_BLEED),
+      );
   const apex2x = expanded[0];
   const apex2y = expanded[1];
   const baseLeft2x = expanded[2];
diff --git a/packages/core/src/atlas/types.ts b/packages/core/src/atlas/types.ts
index 279ae249..9f0100fa 100644
--- a/packages/core/src/atlas/types.ts
+++ b/packages/core/src/atlas/types.ts
@@ -44,6 +44,10 @@ export interface TextureAtlasPlan {
   textureTriangles: TextureTrianglePlan[] | null;
   textureEdgeRepairEdges: Set<number> | null;
   textureEdgeRepair: boolean;
+  seamBleed?: number;
+  seamBleedEdges?: Set<number>;
+  seamBleedEdgeAmounts?: Map<number, number>;
+  seamBleedInsets?: SeamBleedInsets;
   /** World-space surface normal — stable across light changes, used by dynamic mode. */
   normal: Vec3;
   textureTint: RGBFactors;
@@ -76,6 +80,11 @@ export interface CornerShapeGeometry {
 }
 
 export type TextureQuality = number | "auto";
+export type PolySeamBleed = number | "auto";
+export type PolySeamBleedEdgeValue = ReadonlySet<number> | ReadonlyMap<number, number>;
+export type PolySeamBleedEdges =
+  | ReadonlyMap<number, PolySeamBleedEdgeValue>
+  | readonly (PolySeamBleedEdgeValue | undefined)[];
 
 export type PolyRenderStrategy = "b" | "i" | "u";
 export type SolidTrianglePrimitive = "border" | "corner-bevel";
@@ -87,6 +96,13 @@ export interface PolyRenderStrategiesOption {
   disable?: readonly PolyRenderStrategy[];
 }
 
+export interface SeamBleedInsets {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+}
+
 export interface PackedTextureAtlasEntry extends TextureAtlasPlan {
   pageIndex: number;
   x: number;
@@ -259,6 +275,8 @@ export interface SolidTrianglePlanOptions {
   textureLighting?: import("../types").PolyTextureLightingMode;
   solidPaintDefaults?: SolidPaintDefaults;
   strategies?: PolyRenderStrategiesOption;
+  seamBleed?: PolySeamBleed;
+  seamEdges?: Set<number>;
 }
 
 /** Internal solid-triangle plan options (extends SolidTrianglePlanOptions). */
@@ -276,4 +294,6 @@ export interface ComputeTextureAtlasPlanOptions {
   ambientLight?: import("../types").PolyAmbientLight;
   /** Shared-edge set returned by {@link buildTextureEdgeRepairSets}. */
   textureEdgeRepairEdges?: Set<number>;
+  seamBleed?: PolySeamBleed;
+  seamEdges?: Set<number>;
 }
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 92b162ad..085d0ef3 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -95,6 +95,26 @@ export type {
   ApproximateMergeOptions,
   OptimizeMeshPolygonsOptions,
 } from "./merge/optimizePolygons";
+export {
+  DEFAULT_SEAM_FACET_SPLIT_OPTIONS,
+  DEFAULT_SEAM_OVERLAP_OPTIONS,
+  repairMeshSeams,
+  seamFacetSplitPolygons,
+  seamFacetSplitReport,
+  seamOverlapDiagnostics,
+  seamOverlapPolygons,
+  seamOverlapReport,
+} from "./merge/seamRepair";
+export type {
+  SeamFacetSplitCandidate,
+  SeamFacetSplitCandidateReason,
+  SeamFacetSplitOptions,
+  SeamFacetSplitReport,
+  SeamOverlapCandidate,
+  SeamOverlapCandidateKind,
+  SeamOverlapDiagnostics,
+  SeamOverlapOptions,
+} from "./merge/seamRepair";
 export { cullInteriorPolygons } from "./cull/cullInteriorPolygons";
 export type { CullInteriorOptions } from "./cull/cullInteriorPolygons";
 export {
@@ -225,6 +245,7 @@ export {
   PROJECTIVE_QUAD_DENOM_EPS,
   PROJECTIVE_QUAD_MAX_WEIGHT_RATIO,
   PROJECTIVE_QUAD_BLEED,
+  DEFAULT_SEAM_BLEED,
 } from "./atlas/constants";
 export type {
   RGB,
@@ -240,9 +261,13 @@ export type {
   CornerShapeRadius,
   CornerShapeGeometry,
   TextureQuality,
+  PolySeamBleed,
+  PolySeamBleedEdgeValue,
+  PolySeamBleedEdges,
   PolyRenderStrategy,
   SolidTrianglePrimitive,
   PolyRenderStrategiesOption,
+  SeamBleedInsets,
   PackedTextureAtlasEntry,
   PackedPage,
   PackingShelf,
@@ -286,7 +311,17 @@ export {
   formatCssLengthPx,
   formatSolidQuadEntryMatrix,
 } from "./atlas/matrix";
-export { buildTextureEdgeRepairSets } from "./atlas/edgeRepair";
+export {
+  buildTextureEdgeRepairSets,
+  resolveSeamBleed,
+  normalizedSeamBleed,
+  safePlanSeamBleedAmount,
+  computePlanSeamBleedEdgeAmounts,
+  seamBleedAmountArray,
+  computeSeamBleedInsets,
+  buildSeamBleedPolygonSet,
+  buildSeamBleedPolygonEdges,
+} from "./atlas/edgeRepair";
 export {
   cachedParsePureColor,
   parseHex,
@@ -326,6 +361,7 @@ export {
   intersect2DLinesRaw,
   expandClipPoints,
   offsetConvexPolygonPoints,
+  offsetConvexPolygonPointsByEdgeAmounts,
   offsetTrianglePoints,
   offsetStableTrianglePoints,
   stableBasisFromPlan,
diff --git a/packages/core/src/merge/optimizePolygons.test.ts b/packages/core/src/merge/optimizePolygons.test.ts
index 1c3c67fd..73f554a0 100644
--- a/packages/core/src/merge/optimizePolygons.test.ts
+++ b/packages/core/src/merge/optimizePolygons.test.ts
@@ -6,6 +6,7 @@ import type { Polygon, Vec3 } from "../types";
 import { parseGltf } from "../parser/parseGltf";
 import { parseObj } from "../parser/parseObj";
 import { bakeSolidTextureSamples } from "../parser/solidTextureSamples";
+import { DEFAULT_SEAM_FACET_SPLIT_OPTIONS } from "./seamRepair";
 import { optimizeMeshPolygons } from "./optimizePolygons";
 
 function rect(x0: number, y0: number, x1: number, y1: number): Polygon[] {
@@ -380,10 +381,10 @@ describe("optimizeMeshPolygons", () => {
     const lossy = optimizeMeshPolygons(raw, { meshResolution: "lossy" });
 
     expect(lossless).toHaveLength(10);
-    expect(lossy.length).toBeLessThanOrEqual(lossless.length);
+    expect(renderCost(lossy)).toBeLessThanOrEqual(renderCost(lossless) + 1e-9);
   });
 
-  it("keeps automatic lossy quality fallback under the exact lossless floor", async () => {
+  it("keeps automatic lossy seam repair within the split budget over the exact lossless floor", async () => {
     installSolidTextureEnv([10, 20, 30, 255]);
 
     for (const file of ["poly-pizza/arrow.glb", "poly-pizza/bucket.glb"]) {
@@ -395,8 +396,9 @@ describe("optimizeMeshPolygons", () => {
       const lossless = optimizeMeshPolygons(baked.polygons, { meshResolution: "lossless" });
       const lossy = optimizeMeshPolygons(baked.polygons, { meshResolution: "lossy" });
 
-      expect(lossy.length, file).toBeLessThanOrEqual(lossless.length);
-      expect(renderCost(lossy), file).toBeLessThanOrEqual(renderCost(lossless) + 1e-9);
+      expect(lossy.length, file).toBeLessThanOrEqual(
+        lossless.length + DEFAULT_SEAM_FACET_SPLIT_OPTIONS.budget,
+      );
     }
   });
 
@@ -439,8 +441,9 @@ describe("optimizeMeshPolygons", () => {
     const automatic = optimizeMeshPolygons(raw, { meshResolution: "lossy" });
 
     expect(forced.length).toBeLessThan(lossless.length);
-    expect(automatic.length).toBeGreaterThan(forced.length);
     expect(automatic.length).toBeLessThan(lossless.length);
+    expect(renderCost(automatic)).toBeLessThan(renderCost(lossless));
+    expect(polygonSignature(automatic)).not.toEqual(polygonSignature(forced));
   });
 
   it("keeps lossy pair-merge neighbor seams on shared geometry", () => {
diff --git a/packages/core/src/merge/optimizePolygons.ts b/packages/core/src/merge/optimizePolygons.ts
index 96920e35..67c79ce1 100644
--- a/packages/core/src/merge/optimizePolygons.ts
+++ b/packages/core/src/merge/optimizePolygons.ts
@@ -3,6 +3,7 @@ import { findOverlappingPolygonDuplicates } from "./dedupeOverlappingPolygons";
 import type { MeshResolution, Polygon, TextureTriangle, Vec2, Vec3 } from "../types";
 import { coverPlanarPolygons, type CoverPlanarPolygonsOptions } from "./coverPlanarPolygons";
 import { mergePolygons } from "./mergePolygons";
+import { repairMeshSeams } from "./seamRepair";
 
 const NORMALIZE_MAX_ANGLE_DEG = 3;
 const NORMALIZE_MAX_PLANE_DISPLACEMENT = 0.03;
@@ -253,6 +254,8 @@ export function optimizeMeshPolygons(
   options: OptimizeMeshPolygonsOptions = {},
 ): Polygon[] {
   const meshResolution = options.meshResolution ?? "lossy";
+  const finish = (candidate: Polygon[]): Polygon[] =>
+    meshResolution === "lossy" ? repairMeshSeams(candidate) : candidate;
   const preprocessCache: PreprocessCache = {};
   const baseline = preprocessModelPolygons(polygons, false, preprocessCache);
   let best = baseline;
@@ -277,13 +280,13 @@ export function optimizeMeshPolygons(
     if (losslessRectCovered !== baseline) acceptCandidate(losslessRectCovered);
   }
   const exactCostCeiling = bestCost;
-  if (meshResolution === "lossy" && (best.length <= 1 || bestCost <= 1 + 1e-9)) return best;
+  if (meshResolution === "lossy" && (best.length <= 1 || bestCost <= 1 + 1e-9)) return finish(best);
   if (
     meshResolution === "lossy" &&
     options.approximateMerge === undefined &&
     polygons.length >= LOSSY_AUTOMATIC_LOW_VALUE_SOURCE_MIN_POLYGONS &&
     bestCost <= LOSSY_AUTOMATIC_APPROXIMATE_LOW_VALUE_EXACT_COST
-  ) return best;
+  ) return finish(best);
 
   if (meshResolution === "lossy" && options.approximateMerge !== false) {
     const qualityCandidates: LossyQualityCandidate[] = [];
@@ -505,7 +508,7 @@ export function optimizeMeshPolygons(
       colorQuantizeCandidates.length === 0 &&
       shouldUseRectangulatedFastExit(baseline)
     ) {
-      return best;
+      return finish(best);
     }
 
     if (automaticApproximate) {
@@ -684,7 +687,7 @@ export function optimizeMeshPolygons(
     }
   }
 
-  return best;
+  return finish(best);
 }
 
 function lossyColorQuantizeCandidates(polygons: Polygon[], baseline?: Polygon[]): Polygon[][] {
diff --git a/packages/core/src/merge/seamRepair.ts b/packages/core/src/merge/seamRepair.ts
new file mode 100644
index 00000000..41514acf
--- /dev/null
+++ b/packages/core/src/merge/seamRepair.ts
@@ -0,0 +1,1706 @@
+import type { Polygon, Vec3 } from "../types";
+
+type Vec2 = [number, number];
+
+interface LocalBasis {
+  origin: Vec3;
+  xAxis: Vec3;
+  yAxis: Vec3;
+  local: Vec2[];
+  area: number;
+}
+
+interface PolygonMeta {
+  basis: LocalBasis | null;
+  cssPoints: Vec3[];
+  capacities: number[];
+  patchable: boolean;
+}
+
+interface EdgeRecord {
+  index: number;
+  polygon: number;
+  edge: number;
+  key: string;
+  a: Vec3;
+  b: Vec3;
+  length: number;
+  dir: Vec3;
+  normal: Vec3;
+  outward: Vec3;
+  capacity: number;
+  materialKey: string;
+  color?: string;
+}
+
+interface NearSeamInfo {
+  gap: number;
+  facingA: number;
+  facingB: number;
+  aStart: number;
+  aEnd: number;
+  bStart: number;
+  bEnd: number;
+  a0: Vec3;
+  a1: Vec3;
+  b0: Vec3;
+  b1: Vec3;
+}
+
+export type SeamOverlapCandidateKind = "true-gap" | "connected-facet" | "material-boundary";
+
+export interface SeamOverlapCandidate {
+  kind: SeamOverlapCandidateKind;
+  aPolygon: number;
+  aEdge: number;
+  bPolygon: number;
+  bEdge: number;
+  aColor?: string;
+  bColor?: string;
+  aMaterialKey: string;
+  bMaterialKey: string;
+  gapPx: number;
+  spanPx: number;
+  aStartPx: number;
+  aEndPx: number;
+  bStartPx: number;
+  bEndPx: number;
+  targetClosurePx: number;
+  appliedClosurePx: number;
+  residualGapPx: number;
+  residualTargetPx: number;
+}
+
+export interface SeamOverlapDiagnostics {
+  exactPairs: number;
+  nearPairs: number;
+  patchedPolygons: number;
+  patchedEdges: number;
+  maxMeasuredGapPx: number;
+  maxAppliedAmountPx: number;
+  unclosedPairs: number;
+  maxResidualGapPx: number;
+}
+
+interface SeamBuildResult {
+  edgeRepairs: Array<Map<number, EdgeRepairSegment[]>>;
+  diagnostics: SeamOverlapDiagnostics;
+  candidates?: SeamOverlapCandidate[];
+}
+
+interface EdgeRepairSegment {
+  start: number;
+  end: number;
+  amount: number;
+}
+
+export interface SeamOverlapOptions {
+  overlapPx?: number;
+  maxGapPx?: number;
+  capacityScale?: number;
+}
+
+export interface SeamFacetSplitOptions {
+  rotX?: number;
+  rotY?: number;
+  viewAware?: boolean;
+  passes?: number;
+  budget?: number;
+}
+
+export type SeamFacetSplitCandidateReason =
+  | "component-anchor"
+  | "global-outlier"
+  | "local-follow-up"
+  | "shared-polygon"
+  | "below-threshold";
+
+export interface SeamFacetSplitCandidate {
+  key: string;
+  aPolygon: number;
+  aEdge: number;
+  bPolygon: number;
+  bEdge: number;
+  color?: string;
+  materialKey: string;
+  lengthPx: number;
+  projectedLengthPx: number;
+  score: number;
+  normalRisk: number;
+  shapeRisk: number;
+  viewRisk: number;
+  component: number;
+  marginalCost: number;
+  selected: boolean;
+  reason: SeamFacetSplitCandidateReason;
+}
+
+export interface SeamFacetSplitReport {
+  candidates: SeamFacetSplitCandidate[];
+  selectedPolygons: number;
+  selectedEdges: number;
+  addedPolygons: number;
+}
+
+interface ResolvedSeamFacetSplitOptions {
+  rotX: number;
+  rotY: number;
+  viewAware: boolean;
+  passes: number;
+  budget: number;
+}
+
+interface ResolvedSeamOverlapOptions {
+  overlapPx: number;
+  maxGapPx: number;
+  capacityScale: number;
+}
+
+const DEFAULT_TILE = 50;
+const DEFAULT_SEAM_OVERLAP_PX = 2;
+const MAX_NEAR_SEAM_GAP_PX = 14;
+const MIN_RESIDUAL_PATCH_GAP_PX = 0.25;
+const SEAM_SPLIT_INTERNAL_OVERLAP_PX = 1.25;
+const SEAM_SPLIT_EDGE_OVERLAP_PX = 0.75;
+const DEFAULT_SEAM_SPLIT_BUDGET = 20;
+const MIN_PARALLEL_DOT = 0.985;
+const MIN_FACING_DOT = 0.5;
+const TRUE_GAP_OVERLAP_AMOUNT_RATIO = 0.175;
+const DEFAULT_TRUE_GAP_OVERLAP_PX = 1.25;
+const EPS = 1e-6;
+const TOPOLOGY_EPS = 1e-4;
+
+export const DEFAULT_SEAM_OVERLAP_OPTIONS = {
+  overlapPx: DEFAULT_TRUE_GAP_OVERLAP_PX,
+  maxGapPx: MAX_NEAR_SEAM_GAP_PX,
+  capacityScale: 1,
+} as const satisfies SeamOverlapOptions;
+
+export const DEFAULT_SEAM_FACET_SPLIT_OPTIONS = {
+  budget: DEFAULT_SEAM_SPLIT_BUDGET,
+} as const satisfies SeamFacetSplitOptions;
+
+function finiteOr(value: number | undefined, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function resolveSeamOverlapOptions(
+  options?: number | SeamOverlapOptions,
+): ResolvedSeamOverlapOptions {
+  if (typeof options === "number") {
+    return {
+      overlapPx: Math.max(0, options) * TRUE_GAP_OVERLAP_AMOUNT_RATIO,
+      maxGapPx: MAX_NEAR_SEAM_GAP_PX,
+      capacityScale: 1,
+    };
+  }
+
+  return {
+    overlapPx: Math.max(0, finiteOr(options?.overlapPx, DEFAULT_TRUE_GAP_OVERLAP_PX)),
+    maxGapPx: Math.max(0, finiteOr(options?.maxGapPx, MAX_NEAR_SEAM_GAP_PX)),
+    capacityScale: Math.max(0, finiteOr(options?.capacityScale, 1)),
+  };
+}
+
+function seamOverlapEnabled(
+  options: ResolvedSeamOverlapOptions,
+  rawOptions?: number | SeamOverlapOptions,
+): boolean {
+  if (typeof rawOptions === "number" && rawOptions <= 0) return false;
+  return options.maxGapPx > EPS && options.capacityScale > EPS;
+}
+
+function resolveSeamFacetSplitOptions(options?: SeamFacetSplitOptions): ResolvedSeamFacetSplitOptions {
+  return {
+    rotX: finiteOr(options?.rotX, 65),
+    rotY: finiteOr(options?.rotY, 45),
+    viewAware: options?.viewAware !== false,
+    passes: Math.max(1, Math.min(3, Math.round(finiteOr(options?.passes, 2)))),
+    budget: Math.max(0, Math.min(256, Math.round(finiteOr(options?.budget, DEFAULT_SEAM_SPLIT_BUDGET)))),
+  };
+}
+
+function cssPoints(vertices: Vec3[]): Vec3[] {
+  return vertices.map((v): Vec3 => [v[1] * DEFAULT_TILE, v[0] * DEFAULT_TILE, v[2] * DEFAULT_TILE]);
+}
+
+function fromCssPoint(point: Vec3): Vec3 {
+  return [point[1] / DEFAULT_TILE, point[0] / DEFAULT_TILE, point[2] / DEFAULT_TILE];
+}
+
+function pointKey(point: Vec3): string {
+  return `${point[0]},${point[1]},${point[2]}`;
+}
+
+function edgeKey(a: Vec3, b: Vec3): string {
+  const ak = pointKey(a);
+  const bk = pointKey(b);
+  return ak < bk ? `${ak}|${bk}` : `${bk}|${ak}`;
+}
+
+function add(a: Vec3, b: Vec3): Vec3 {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+
+function sub(a: Vec3, b: Vec3): Vec3 {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+
+function scale(a: Vec3, value: number): Vec3 {
+  return [a[0] * value, a[1] * value, a[2] * value];
+}
+
+function length(a: Vec3): number {
+  return Math.hypot(a[0], a[1], a[2]);
+}
+
+function normalize(a: Vec3): Vec3 | null {
+  const len = length(a);
+  return len > EPS ? [a[0] / len, a[1] / len, a[2] / len] : null;
+}
+
+function dot(a: Vec3, b: Vec3): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+function rotateCssVec3(v: Vec3, rxDeg: number, ryDeg: number, rzDeg: number): Vec3 {
+  const dx = (rxDeg * Math.PI) / 180;
+  const dy = (ryDeg * Math.PI) / 180;
+  const dz = (rzDeg * Math.PI) / 180;
+  let [x, y, z] = v;
+  if (dz !== 0) {
+    const c = Math.cos(dz), s = Math.sin(dz);
+    [x, y] = [x * c - y * s, x * s + y * c];
+  }
+  if (dy !== 0) {
+    const c = Math.cos(dy), s = Math.sin(dy);
+    [x, z] = [x * c + z * s, -x * s + z * c];
+  }
+  if (dx !== 0) {
+    const c = Math.cos(dx), s = Math.sin(dx);
+    [y, z] = [y * c - z * s, y * s + z * c];
+  }
+  return [x, y, z];
+}
+
+function cross(a: Vec3, b: Vec3): Vec3 {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+  ];
+}
+
+function surfaceNormal(points: Vec3[]): Vec3 | null {
+  if (points.length < 3) return null;
+  const origin = points[0];
+  const normal: Vec3 = [0, 0, 0];
+  for (let i = 1; i + 1 < points.length; i += 1) {
+    const a = sub(points[i], origin);
+    const b = sub(points[i + 1], origin);
+    const n = cross(a, b);
+    normal[0] -= n[0];
+    normal[1] -= n[1];
+    normal[2] -= n[2];
+  }
+  return normalize(normal);
+}
+
+function localBasis(points: Vec3[]): LocalBasis | null {
+  const origin = points[0];
+  const normal = surfaceNormal(points);
+  if (!normal) return null;
+
+  let rawXAxis: Vec3 | null = null;
+  for (let i = 0; i < points.length; i += 1) {
+    const edge = sub(points[(i + 1) % points.length], points[i]);
+    if (length(edge) > EPS) {
+      rawXAxis = edge;
+      break;
+    }
+  }
+  if (!rawXAxis) return null;
+
+  const projected = dot(rawXAxis, normal);
+  const xRaw: Vec3 = [
+    rawXAxis[0] - projected * normal[0],
+    rawXAxis[1] - projected * normal[1],
+    rawXAxis[2] - projected * normal[2],
+  ];
+  const xAxis = normalize(xRaw);
+  if (!xAxis) return null;
+  const yAxis = normalize(cross(normal, xAxis));
+  if (!yAxis) return null;
+
+  const local = points.map((point): Vec2 => {
+    const d = sub(point, origin);
+    return [dot(d, xAxis), dot(d, yAxis)];
+  });
+  const area = signedArea(local);
+  return Math.abs(area) > EPS ? { origin, xAxis, yAxis, local, area } : null;
+}
+
+function signedArea(points: Vec2[]): number {
+  let area = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    area += a[0] * b[1] - a[1] * b[0];
+  }
+  return area / 2;
+}
+
+function isWeaklyConvex(points: Vec2[]): boolean {
+  if (points.length < 3) return false;
+  let sign = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    const c = points[(i + 2) % points.length];
+    const crossValue = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
+    if (Math.abs(crossValue) <= EPS) continue;
+    const nextSign = Math.sign(crossValue);
+    if (sign === 0) sign = nextSign;
+    else if (nextSign !== sign) return false;
+  }
+  return true;
+}
+
+function edgeOutward2D(points: Vec2[], area: number, edgeIndex: number): Vec2 | null {
+  const a = points[edgeIndex];
+  const b = points[(edgeIndex + 1) % points.length];
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const edgeLength = Math.hypot(dx, dy);
+  if (edgeLength <= EPS) return null;
+  const outwardSign = area > 0 ? 1 : -1;
+  return [
+    outwardSign * (dy / edgeLength),
+    outwardSign * (-dx / edgeLength),
+  ];
+}
+
+function edgeOutward3D(basis: LocalBasis, edgeIndex: number): Vec3 | null {
+  const outward = edgeOutward2D(basis.local, basis.area, edgeIndex);
+  if (!outward) return null;
+  return normalize([
+    basis.xAxis[0] * outward[0] + basis.yAxis[0] * outward[1],
+    basis.xAxis[1] * outward[0] + basis.yAxis[1] * outward[1],
+    basis.xAxis[2] * outward[0] + basis.yAxis[2] * outward[1],
+  ]);
+}
+
+function edgeSafeCapacity(points: Vec2[], edgeIndex: number): number {
+  const count = points.length;
+  const a = points[edgeIndex];
+  const b = points[(edgeIndex + 1) % count];
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const edgeLength = Math.hypot(dx, dy);
+  if (edgeLength <= EPS) return 0;
+
+  const limits = [edgeLength * 0.24];
+  let oppositeClearance = Infinity;
+  for (let i = 0; i < count; i += 1) {
+    if (i === edgeIndex || i === (edgeIndex + 1) % count) continue;
+    const p = points[i];
+    const distance = Math.abs((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / edgeLength;
+    if (distance > EPS) oppositeClearance = Math.min(oppositeClearance, distance);
+  }
+  if (Number.isFinite(oppositeClearance)) limits.push(oppositeClearance * 0.32);
+
+  const adjacentChecks: Array<{ origin: Vec2; point: Vec2 }> = [
+    { origin: a, point: points[(edgeIndex + count - 1) % count] },
+    { origin: b, point: points[(edgeIndex + 2) % count] },
+  ];
+  for (const adjacent of adjacentChecks) {
+    const adx = adjacent.point[0] - adjacent.origin[0];
+    const ady = adjacent.point[1] - adjacent.origin[1];
+    const adjacentLength = Math.hypot(adx, ady);
+    if (adjacentLength <= EPS) continue;
+    const sin = Math.abs(dx * ady - dy * adx) / (edgeLength * adjacentLength);
+    if (sin > EPS) limits.push(adjacentLength * sin * 0.32);
+  }
+
+  return Math.max(0, Math.min(...limits.filter((value) => Number.isFinite(value) && value > 0)));
+}
+
+function buildPolygonMetas(polygons: Polygon[]): PolygonMeta[] {
+  return polygons.map((polygon): PolygonMeta => {
+    const css = cssPoints(polygon.vertices);
+    const basis = localBasis(css);
+    const patchable = !hasTexture(polygon) && !!basis && isWeaklyConvex(basis.local);
+    const capacities = patchable
+      ? basis!.local.map((_, edgeIndex) => edgeSafeCapacity(basis!.local, edgeIndex))
+      : [];
+    return {
+      basis,
+      cssPoints: css,
+      capacities,
+      patchable,
+    };
+  });
+}
+
+function hasTexture(polygon: Polygon): boolean {
+  return !!(polygon.texture || polygon.material?.texture || polygon.textureTriangles?.length);
+}
+
+function materialKey(polygon: Polygon): string {
+  return polygon.material?.key ?? polygon.color ?? "";
+}
+
+function polygonSurfaceArea(polygon: Polygon): number {
+  if (polygon.vertices.length < 3) return 0;
+  const origin = polygon.vertices[0];
+  let area = 0;
+  for (let i = 1; i + 1 < polygon.vertices.length; i += 1) {
+    area += length(cross(sub(polygon.vertices[i], origin), sub(polygon.vertices[i + 1], origin))) * 0.5;
+  }
+  return area;
+}
+
+function dominantSolidColor(polygons: Polygon[]): string | undefined {
+  const weights = new Map<string, number>();
+  for (const polygon of polygons) {
+    if (hasTexture(polygon) || !polygon.color) continue;
+    weights.set(polygon.color, (weights.get(polygon.color) ?? 0) + Math.max(polygonSurfaceArea(polygon), EPS));
+  }
+  let bestColor: string | undefined;
+  let bestWeight = 0;
+  for (const [color, weight] of weights) {
+    if (weight > bestWeight) {
+      bestColor = color;
+      bestWeight = weight;
+    }
+  }
+  return bestColor;
+}
+
+function buildEdgeRecords(
+  polygons: Polygon[],
+  metas: PolygonMeta[],
+  capacityScale: number,
+): EdgeRecord[] {
+  const records: EdgeRecord[] = [];
+  for (let polygonIndex = 0; polygonIndex < metas.length; polygonIndex += 1) {
+    const meta = metas[polygonIndex];
+    if (!meta.patchable || !meta.basis) continue;
+    for (let edgeIndex = 0; edgeIndex < meta.cssPoints.length; edgeIndex += 1) {
+      const a = meta.cssPoints[edgeIndex];
+      const b = meta.cssPoints[(edgeIndex + 1) % meta.cssPoints.length];
+      const edge = sub(b, a);
+      const edgeLength = length(edge);
+      const dir = normalize(edge);
+      const outward = edgeOutward3D(meta.basis, edgeIndex);
+      const normal = surfaceNormal(meta.cssPoints);
+      const capacity = (meta.capacities[edgeIndex] ?? 0) * capacityScale;
+      if (!dir || !outward || !normal || capacity <= EPS || edgeLength <= EPS) continue;
+      records.push({
+        index: records.length,
+        polygon: polygonIndex,
+        edge: edgeIndex,
+        key: edgeKey(a, b),
+        a,
+        b,
+        length: edgeLength,
+        dir,
+        normal,
+        outward,
+        capacity,
+        materialKey: materialKey(polygons[polygonIndex]),
+        color: polygons[polygonIndex].color,
+      });
+    }
+  }
+  return records;
+}
+
+function compatibleRepairMaterials(a: EdgeRecord, b: EdgeRecord): boolean {
+  return a.materialKey === b.materialKey && a.color === b.color;
+}
+
+function sameTopologyPoint(a: Vec3, b: Vec3): boolean {
+  return length(sub(a, b)) <= TOPOLOGY_EPS;
+}
+
+function edgeRecordsTouch(a: EdgeRecord, b: EdgeRecord): boolean {
+  return sameTopologyPoint(a.a, b.a) ||
+    sameTopologyPoint(a.a, b.b) ||
+    sameTopologyPoint(a.b, b.a) ||
+    sameTopologyPoint(a.b, b.b);
+}
+
+function classifyCandidate(a: EdgeRecord, b: EdgeRecord): SeamOverlapCandidateKind {
+  if (!compatibleRepairMaterials(a, b)) return "material-boundary";
+  return edgeRecordsTouch(a, b) ? "connected-facet" : "true-gap";
+}
+
+function seamOverlapCandidate(
+  kind: SeamOverlapCandidateKind,
+  a: EdgeRecord,
+  b: EdgeRecord,
+  info: NearSeamInfo,
+  targetClosurePx: number,
+  appliedClosurePx: number,
+): SeamOverlapCandidate {
+  return {
+    kind,
+    aPolygon: a.polygon,
+    aEdge: a.edge,
+    bPolygon: b.polygon,
+    bEdge: b.edge,
+    aColor: a.color,
+    bColor: b.color,
+    aMaterialKey: a.materialKey,
+    bMaterialKey: b.materialKey,
+    gapPx: info.gap,
+    spanPx: info.aEnd - info.aStart,
+    aStartPx: info.aStart,
+    aEndPx: info.aEnd,
+    bStartPx: info.bStart,
+    bEndPx: info.bEnd,
+    targetClosurePx,
+    appliedClosurePx,
+    residualGapPx: Math.max(0, info.gap - appliedClosurePx),
+    residualTargetPx: Math.max(0, targetClosurePx - appliedClosurePx),
+  };
+}
+
+function addEdgeRepair(
+  repairs: Array<Map<number, EdgeRepairSegment[]>>,
+  record: EdgeRecord,
+  start: number,
+  end: number,
+  amount: number,
+): void {
+  const clippedStart = Math.max(0, Math.min(record.length, Math.min(start, end)));
+  const clippedEnd = Math.max(0, Math.min(record.length, Math.max(start, end)));
+  if (amount <= EPS || clippedEnd - clippedStart <= EPS) return;
+  const current = repairs[record.polygon].get(record.edge);
+  const segment = { start: clippedStart, end: clippedEnd, amount };
+  if (current) current.push(segment);
+  else repairs[record.polygon].set(record.edge, [segment]);
+}
+
+function emptyDiagnostics(): SeamOverlapDiagnostics {
+  return {
+    exactPairs: 0,
+    nearPairs: 0,
+    patchedPolygons: 0,
+    patchedEdges: 0,
+    maxMeasuredGapPx: 0,
+    maxAppliedAmountPx: 0,
+    unclosedPairs: 0,
+    maxResidualGapPx: 0,
+  };
+}
+
+function finishDiagnostics(
+  repairs: Array<Map<number, EdgeRepairSegment[]>>,
+  diagnostics: SeamOverlapDiagnostics,
+): SeamOverlapDiagnostics {
+  let maxAppliedAmountPx = 0;
+  let patchedEdges = 0;
+  let patchedPolygons = 0;
+  for (const polygonRepairs of repairs) {
+    if (polygonRepairs.size > 0) patchedPolygons += 1;
+    patchedEdges += polygonRepairs.size;
+    for (const segments of polygonRepairs.values()) {
+      for (const segment of segments) {
+        maxAppliedAmountPx = Math.max(maxAppliedAmountPx, segment.amount);
+      }
+    }
+  }
+  return {
+    ...diagnostics,
+    patchedPolygons,
+    patchedEdges,
+    maxAppliedAmountPx,
+  };
+}
+
+function buildSeamEdgeAmounts(
+  polygons: Polygon[],
+  options: ResolvedSeamOverlapOptions,
+  collectCandidates = false,
+): SeamBuildResult {
+  const metas = buildPolygonMetas(polygons);
+  const records = buildEdgeRecords(polygons, metas, options.capacityScale);
+  const repairs = polygons.map(() => new Map<number, EdgeRepairSegment[]>());
+  const diagnostics = emptyDiagnostics();
+  const candidates = collectCandidates ? [] as SeamOverlapCandidate[] : undefined;
+  if (records.length === 0) {
+    return { edgeRepairs: repairs, diagnostics, candidates };
+  }
+
+  const edgeOwners = new Map<string, EdgeRecord[]>();
+  for (const record of records) {
+    const owners = edgeOwners.get(record.key);
+    if (owners) owners.push(record);
+    else edgeOwners.set(record.key, [record]);
+  }
+
+  for (const owners of edgeOwners.values()) {
+    if (owners.length < 2) continue;
+    diagnostics.exactPairs += owners.length === 2 ? 1 : owners.length;
+  }
+
+  buildNearSeamEdgeAmounts(records, edgeOwners, repairs, diagnostics, options, candidates);
+  return {
+    edgeRepairs: repairs,
+    diagnostics: finishDiagnostics(repairs, diagnostics),
+    candidates,
+  };
+}
+
+function buildNearSeamEdgeAmounts(
+  records: EdgeRecord[],
+  edgeOwners: ReadonlyMap<string, EdgeRecord[]>,
+  repairs: Array<Map<number, EdgeRepairSegment[]>>,
+  diagnostics: SeamOverlapDiagnostics,
+  options: ResolvedSeamOverlapOptions,
+  candidates: SeamOverlapCandidate[] | undefined,
+): void {
+  const maxGap = options.maxGapPx;
+  const cellSize = Math.max(MAX_NEAR_SEAM_GAP_PX * 2, maxGap * 2);
+  const cells = new Map<string, EdgeRecord[]>();
+  for (const record of records) {
+    for (const key of segmentCellKeys(record, cellSize, maxGap)) {
+      const bucket = cells.get(key);
+      if (bucket) bucket.push(record);
+      else cells.set(key, [record]);
+    }
+  }
+
+  for (const record of records) {
+    const seen = new Set<number>();
+    for (const queryKey of segmentCellKeys(record, cellSize, maxGap)) {
+      const bucket = cells.get(queryKey);
+      if (!bucket) continue;
+      for (const candidate of bucket) {
+        if (seen.has(candidate.index)) continue;
+        seen.add(candidate.index);
+        if (candidate.index <= record.index) continue;
+        if (candidate.polygon === record.polygon) continue;
+        if (record.key === candidate.key && (edgeOwners.get(record.key)?.length ?? 0) > 1) continue;
+        const info = nearSeamInfo(record, candidate, maxGap);
+        if (!info) continue;
+        const kind = classifyCandidate(record, candidate);
+        const targetClosure = info.gap + options.overlapPx;
+        if (kind === "material-boundary") {
+          candidates?.push(seamOverlapCandidate(kind, record, candidate, info, targetClosure, 0));
+          continue;
+        }
+
+        let remainingClosure = targetClosure;
+        if (remainingClosure <= MIN_RESIDUAL_PATCH_GAP_PX) {
+          candidates?.push(seamOverlapCandidate(kind, record, candidate, info, targetClosure, 0));
+          continue;
+        }
+
+        const maxClosureA = record.capacity * info.facingA;
+        const maxClosureB = candidate.capacity * info.facingB;
+        let closureA = Math.min(maxClosureA, remainingClosure / 2);
+        let closureB = Math.min(maxClosureB, remainingClosure / 2);
+        remainingClosure -= closureA + closureB;
+        if (remainingClosure > EPS) {
+          const extraA = Math.min(maxClosureA - closureA, remainingClosure);
+          closureA += extraA;
+          remainingClosure -= extraA;
+        }
+        if (remainingClosure > EPS) {
+          const extraB = Math.min(maxClosureB - closureB, remainingClosure);
+          closureB += extraB;
+          remainingClosure -= extraB;
+        }
+
+        const appliedClosure = closureA + closureB;
+        candidates?.push(seamOverlapCandidate(kind, record, candidate, info, targetClosure, appliedClosure));
+        if (closureA > EPS) addEdgeRepair(repairs, record, info.aStart, info.aEnd, closureA / info.facingA);
+        if (closureB > EPS) addEdgeRepair(repairs, candidate, info.bStart, info.bEnd, closureB / info.facingB);
+        diagnostics.nearPairs += 1;
+        diagnostics.maxMeasuredGapPx = Math.max(diagnostics.maxMeasuredGapPx, info.gap);
+        if (remainingClosure > MIN_RESIDUAL_PATCH_GAP_PX) {
+          diagnostics.unclosedPairs += 1;
+          diagnostics.maxResidualGapPx = Math.max(diagnostics.maxResidualGapPx, remainingClosure);
+        }
+      }
+    }
+  }
+}
+
+function cellCoords(point: Vec3, cellSize: number): [number, number, number] {
+  return [
+    Math.floor(point[0] / cellSize),
+    Math.floor(point[1] / cellSize),
+    Math.floor(point[2] / cellSize),
+  ];
+}
+
+function segmentCellKeys(record: EdgeRecord, cellSize: number, padding: number): string[] {
+  const minX = Math.min(record.a[0], record.b[0]) - padding;
+  const minY = Math.min(record.a[1], record.b[1]) - padding;
+  const minZ = Math.min(record.a[2], record.b[2]) - padding;
+  const maxX = Math.max(record.a[0], record.b[0]) + padding;
+  const maxY = Math.max(record.a[1], record.b[1]) + padding;
+  const maxZ = Math.max(record.a[2], record.b[2]) + padding;
+  const [minCx, minCy, minCz] = cellCoords([minX, minY, minZ], cellSize);
+  const [maxCx, maxCy, maxCz] = cellCoords([maxX, maxY, maxZ], cellSize);
+  const keys: string[] = [];
+  for (let x = minCx; x <= maxCx; x += 1) {
+    for (let y = minCy; y <= maxCy; y += 1) {
+      for (let z = minCz; z <= maxCz; z += 1) {
+        keys.push(`${x},${y},${z}`);
+      }
+    }
+  }
+  return keys;
+}
+
+function nearSeamInfo(a: EdgeRecord, b: EdgeRecord, maxGap: number): NearSeamInfo | null {
+  if (Math.abs(dot(a.dir, b.dir)) < MIN_PARALLEL_DOT) return null;
+
+  const bStart = dot(sub(b.a, a.a), a.dir);
+  const bEnd = dot(sub(b.b, a.a), a.dir);
+  const overlapStart = Math.max(0, Math.min(bStart, bEnd));
+  const overlapEnd = Math.min(a.length, Math.max(bStart, bEnd));
+  const overlap = overlapEnd - overlapStart;
+  const minLength = Math.min(a.length, b.length);
+  if (overlap < Math.max(0.75, minLength * 0.12)) return null;
+
+  const a0 = add(a.a, scale(a.dir, overlapStart));
+  const a1 = add(a.a, scale(a.dir, overlapEnd));
+  const aPoint = add(a.a, scale(a.dir, (overlapStart + overlapEnd) / 2));
+  const bT = Math.max(0, Math.min(b.length, dot(sub(aPoint, b.a), b.dir)));
+  const bPoint = add(b.a, scale(b.dir, bT));
+  const gapVector = sub(bPoint, aPoint);
+  const gap = length(gapVector);
+  if (gap <= EPS) return null;
+  if (gap > maxGap) return null;
+  if (gap > Math.min(maxGap, Math.max(4, minLength * 0.28))) return null;
+
+  const gapDir = scale(gapVector, 1 / gap);
+  const facingA = dot(a.outward, gapDir);
+  const facingB = dot(b.outward, scale(gapDir, -1));
+  if (facingA < MIN_FACING_DOT || facingB < MIN_FACING_DOT) return null;
+  const b0T = Math.max(0, Math.min(b.length, dot(sub(a0, b.a), b.dir)));
+  const b1T = Math.max(0, Math.min(b.length, dot(sub(a1, b.a), b.dir)));
+  const b0 = add(b.a, scale(b.dir, b0T));
+  const b1 = add(b.a, scale(b.dir, b1T));
+  return {
+    gap,
+    facingA,
+    facingB,
+    aStart: overlapStart,
+    aEnd: overlapEnd,
+    bStart: Math.min(b0T, b1T),
+    bEnd: Math.max(b0T, b1T),
+    a0,
+    a1,
+    b0,
+    b1,
+  };
+}
+
+function repairPoint(a: Vec2, b: Vec2, edgeLength: number, distance: number): Vec2 {
+  const t = edgeLength <= EPS ? 0 : Math.max(0, Math.min(1, distance / edgeLength));
+  return [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+  ];
+}
+
+function pushUniquePoint(points: Vec2[], point: Vec2): void {
+  const last = points[points.length - 1];
+  if (last && Math.hypot(last[0] - point[0], last[1] - point[1]) <= EPS) return;
+  points.push(point);
+}
+
+function normalizeRepairSegments(
+  segments: EdgeRepairSegment[] | undefined,
+  edgeLength: number,
+  capacity: number,
+): EdgeRepairSegment[] {
+  if (!segments?.length || edgeLength <= EPS || capacity <= EPS) return [];
+  const stops = new Set<number>([0, edgeLength]);
+  for (const segment of segments) {
+    const start = Math.max(0, Math.min(edgeLength, segment.start));
+    const end = Math.max(0, Math.min(edgeLength, segment.end));
+    if (end - start <= EPS || segment.amount <= EPS) continue;
+    stops.add(start);
+    stops.add(end);
+  }
+
+  const sortedStops = Array.from(stops).sort((a, b) => a - b);
+  const normalized: EdgeRepairSegment[] = [];
+  for (let i = 0; i + 1 < sortedStops.length; i += 1) {
+    const start = sortedStops[i];
+    const end = sortedStops[i + 1];
+    if (end - start <= EPS) continue;
+    const mid = (start + end) / 2;
+    let amount = 0;
+    for (const segment of segments) {
+      if (mid + EPS < segment.start || mid - EPS > segment.end) continue;
+      amount = Math.max(amount, segment.amount);
+    }
+    const safeAmount = Math.min(capacity, amount);
+    if (safeAmount > EPS) normalized.push({ start, end, amount: safeAmount });
+  }
+  return normalized;
+}
+
+function isValidRepairedPolygon(source: Vec2[], repaired: Vec2[]): boolean {
+  if (repaired.length < 3) return false;
+  const sourceArea = signedArea(source);
+  const repairedArea = signedArea(repaired);
+  return Math.sign(repairedArea) === Math.sign(sourceArea) && Math.abs(repairedArea) >= Math.abs(sourceArea) - EPS;
+}
+
+function patchPolygon(
+  polygon: Polygon,
+  edgeRepairs: ReadonlyMap<number, EdgeRepairSegment[]>,
+  capacityScale: number,
+): Polygon {
+  if (edgeRepairs.size === 0 || polygon.vertices.length < 3) return polygon;
+  if (hasTexture(polygon)) return polygon;
+
+  const points = cssPoints(polygon.vertices);
+  const basis = localBasis(points);
+  if (!basis || !isWeaklyConvex(basis.local)) return polygon;
+
+  const repaired: Vec2[] = [];
+  for (let edgeIndex = 0; edgeIndex < basis.local.length; edgeIndex += 1) {
+    const a = basis.local[edgeIndex];
+    const b = basis.local[(edgeIndex + 1) % basis.local.length];
+    const edgeLength = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const outward = edgeOutward2D(basis.local, basis.area, edgeIndex);
+    if (!outward || edgeLength <= EPS) return polygon;
+    const segments = normalizeRepairSegments(
+      edgeRepairs.get(edgeIndex),
+      edgeLength,
+      edgeSafeCapacity(basis.local, edgeIndex) * capacityScale,
+    );
+
+    pushUniquePoint(repaired, a);
+    let cursor = 0;
+    for (const segment of segments) {
+      if (segment.start > cursor + EPS) {
+        pushUniquePoint(repaired, repairPoint(a, b, edgeLength, segment.start));
+      }
+
+      const start = repairPoint(a, b, edgeLength, segment.start);
+      const end = repairPoint(a, b, edgeLength, segment.end);
+      pushUniquePoint(repaired, [
+        start[0] + outward[0] * segment.amount,
+        start[1] + outward[1] * segment.amount,
+      ]);
+      pushUniquePoint(repaired, [
+        end[0] + outward[0] * segment.amount,
+        end[1] + outward[1] * segment.amount,
+      ]);
+      if (segment.end < edgeLength - EPS) pushUniquePoint(repaired, end);
+      cursor = segment.end;
+    }
+  }
+
+  const first = repaired[0];
+  const last = repaired[repaired.length - 1];
+  if (first && last && Math.hypot(first[0] - last[0], first[1] - last[1]) <= EPS) repaired.pop();
+  if (!isValidRepairedPolygon(basis.local, repaired)) return polygon;
+
+  const vertices = repaired.map(([x, y]) => fromCssPoint([
+    basis.origin[0] + x * basis.xAxis[0] + y * basis.yAxis[0],
+    basis.origin[1] + x * basis.xAxis[1] + y * basis.yAxis[1],
+    basis.origin[2] + x * basis.xAxis[2] + y * basis.yAxis[2],
+  ]));
+  return { ...polygon, vertices };
+}
+
+function isRefinableSeamQuad(polygon: Polygon): boolean {
+  return polygon.vertices.length === 4 && !hasTexture(polygon);
+}
+
+function quadShapeRisk(meta: PolygonMeta): number {
+  const local = meta.basis?.local;
+  if (!local || local.length !== 4) return 1;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of local) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  const bboxArea = Math.max(EPS, (maxX - minX) * (maxY - minY));
+  const fillRatio = Math.max(0, Math.min(1, Math.abs(meta.basis?.area ?? 0) / bboxArea));
+  return 0.75 + (1 - fillRatio) * 2.5;
+}
+
+function cssDistance(a: Vec3, b: Vec3): number {
+  return length(sub(cssPoints([a])[0], cssPoints([b])[0]));
+}
+
+function triangleQuality(a: Vec3, b: Vec3, c: Vec3): number {
+  const ab = cssDistance(a, b);
+  const bc = cssDistance(b, c);
+  const ca = cssDistance(c, a);
+  const longest = Math.max(ab, bc, ca);
+  if (longest <= EPS) return 0;
+  const area = length(cross(sub(cssPoints([b])[0], cssPoints([a])[0]), sub(cssPoints([c])[0], cssPoints([a])[0]))) * 0.5;
+  return area / (longest * longest);
+}
+
+function intersectLocalLines(a0: Vec2, a1: Vec2, b0: Vec2, b1: Vec2): Vec2 | null {
+  const rx = a1[0] - a0[0];
+  const ry = a1[1] - a0[1];
+  const sx = b1[0] - b0[0];
+  const sy = b1[1] - b0[1];
+  const det = rx * sy - ry * sx;
+  if (Math.abs(det) <= EPS) return null;
+  const qpx = b0[0] - a0[0];
+  const qpy = b0[1] - a0[1];
+  const t = (qpx * sy - qpy * sx) / det;
+  return [a0[0] + t * rx, a0[1] + t * ry];
+}
+
+function offsetLocalConvexPointsByEdgeAmounts(points: Vec2[], amounts: number[]): Vec2[] | null {
+  if (points.length < 3 || points.length !== amounts.length) return null;
+  const maxAmount = Math.max(0, ...amounts);
+  if (maxAmount <= EPS) return points;
+  const area = signedArea(points);
+  if (Math.abs(area) <= EPS) return null;
+  const outwardSign = area > 0 ? 1 : -1;
+  const offsetLines: Array<{ a: Vec2; b: Vec2 }> = [];
+  for (let i = 0; i < points.length; i += 1) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const edgeLength = Math.hypot(dx, dy);
+    if (edgeLength <= EPS) return null;
+    const amount = Math.max(0, amounts[i]);
+    const ox = outwardSign * (dy / edgeLength) * amount;
+    const oy = outwardSign * (-dx / edgeLength) * amount;
+    offsetLines.push({
+      a: [a[0] + ox, a[1] + oy],
+      b: [b[0] + ox, b[1] + oy],
+    });
+  }
+
+  const expanded: Vec2[] = [];
+  const maxMiter = Math.max(2, maxAmount * 4);
+  for (let i = 0; i < points.length; i += 1) {
+    const prev = offsetLines[(i + points.length - 1) % points.length];
+    const next = offsetLines[i];
+    const intersection = intersectLocalLines(prev.a, prev.b, next.a, next.b);
+    if (!intersection) return null;
+    const original = points[i];
+    const dx = intersection[0] - original[0];
+    const dy = intersection[1] - original[1];
+    const miter = Math.hypot(dx, dy);
+    expanded.push(
+      miter > maxMiter
+        ? [original[0] + (dx / miter) * maxMiter, original[1] + (dy / miter) * maxMiter]
+        : intersection,
+    );
+  }
+  return expanded;
+}
+
+function cssPointFromLocal(basis: LocalBasis, point: Vec2): Vec3 {
+  return [
+    basis.origin[0] + basis.xAxis[0] * point[0] + basis.yAxis[0] * point[1],
+    basis.origin[1] + basis.xAxis[1] * point[0] + basis.yAxis[1] * point[1],
+    basis.origin[2] + basis.xAxis[2] * point[0] + basis.yAxis[2] * point[1],
+  ];
+}
+
+function offsetTriangleVertices(vertices: Vec3[], amounts: [number, number, number]): Vec3[] {
+  const basis = localBasis(cssPoints(vertices));
+  if (!basis) return vertices;
+  const expanded = offsetLocalConvexPointsByEdgeAmounts(basis.local, amounts);
+  return expanded
+    ? expanded.map((point) => fromCssPoint(cssPointFromLocal(basis, point)))
+    : vertices;
+}
+
+function splitQuadIntoTriangles(polygon: Polygon, edges: ReadonlySet<number>): Polygon[] {
+  const solid: Polygon = { ...polygon, uvs: undefined, textureTriangles: undefined };
+  const [a, b, c, d] = polygon.vertices;
+  const acQuality = Math.min(triangleQuality(a, b, c), triangleQuality(a, c, d));
+  const bdQuality = Math.min(triangleQuality(a, b, d), triangleQuality(b, c, d));
+  const seamAmount = (edge: number): number => edges.has(edge) ? SEAM_SPLIT_EDGE_OVERLAP_PX : 0;
+  return acQuality >= bdQuality
+    ? [
+        { ...solid, vertices: offsetTriangleVertices([a, b, c], [seamAmount(0), seamAmount(1), SEAM_SPLIT_INTERNAL_OVERLAP_PX]) },
+        { ...solid, vertices: offsetTriangleVertices([a, c, d], [SEAM_SPLIT_INTERNAL_OVERLAP_PX, seamAmount(2), seamAmount(3)]) },
+      ]
+    : [
+        { ...solid, vertices: offsetTriangleVertices([a, b, d], [seamAmount(0), SEAM_SPLIT_INTERNAL_OVERLAP_PX, seamAmount(3)]) },
+        { ...solid, vertices: offsetTriangleVertices([b, c, d], [seamAmount(1), seamAmount(2), SEAM_SPLIT_INTERNAL_OVERLAP_PX]) },
+      ];
+}
+
+interface SeamFacetSplitCandidateInternal {
+  key: string;
+  owners: EdgeRecord[];
+  records: EdgeRecord[];
+  length: number;
+  rankLength: number;
+  projectedLength: number;
+  score: number;
+  normalRisk: number;
+  shapeRisk: number;
+  viewRisk: number;
+  component: number;
+  selected: boolean;
+  reason: SeamFacetSplitCandidateReason;
+  marginalCost: number;
+}
+
+interface SeamFacetSplitPlan {
+  selected: Map<number, Set<number>>;
+  candidates: SeamFacetSplitCandidateInternal[];
+  budgetLimit: number;
+}
+
+interface SeamFacetSplitFollowUpContext {
+  endpoints: ReadonlySet<string>;
+}
+
+type SeamFacetSplitSelectionMode = "primary" | "follow-up";
+
+interface SeamFacetSplitBudgetPlan {
+  budgetLimit: number;
+  componentBudgets: ReadonlyMap<number, number> | null;
+}
+
+interface NumericDistribution {
+  q1: number;
+  median: number;
+  q3: number;
+  p70: number;
+  p80: number;
+  p88: number;
+  p95: number;
+  p97: number;
+  max: number;
+}
+
+function numericDistribution(values: number[]): NumericDistribution {
+  if (values.length === 0) {
+    return {
+      q1: Infinity,
+      median: Infinity,
+      q3: Infinity,
+      p70: Infinity,
+      p80: Infinity,
+      p88: Infinity,
+      p95: Infinity,
+      p97: Infinity,
+      max: Infinity,
+    };
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const at = (ratio: number) => sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * ratio))] ?? 0;
+  return {
+    q1: at(0.25),
+    median: at(0.5),
+    q3: at(0.75),
+    p70: at(0.7),
+    p80: at(0.8),
+    p88: at(0.88),
+    p95: at(0.95),
+    p97: at(0.97),
+    max: sorted[sorted.length - 1] ?? 0,
+  };
+}
+
+class UnionFind {
+  private parents: number[];
+
+  constructor(size: number) {
+    this.parents = Array.from({ length: size }, (_, index) => index);
+  }
+
+  find(index: number): number {
+    const parent = this.parents[index];
+    if (parent === index) return index;
+    const root = this.find(parent);
+    this.parents[index] = root;
+    return root;
+  }
+
+  union(a: number, b: number): void {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+    if (rootA !== rootB) this.parents[rootB] = rootA;
+  }
+}
+
+function splitCandidateEndpointKeys(candidate: SeamFacetSplitCandidateInternal): string[] {
+  const first = candidate.records[0];
+  if (!first) return [];
+  return [pointKey(first.a), pointKey(first.b)];
+}
+
+function splitPlanFollowUpContext(candidates: SeamFacetSplitCandidateInternal[]): SeamFacetSplitFollowUpContext {
+  const endpoints = new Set<string>();
+  const components = new Set<number>();
+  for (const candidate of candidates) {
+    if (!candidate.selected) continue;
+    components.add(candidate.component);
+  }
+  for (const candidate of candidates) {
+    if (!components.has(candidate.component)) continue;
+    for (const endpoint of splitCandidateEndpointKeys(candidate)) endpoints.add(endpoint);
+  }
+  return { endpoints };
+}
+
+function splitCandidateTouchesFollowUp(
+  candidate: SeamFacetSplitCandidateInternal,
+  context: SeamFacetSplitFollowUpContext | undefined,
+): boolean {
+  if (!context) return true;
+  return splitCandidateEndpointKeys(candidate).some((endpoint) => context.endpoints.has(endpoint));
+}
+
+function buildSeamFacetSplitCandidates(
+  polygons: Polygon[],
+  metas: PolygonMeta[],
+  edgeOwners: ReadonlyMap<string, EdgeRecord[]>,
+  splitOptions: ResolvedSeamFacetSplitOptions,
+): SeamFacetSplitCandidateInternal[] {
+  const candidates: SeamFacetSplitCandidateInternal[] = [];
+  for (const [key, owners] of edgeOwners) {
+    if (owners.length !== 2) continue;
+    const [a, b] = owners;
+    if (!compatibleRepairMaterials(a, b)) continue;
+    const refinable = owners.filter((record) => isRefinableSeamQuad(polygons[record.polygon]));
+    if (refinable.length === 0) continue;
+
+    const normalRisk = 1 - Math.min(1, Math.abs(dot(a.normal, b.normal)));
+    const seamLength = Math.max(a.length, b.length);
+    if (normalRisk < 0.01 && seamLength < 64) continue;
+
+    const shapeRisk = Math.max(...refinable.map((record) => quadShapeRisk(metas[record.polygon])));
+    const bothSidesRefinable = refinable.length === 2 ? 1.18 : 1;
+    const seamRisk = Math.max(0.08, normalRisk);
+    const projected = splitOptions.viewAware
+      ? splitCandidateViewMetrics(a, b, splitOptions.rotX, splitOptions.rotY)
+      : { projectedLength: seamLength, viewRisk: 1 };
+    const rankLength = splitOptions.viewAware ? Math.max(projected.projectedLength, seamLength * 0.12) : seamLength;
+    const viewWeight = splitOptions.viewAware ? 0.18 + projected.viewRisk * 1.82 : 1;
+    candidates.push({
+      key,
+      owners,
+      records: refinable,
+      length: seamLength,
+      rankLength,
+      projectedLength: projected.projectedLength,
+      score: rankLength * (0.58 + seamRisk * 2.8) * shapeRisk * bothSidesRefinable * viewWeight,
+      normalRisk,
+      shapeRisk,
+      viewRisk: projected.viewRisk,
+      component: -1,
+      selected: false,
+      reason: "below-threshold",
+      marginalCost: refinable.length,
+    });
+  }
+
+  const union = new UnionFind(candidates.length);
+  const byEndpoint = new Map<string, number>();
+  for (let index = 0; index < candidates.length; index += 1) {
+    for (const endpoint of splitCandidateEndpointKeys(candidates[index])) {
+      const previous = byEndpoint.get(endpoint);
+      if (previous !== undefined) union.union(previous, index);
+      else byEndpoint.set(endpoint, index);
+    }
+  }
+
+  const componentIds = new Map<number, number>();
+  for (let index = 0; index < candidates.length; index += 1) {
+    const root = union.find(index);
+    let component = componentIds.get(root);
+    if (component === undefined) {
+      component = componentIds.size;
+      componentIds.set(root, component);
+    }
+    candidates[index].component = component;
+  }
+
+  return candidates;
+}
+
+function splitCandidateViewMetrics(
+  a: EdgeRecord,
+  b: EdgeRecord,
+  rotX: number,
+  rotY: number,
+): { projectedLength: number; viewRisk: number } {
+  const p0 = rotateCssVec3(a.a, rotX, 0, rotY);
+  const p1 = rotateCssVec3(a.b, rotX, 0, rotY);
+  const projectedLength = Math.hypot(p1[0] - p0[0], p1[1] - p0[1]);
+  const depthA = rotateCssVec3(a.normal, rotX, 0, rotY)[2];
+  const depthB = rotateCssVec3(b.normal, rotX, 0, rotY)[2];
+  const frontness = Math.max(0, depthA, depthB);
+  const silhouette = Math.min(1, Math.abs(depthA - depthB));
+  return {
+    projectedLength,
+    viewRisk: Math.max(0.04, Math.min(1, frontness * 0.85 + silhouette * 0.45)),
+  };
+}
+
+function strongestCandidatesByComponent(
+  candidates: SeamFacetSplitCandidateInternal[],
+): Set<SeamFacetSplitCandidateInternal> {
+  const strongest = new Map<number, SeamFacetSplitCandidateInternal>();
+  for (const candidate of candidates) {
+    const current = strongest.get(candidate.component);
+    if (!current || candidate.score > current.score || (candidate.score === current.score && candidate.length > current.length)) {
+      strongest.set(candidate.component, candidate);
+    }
+  }
+  return new Set(strongest.values());
+}
+
+function splitCandidateBudgetPriority(candidate: SeamFacetSplitCandidateInternal): number {
+  const coplanar = Math.max(0, 1 - Math.min(1, candidate.normalRisk));
+  const coplanarWeight = 0.35 + coplanar * coplanar * coplanar * 3.65;
+  const oneSidedWeight = candidate.records.length === 1 ? 1.08 : 1;
+  return (candidate.rankLength * coplanarWeight * oneSidedWeight) / Math.sqrt(Math.max(1, candidate.records.length));
+}
+
+function splitCandidateLikelyCrackPriority(candidate: SeamFacetSplitCandidateInternal): number {
+  const coplanar = Math.max(0, 1 - Math.min(1, candidate.normalRisk));
+  const visibleWeight = 0.35 + Math.min(1, candidate.viewRisk) * 1.65;
+  const shapeWeight = 0.7 + Math.min(2.6, candidate.shapeRisk) * 0.3;
+  const oneSidedWeight = candidate.records.length === 1 ? 1.1 : 1;
+  const visiblePriority = (
+    candidate.rankLength *
+    (0.6 + coplanar * coplanar * 1.4) *
+    visibleWeight *
+    shapeWeight *
+    oneSidedWeight
+  ) / Math.sqrt(Math.max(1, candidate.records.length));
+  return Math.max(visiblePriority, splitCandidateBudgetPriority(candidate) * 0.75);
+}
+
+function uniqueSplitPolygonCost(candidates: SeamFacetSplitCandidateInternal[]): number {
+  const polygons = new Set<number>();
+  for (const candidate of candidates) {
+    for (const record of candidate.records) polygons.add(record.polygon);
+  }
+  return polygons.size;
+}
+
+function splitCandidateLikelyCrack(candidate: SeamFacetSplitCandidateInternal, lengthStats: NumericDistribution): boolean {
+  return candidate.normalRisk <= 0.25 &&
+    candidate.rankLength >= lengthStats.median * 1.08 &&
+    candidate.projectedLength >= 24;
+}
+
+function splitCandidateGlobalSeed(
+  candidate: SeamFacetSplitCandidateInternal,
+  strongScore: number,
+  strongLength: number,
+): boolean {
+  return candidate.score >= strongScore || candidate.rankLength >= strongLength;
+}
+
+function seamFacetSplitBudgetPlan(
+  candidates: SeamFacetSplitCandidateInternal[],
+  mode: SeamFacetSplitSelectionMode,
+  maxBudget: number,
+  scoreStats: NumericDistribution,
+  lengthStats: NumericDistribution,
+  strongScore: number,
+  strongLength: number,
+): SeamFacetSplitBudgetPlan {
+  const budgetLimit = Math.max(0, Math.floor(maxBudget));
+  if (budgetLimit <= 0 || candidates.length === 0 || mode === "follow-up") {
+    return { budgetLimit, componentBudgets: null };
+  }
+
+  const byComponent = new Map<number, SeamFacetSplitCandidateInternal[]>();
+  for (const candidate of candidates) {
+    const group = byComponent.get(candidate.component);
+    if (group) group.push(candidate);
+    else byComponent.set(candidate.component, [candidate]);
+  }
+
+  const componentBudgets = new Map<number, number>();
+  const scoreSpread = Math.max(EPS, scoreStats.q3 - scoreStats.q1);
+  const fallbackSeedScore = Math.min(scoreStats.max, Math.max(scoreStats.p95, scoreStats.q3 + scoreSpread));
+  let total = 0;
+  for (const [component, group] of byComponent) {
+    const primary = group.filter((candidate) =>
+      splitCandidateGlobalSeed(candidate, strongScore, strongLength) ||
+      candidate.score >= fallbackSeedScore
+    );
+    if (primary.length === 0) continue;
+
+    const likely = group.filter((candidate) => splitCandidateLikelyCrack(candidate, lengthStats));
+    const primaryCost = uniqueSplitPolygonCost(primary);
+    const likelyCost = uniqueSplitPolygonCost(likely);
+    const followUpAllowance = Math.ceil(Math.sqrt(Math.max(0, likelyCost - primaryCost)) * 3);
+    const componentBudget = Math.min(
+      uniqueSplitPolygonCost(group),
+      primaryCost + followUpAllowance,
+    );
+    if (componentBudget <= 0) continue;
+    componentBudgets.set(component, componentBudget);
+    total += componentBudget;
+  }
+
+  if (componentBudgets.size === 0) return { budgetLimit: 0, componentBudgets };
+  return {
+    budgetLimit: Math.min(budgetLimit, total),
+    componentBudgets,
+  };
+}
+
+function selectSeamFacetSplitCandidates(
+  candidates: SeamFacetSplitCandidateInternal[],
+  mode: SeamFacetSplitSelectionMode,
+  budget: number,
+): { selected: Map<number, Set<number>>; budgetLimit: number } {
+  const selected = new Map<number, Set<number>>();
+  if (candidates.length === 0 || budget <= 0) return { selected, budgetLimit: 0 };
+
+  const scoreStats = numericDistribution(candidates.map((candidate) => candidate.score));
+  const lengthStats = numericDistribution(candidates.map((candidate) => candidate.rankLength));
+  const scoreSpread = Math.max(EPS, scoreStats.q3 - scoreStats.q1);
+  const strongScore = Math.min(scoreStats.max, Math.max(scoreStats.p95, scoreStats.q3 + scoreSpread * 0.85));
+  const anchorScore = Math.min(scoreStats.max, Math.max(scoreStats.p80, scoreStats.q3 + scoreSpread * 0.15));
+  const sharedPolygonScore = Math.min(scoreStats.max, Math.max(scoreStats.p70, scoreStats.q3));
+  const strongLength = Math.max(lengthStats.p97, lengthStats.median * 1.8);
+  const anchorLength = Math.max(lengthStats.p88, lengthStats.median * 1.35);
+  const budgetPlan = seamFacetSplitBudgetPlan(
+    candidates,
+    mode,
+    budget,
+    scoreStats,
+    lengthStats,
+    strongScore,
+    strongLength,
+  );
+  let remainingBudget = budgetPlan.budgetLimit;
+  if (remainingBudget <= 0) return { selected, budgetLimit: 0 };
+
+  const anchors = strongestCandidatesByComponent(candidates);
+  const alreadySplit = new Set<number>();
+  const selectedEndpoints = new Set<string>();
+  const selectedComponents = new Set<number>();
+  const componentSpend = new Map<number, number>();
+  const localReserve = mode === "primary"
+    ? Math.min(Math.max(0, budgetPlan.budgetLimit - 1), Math.max(2, Math.floor(budgetPlan.budgetLimit * 0.28)))
+    : 0;
+
+  const sorted = [...candidates].sort((a, b) =>
+    splitCandidateBudgetPriority(b) - splitCandidateBudgetPriority(a) ||
+    (b.score / Math.max(1, b.records.length)) - (a.score / Math.max(1, a.records.length)) ||
+    b.length - a.length
+  );
+  const likelyCrackSorted = [...candidates].sort((a, b) =>
+    splitCandidateLikelyCrackPriority(b) - splitCandidateLikelyCrackPriority(a) ||
+    splitCandidateBudgetPriority(b) - splitCandidateBudgetPriority(a) ||
+    b.length - a.length
+  );
+
+  const selectCandidate = (candidate: SeamFacetSplitCandidateInternal, reason: SeamFacetSplitCandidateReason): void => {
+    candidate.selected = true;
+    candidate.reason = reason;
+    selectedComponents.add(candidate.component);
+    for (const endpoint of splitCandidateEndpointKeys(candidate)) selectedEndpoints.add(endpoint);
+    for (const record of candidate.records) {
+      alreadySplit.add(record.polygon);
+      const edges = selected.get(record.polygon);
+      if (edges) edges.add(record.edge);
+      else selected.set(record.polygon, new Set([record.edge]));
+    }
+  };
+
+  const withinComponentBudget = (candidate: SeamFacetSplitCandidateInternal, marginalCost: number): boolean => {
+    const componentBudgets = budgetPlan.componentBudgets;
+    if (marginalCost <= 0 || !componentBudgets) return true;
+    const componentBudget = componentBudgets.get(candidate.component) ?? 0;
+    return (componentSpend.get(candidate.component) ?? 0) + marginalCost <= componentBudget;
+  };
+
+  const recordComponentSpend = (candidate: SeamFacetSplitCandidateInternal, marginalCost: number): void => {
+    if (marginalCost <= 0 || !budgetPlan.componentBudgets) return;
+    componentSpend.set(candidate.component, (componentSpend.get(candidate.component) ?? 0) + marginalCost);
+  };
+
+  for (const candidate of likelyCrackSorted) {
+    const marginalCost = candidate.records.reduce(
+      (total, record) => total + (alreadySplit.has(record.polygon) ? 0 : 1),
+      0,
+    );
+    candidate.marginalCost = marginalCost;
+    if (marginalCost > remainingBudget) continue;
+    if (!withinComponentBudget(candidate, marginalCost)) continue;
+    if (marginalCost > 0 && remainingBudget - marginalCost < localReserve) continue;
+    const isLikelyCrack = splitCandidateLikelyCrack(candidate, lengthStats);
+    if (!isLikelyCrack) continue;
+    selectCandidate(candidate, "global-outlier");
+    recordComponentSpend(candidate, marginalCost);
+    remainingBudget -= marginalCost;
+    if (remainingBudget <= 0) return { selected, budgetLimit: budgetPlan.budgetLimit };
+  }
+
+  for (const candidate of sorted) {
+    if (candidate.selected) continue;
+    const marginalCost = candidate.records.reduce(
+      (total, record) => total + (alreadySplit.has(record.polygon) ? 0 : 1),
+      0,
+    );
+    candidate.marginalCost = marginalCost;
+    if (marginalCost > remainingBudget) continue;
+    if (!withinComponentBudget(candidate, marginalCost)) continue;
+    if (marginalCost > 0 && remainingBudget - marginalCost < localReserve) continue;
+
+    const twoSided = candidate.records.length === 2;
+    const isAnchor = anchors.has(candidate) && (
+      mode === "primary" ||
+      (mode === "follow-up" && candidate.score >= anchorScore * 1.08 && candidate.rankLength >= anchorLength)
+    ) && (
+      twoSided
+        ? candidate.score >= anchorScore || candidate.rankLength >= anchorLength
+        : candidate.score >= anchorScore * 1.18 || candidate.rankLength >= anchorLength * 1.12
+    );
+    const isGlobalOutlier = twoSided
+      ? candidate.score >= strongScore || candidate.rankLength >= strongLength
+      : candidate.score >= strongScore * 1.35 || candidate.rankLength >= strongLength * 1.2;
+    const isSharedPolygonFollowUp = marginalCost === 0 && (
+      twoSided
+        ? candidate.score >= sharedPolygonScore || candidate.rankLength >= anchorLength
+        : candidate.score >= sharedPolygonScore * 1.25 || candidate.rankLength >= anchorLength * 1.12
+    );
+    if (!isAnchor && !isGlobalOutlier && !isSharedPolygonFollowUp) continue;
+
+    selectCandidate(candidate, isAnchor
+      ? "component-anchor"
+      : isGlobalOutlier
+        ? "global-outlier"
+        : "shared-polygon");
+    recordComponentSpend(candidate, marginalCost);
+    remainingBudget -= marginalCost;
+    if (remainingBudget <= 0) return { selected, budgetLimit: budgetPlan.budgetLimit };
+  }
+
+  for (const candidate of sorted) {
+    if (candidate.selected) continue;
+    const marginalCost = candidate.records.reduce(
+      (total, record) => total + (alreadySplit.has(record.polygon) ? 0 : 1),
+      0,
+    );
+    candidate.marginalCost = marginalCost;
+    if (marginalCost > 1 || marginalCost > remainingBudget) continue;
+    if (!withinComponentBudget(candidate, marginalCost)) continue;
+    const touchesSelectedPolygon = candidate.records.some((record) => alreadySplit.has(record.polygon));
+    const touchesSelectedEndpoint = splitCandidateEndpointKeys(candidate).some((endpoint) => selectedEndpoints.has(endpoint));
+    const isOneSidedTail = mode === "primary" &&
+      candidate.records.length === 1 &&
+      marginalCost === 1 &&
+      (selectedComponents.has(candidate.component) || touchesSelectedEndpoint || touchesSelectedPolygon) &&
+      candidate.rankLength >= anchorLength * 1.05 &&
+      candidate.normalRisk >= 0.16 &&
+      candidate.viewRisk <= 0.32;
+    if (isOneSidedTail) {
+      selectCandidate(candidate, "local-follow-up");
+      recordComponentSpend(candidate, marginalCost);
+      remainingBudget -= marginalCost;
+      if (remainingBudget <= 0) return { selected, budgetLimit: budgetPlan.budgetLimit };
+      continue;
+    }
+    if (candidate.records.length !== 2) continue;
+    const isProjectedNeighbor = touchesSelectedPolygon &&
+      marginalCost === 1 &&
+      candidate.projectedLength >= anchorLength * 1.45 &&
+      candidate.viewRisk <= 0.18;
+    if (!touchesSelectedEndpoint && !isProjectedNeighbor) continue;
+    const isLocalFollowUp = (
+      candidate.score >= sharedPolygonScore * 0.42 ||
+      candidate.rankLength >= anchorLength * 0.62
+    ) && candidate.score <= sharedPolygonScore * 1.1 && candidate.projectedLength >= 24;
+    if (isLocalFollowUp) {
+      selectCandidate(candidate, "local-follow-up");
+      recordComponentSpend(candidate, marginalCost);
+      remainingBudget -= marginalCost;
+      if (remainingBudget <= 0) return { selected, budgetLimit: budgetPlan.budgetLimit };
+    }
+  }
+
+  return { selected, budgetLimit: budgetPlan.budgetLimit };
+}
+
+function seamFacetSplitPlan(
+  polygons: Polygon[],
+  seamOptions: ResolvedSeamOverlapOptions,
+  splitOptions: ResolvedSeamFacetSplitOptions,
+  budget: number,
+  followUpContext?: SeamFacetSplitFollowUpContext,
+): SeamFacetSplitPlan {
+  const metas = buildPolygonMetas(polygons);
+  const records = buildEdgeRecords(polygons, metas, seamOptions.capacityScale);
+  const edgeOwners = new Map<string, EdgeRecord[]>();
+  for (const record of records) {
+    const owners = edgeOwners.get(record.key);
+    if (owners) owners.push(record);
+    else edgeOwners.set(record.key, [record]);
+  }
+
+  const candidates = buildSeamFacetSplitCandidates(polygons, metas, edgeOwners, splitOptions)
+    .filter((candidate) => splitCandidateTouchesFollowUp(candidate, followUpContext));
+  const selection = selectSeamFacetSplitCandidates(candidates, followUpContext ? "follow-up" : "primary", budget);
+  return { selected: selection.selected, candidates, budgetLimit: selection.budgetLimit };
+}
+
+function seamFacetSplitSelection(
+  polygons: Polygon[],
+  seamOptions: ResolvedSeamOverlapOptions,
+  splitOptions: ResolvedSeamFacetSplitOptions,
+): Map<number, Set<number>> {
+  return seamFacetSplitPlan(polygons, seamOptions, splitOptions, splitOptions.budget).selected;
+}
+
+function applySeamFacetSplitSelection(
+  polygons: Polygon[],
+  selected: ReadonlyMap<number, ReadonlySet<number>>,
+): Polygon[] {
+  const out: Polygon[] = [];
+  for (let i = 0; i < polygons.length; i += 1) {
+    const polygon = polygons[i];
+    const edges = selected.get(i);
+    if (edges && isRefinableSeamQuad(polygon)) out.push(...splitQuadIntoTriangles(polygon, edges));
+    else out.push(polygon);
+  }
+  return out;
+}
+
+function seamFacetSplitPublicCandidate(candidate: SeamFacetSplitCandidateInternal): SeamFacetSplitCandidate {
+  const [a, b] = candidate.owners;
+  const first = a ?? b;
+  const second = b ?? a;
+  return {
+    key: candidate.key,
+    aPolygon: first?.polygon ?? -1,
+    aEdge: first?.edge ?? -1,
+    bPolygon: second?.polygon ?? -1,
+    bEdge: second?.edge ?? -1,
+    color: first?.color ?? second?.color,
+    materialKey: first?.materialKey ?? second?.materialKey ?? "",
+    lengthPx: candidate.length,
+    projectedLengthPx: candidate.projectedLength,
+    score: candidate.score,
+    normalRisk: candidate.normalRisk,
+    shapeRisk: candidate.shapeRisk,
+    viewRisk: candidate.viewRisk,
+    component: candidate.component,
+    marginalCost: candidate.marginalCost,
+    selected: candidate.selected,
+    reason: candidate.reason,
+  };
+}
+
+export function seamFacetSplitPolygons(
+  polygons: Polygon[],
+  seamOptions?: number | SeamOverlapOptions,
+  splitOptions?: SeamFacetSplitOptions,
+): Polygon[] {
+  const resolved = resolveSeamOverlapOptions(seamOptions);
+  const split = resolveSeamFacetSplitOptions(splitOptions);
+  if (!seamOverlapEnabled(resolved, seamOptions) || polygons.length === 0) return polygons;
+  let current = polygons;
+  let followUpContext: SeamFacetSplitFollowUpContext | undefined;
+  let remainingBudget = split.budget;
+  for (let pass = 0; pass < split.passes; pass += 1) {
+    const plan = seamFacetSplitPlan(current, resolved, split, remainingBudget, followUpContext);
+    if (pass === 0) remainingBudget = Math.min(remainingBudget, plan.budgetLimit);
+    if (plan.selected.size === 0) break;
+    const next = applySeamFacetSplitSelection(current, plan.selected);
+    if (next.length === current.length) break;
+    remainingBudget -= plan.selected.size;
+    if (remainingBudget <= 0) {
+      current = next;
+      break;
+    }
+    followUpContext = splitPlanFollowUpContext(plan.candidates);
+    current = next;
+  }
+  return current;
+}
+
+export function seamFacetSplitReport(
+  polygons: Polygon[],
+  seamOptions?: number | SeamOverlapOptions,
+  splitOptions?: SeamFacetSplitOptions,
+): SeamFacetSplitReport {
+  const resolved = resolveSeamOverlapOptions(seamOptions);
+  const split = resolveSeamFacetSplitOptions(splitOptions);
+  if (!seamOverlapEnabled(resolved, seamOptions) || polygons.length === 0) {
+    return { candidates: [], selectedPolygons: 0, selectedEdges: 0, addedPolygons: 0 };
+  }
+
+  const plan = seamFacetSplitPlan(polygons, resolved, split, split.budget);
+  let selectedEdges = 0;
+  for (const edges of plan.selected.values()) selectedEdges += edges.size;
+  return {
+    candidates: plan.candidates.map(seamFacetSplitPublicCandidate),
+    selectedPolygons: plan.selected.size,
+    selectedEdges,
+    addedPolygons: plan.selected.size,
+  };
+}
+
+export function seamOverlapPolygons(
+  polygons: Polygon[],
+  options?: number | SeamOverlapOptions,
+): Polygon[] {
+  const resolved = resolveSeamOverlapOptions(options);
+  if (!seamOverlapEnabled(resolved, options) || polygons.length === 0) return polygons;
+  const { edgeRepairs } = buildSeamEdgeAmounts(polygons, resolved);
+  if (!edgeRepairs.some((edges) => edges.size > 0)) return polygons;
+  return polygons.map((polygon, index) => patchPolygon(polygon, edgeRepairs[index], resolved.capacityScale));
+}
+
+export function repairMeshSeams(
+  polygons: Polygon[],
+  seamOptions: number | SeamOverlapOptions = DEFAULT_SEAM_OVERLAP_OPTIONS,
+  splitOptions: SeamFacetSplitOptions = DEFAULT_SEAM_FACET_SPLIT_OPTIONS,
+): Polygon[] {
+  if (polygons.length === 0) return polygons;
+  const split = seamFacetSplitPolygons(polygons, seamOptions, splitOptions);
+  return seamOverlapPolygons(split, seamOptions);
+}
+
+export function seamOverlapDiagnostics(
+  polygons: Polygon[],
+  options?: number | SeamOverlapOptions,
+): SeamOverlapDiagnostics {
+  const resolved = resolveSeamOverlapOptions(options);
+  if (!seamOverlapEnabled(resolved, options) || polygons.length === 0) return emptyDiagnostics();
+  return buildSeamEdgeAmounts(polygons, resolved).diagnostics;
+}
+
+export function seamOverlapReport(
+  polygons: Polygon[],
+  options?: number | SeamOverlapOptions,
+): { diagnostics: SeamOverlapDiagnostics; candidates: SeamOverlapCandidate[] } {
+  const resolved = resolveSeamOverlapOptions(options);
+  if (!seamOverlapEnabled(resolved, options) || polygons.length === 0) {
+    return { diagnostics: emptyDiagnostics(), candidates: [] };
+  }
+  const result = buildSeamEdgeAmounts(polygons, resolved, true);
+  return {
+    diagnostics: result.diagnostics,
+    candidates: result.candidates ?? [],
+  };
+}
diff --git a/packages/core/src/parser/loadMesh.ts b/packages/core/src/parser/loadMesh.ts
index b038d1e1..b0f7edf2 100644
--- a/packages/core/src/parser/loadMesh.ts
+++ b/packages/core/src/parser/loadMesh.ts
@@ -24,7 +24,6 @@ import { parseGltf } from "./parseGltf";
 import { parseMtl } from "./parseMtl";
 import { parseVox } from "./parseVox";
 import { bakeSolidTextureSamples, type SolidTextureSampleOptions } from "./solidTextureSamples";
-import { mergePolygons } from "../merge/mergePolygons";
 import { optimizeMeshPolygons } from "../merge/optimizePolygons";
 
 export interface LoadMeshOptions {
@@ -71,16 +70,8 @@ function withMeshResolution(result: ParseResult, options?: LoadMeshOptions): Par
   const optimized = optimizeMeshPolygons(result.polygons, {
     meshResolution: options?.meshResolution,
   });
-  // Final canonicalising merge so every caller — vanilla scene.add(), React
-  // <PolyMesh>, Vue <PolyMesh>, custom-element <poly-mesh> — receives the
-  // same merged polygon list. optimizeMeshPolygons runs mergePolygons on its
-  // baseline, but lossy candidates (rect cover, approximate merge, color
-  // quantize) can pick a different polygon set that still has merge-eligible
-  // pairs; running mergePolygons one more time closes those without
-  // affecting already-canonical baselines (idempotent).
-  const polygons = mergePolygons(optimized);
-  if (polygons === result.polygons) return result;
-  return { ...result, polygons };
+  if (optimized === result.polygons) return result;
+  return { ...result, polygons: optimized };
 }
 
 async function withSolidTextureSamples(result: ParseResult, options?: LoadMeshOptions): Promise<ParseResult> {
diff --git a/packages/polycss/README.md b/packages/polycss/README.md
index ad8a69f3..11437ba3 100644
--- a/packages/polycss/README.md
+++ b/packages/polycss/README.md
@@ -88,6 +88,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `directionalLight` and `ambientLight` control scene lighting.
 - `textureLighting` chooses `"baked"` or `"dynamic"`.
 - `textureQuality` controls atlas raster budget.
+- Seam bleed defaults to `1.5` CSS px on detected shared solid edges; `seamBleed="auto"` fits the amount from each polygon plan.
 - `strategies` can disable selected render strategies for diagnostics.
 - `autoCenter` rotates around the rendered mesh bounds instead of world origin.
 
@@ -98,7 +99,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `polygons` accepts pre-parsed geometry.
 - `position`, `scale`, and `rotation` transform the mesh wrapper.
 - `autoCenter` shifts the mesh bbox center to local origin.
-- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization.
+- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization. Lossy also applies bounded seam repair.
 - `castShadow` emits CSS-projected shadows in dynamic lighting mode.
 
 ### Controls
@@ -177,7 +178,7 @@ polycss renders in the DOM, so performance is mostly determined by how many poly
 - Textured polygons are packed into generated texture atlases.
 - Dynamic lighting runs through CSS custom properties instead of per-frame JavaScript.
 - Voxel-shaped meshes mount only camera-facing leaves when the mesh is eligible.
-- `meshResolution: "lossy"` can merge compatible polygons to reduce DOM node count.
+- `meshResolution: "lossy"` merges compatible polygons, then may spend a small split budget to repair high-risk seams.
 
 For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, which returns mounted polygon leaf counts, shadow counts, surface categories, and bucket counts for an already-rendered scene.
 
diff --git a/packages/polycss/src/api/createPolyScene.test.ts b/packages/polycss/src/api/createPolyScene.test.ts
index 461a9f9d..c8c43b5b 100644
--- a/packages/polycss/src/api/createPolyScene.test.ts
+++ b/packages/polycss/src/api/createPolyScene.test.ts
@@ -5,6 +5,7 @@
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { ParseResult, Polygon } from "@layoutit/polycss-core";
+import { DEFAULT_SEAM_BLEED } from "@layoutit/polycss-core";
 import {
   createPolyScene,
   type PolySceneOptions,
@@ -413,7 +414,7 @@ describe("createPolyScene", () => {
   describe("add / remove mesh", () => {
     it("adds a .polycss-mesh wrapper with one polygon leaf element per polygon", () => {
       scene = makeScene(host);
-      const handle = scene.add(makeParseResult([triangle(), triangle("#00ff00")]));
+      const handle = scene.add(makeParseResult([triangle(), triangle("#00ff00")]), { merge: false });
       const wrappers = host.querySelectorAll(".polycss-mesh");
       expect(wrappers.length).toBe(1);
       const polys = host.querySelectorAll("i,b,s,u");
@@ -1277,6 +1278,32 @@ describe("createPolyScene", () => {
       expect(host.querySelector("i, s")).toBe(firstLeaf);
     });
 
+    it("re-renders meshes when seamBleed is set and explicitly unset", () => {
+      scene = makeScene(host, { seamBleed: 0 });
+      scene.add(makeParseResult([
+        triangle(),
+        {
+          vertices: [
+            [1, 0, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+          ],
+          color: "#ff0000",
+        },
+      ]), { merge: false });
+      const leaf = host.querySelector(".polycss-mesh u") as HTMLElement;
+      const baseTransform = leaf.style.transform;
+
+      scene.setOptions({ seamBleed: DEFAULT_SEAM_BLEED });
+      const bleedLeaf = host.querySelector(".polycss-mesh u") as HTMLElement;
+      expect(bleedLeaf.style.transform).not.toBe(baseTransform);
+      const bleedTransform = bleedLeaf.style.transform;
+
+      scene.setOptions({ seamBleed: undefined });
+      const resetLeaf = host.querySelector(".polycss-mesh u") as HTMLElement;
+      expect(resetLeaf.style.transform).toBe(bleedTransform);
+    });
+
     it("mounts only camera-facing voxel leaves by default", () => {
       scene = makeScene(host, {}, { rotX: 0, rotY: 0 });
       const handle = scene.add(makeParseResult([triangle(), backTriangle()]), { merge: false });
diff --git a/packages/polycss/src/api/createPolyScene.ts b/packages/polycss/src/api/createPolyScene.ts
index d0cd0892..8e1bf72f 100644
--- a/packages/polycss/src/api/createPolyScene.ts
+++ b/packages/polycss/src/api/createPolyScene.ts
@@ -37,6 +37,7 @@ import type {
 import {
   BASE_TILE,
   CAMERA_BACKFACE_CULL_EPS,
+  DEFAULT_SEAM_BLEED,
   VOXEL_CAMERA_CULL_NORMAL_LIMIT,
   cameraCullNormalKey,
   cameraCullVisibleSignature,
@@ -45,7 +46,6 @@ import {
   inverseRotateVec3,
   isAxisAlignedSurfaceNormal,
   isVoxelCameraCullableNormalGroups,
-  mergePolygons,
   normalFacesCamera,
   optimizeMeshPolygons,
   parseHexColor,
@@ -60,6 +60,7 @@ import {
   updateStableTriangleFrame,
   updatePolygonsWithStableTopology,
   type TextureQuality,
+  type PolySeamBleed,
   type PolyRenderStrategiesOption,
   type RenderedPoly,
   type SolidPaintDefaults,
@@ -76,6 +77,13 @@ import { injectPolyBaseStyles } from "../styles/styles";
 const ASYNC_MOUNT_BATCH_SIZE = 750;
 const DEFAULT_SCENE_PERSPECTIVE = 8000;
 
+function normalizeSceneOptions<T extends Partial<Omit<PolySceneOptions, "camera">>>(options: T): T {
+  if (!Object.prototype.hasOwnProperty.call(options, "seamBleed") || options.seamBleed !== undefined) {
+    return options;
+  }
+  return { ...options, seamBleed: DEFAULT_SEAM_BLEED };
+}
+
 export interface PolySceneOptions {
   /**
    * Camera handle created by `createPolyCamera`, `createPolyOrthographicCamera`,
@@ -92,6 +100,8 @@ export interface PolySceneOptions {
    *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
    *  raster scale and the 64px sprite. */
   textureQuality?: TextureQuality;
+  /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+  seamBleed?: PolySeamBleed;
   /**
    * Skip specific render-strategy tags. Polygons that would normally use a
    * disabled tag fall through the chain (b → i → s, u → i → s, i → s).
@@ -143,8 +153,6 @@ export interface PolyMeshTransform {
    * Mesh optimization intent. Defaults to `"lossy"` (bounded geometric
    * approximation when it reduces polygon count). Set `"lossless"` to preserve
    * the authored surface — only exact coplanar merges are applied.
-   * When set, the optimizer runs with this resolution and supersedes the
-   * plain `mergePolygons` pass.
    */
   meshResolution?: MeshResolution;
   /**
@@ -526,7 +534,10 @@ export function createPolyScene(
   // currentOptions holds non-camera scene options only.
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const { camera: _cameraOption, ...nonCameraOptions } = options;
-  let currentOptions: Omit<PolySceneOptions, "camera"> = { ...nonCameraOptions };
+  let currentOptions: Omit<PolySceneOptions, "camera"> = normalizeSceneOptions({
+    seamBleed: DEFAULT_SEAM_BLEED,
+    ...nonCameraOptions,
+  });
   const layoutScale = effectiveCssZoom(host);
 
   // Bbox-center of all live meshes (helpers opt out). Auto-managed by
@@ -1233,6 +1244,7 @@ export function createPolyScene(
       ambientLight: currentOptions.ambientLight,
       textureLighting: currentOptions.textureLighting,
       textureQuality: currentOptions.textureQuality,
+      seamBleed: currentOptions.seamBleed,
       strategies: currentOptions.strategies,
     };
     const solidPaintDefaults = getSolidPaintDefaults(entry.polygons, renderOptions);
@@ -1300,6 +1312,7 @@ export function createPolyScene(
       ambientLight: currentOptions.ambientLight,
       textureLighting: currentOptions.textureLighting,
       textureQuality: currentOptions.textureQuality,
+      seamBleed: currentOptions.seamBleed,
       strategies: currentOptions.strategies,
     };
     const atlas = entry.stableDom
@@ -1374,14 +1387,12 @@ export function createPolyScene(
     const css = buildMeshTransform(transform);
     if (css) wrapper.style.transform = css;
 
-    // When meshResolution is explicitly set, run the full optimizer (which
-    // subsumes mergePolygons) with that resolution intent. Otherwise fall back
-    // to the plain merge pass for backward compatibility.
+    // Static meshes use the full optimizer by default; meshResolution selects
+    // the quality intent. Explicit merge:false remains the escape hatch for
+    // animated topology updates and helper meshes that are already prepared.
     const preparePolygons = (polygons: Polygon[], merge: boolean): Polygon[] => {
-      if (transformIn.meshResolution !== undefined) {
-        return optimizeMeshPolygons(polygons, { meshResolution: transformIn.meshResolution });
-      }
-      return merge ? mergePolygons(polygons) : polygons;
+      if (parseResult.voxelSource || !merge) return polygons;
+      return optimizeMeshPolygons(polygons, { meshResolution: transformIn.meshResolution });
     };
     const sourcePolygons = preparePolygons(parseResult.polygons, mergeOnUpdate);
 
@@ -1501,6 +1512,7 @@ export function createPolyScene(
           ambientLight: currentOptions.ambientLight,
           textureLighting: currentOptions.textureLighting,
           textureQuality: currentOptions.textureQuality,
+          seamBleed: currentOptions.seamBleed,
         };
         const allStableTriangles =
           entry.rendered.length === entry.polygons.length &&
@@ -1631,6 +1643,7 @@ export function createPolyScene(
             ambientLight: currentOptions.ambientLight,
             textureLighting: currentOptions.textureLighting,
             textureQuality: currentOptions.textureQuality,
+            seamBleed: currentOptions.seamBleed,
             solidPaintDefaults: {},
             optimizeStableTriangleStyle: true,
             stableTriangleDebug: options?.stableTriangleDebug,
@@ -1801,8 +1814,10 @@ export function createPolyScene(
   function setOptions(partial: Partial<Omit<PolySceneOptions, "camera">>): void {
     const prevAutoCenter = !!currentOptions.autoCenter;
     const prevStrategies = currentOptions.strategies;
+    const prevSeamBleed = currentOptions.seamBleed;
     const prevTextureLighting = currentOptions.textureLighting;
-    currentOptions = { ...currentOptions, ...partial };
+    const normalizedPartial = normalizeSceneOptions(partial);
+    currentOptions = { ...currentOptions, ...normalizedPartial };
     applySceneStyle(sceneEl, currentOptions);
     const nextAutoCenter = !!currentOptions.autoCenter;
     // Re-evaluate per-mesh light overrides when lighting settings change —
@@ -1817,7 +1832,9 @@ export function createPolyScene(
     // updates) don't blow up the atlas every frame.
     const strategiesChanged = partial.strategies !== undefined &&
       !strategiesEqual(partial.strategies, prevStrategies);
-    if (strategiesChanged) {
+    const seamBleedChanged = Object.prototype.hasOwnProperty.call(partial, "seamBleed") &&
+      normalizedPartial.seamBleed !== prevSeamBleed;
+    if (strategiesChanged || seamBleedChanged) {
       for (const entry of meshes) renderEntry(entry);
     }
     if (prevAutoCenter !== nextAutoCenter) recomputeAutoCenter();
@@ -1827,7 +1844,7 @@ export function createPolyScene(
       prevTextureLighting !== currentOptions.textureLighting;
     if (textureLightingChanged) {
       for (const entry of meshes) {
-        if (!strategiesChanged && (entry.voxelSource || entry.voxelRenderer)) {
+        if (!strategiesChanged && !seamBleedChanged && (entry.voxelSource || entry.voxelRenderer)) {
           renderEntry(entry);
         } else {
           emitShadowLeaves(entry);
diff --git a/packages/polycss/src/elements/PolyAxesHelperElement.ts b/packages/polycss/src/elements/PolyAxesHelperElement.ts
index 080a6637..ca756a10 100644
--- a/packages/polycss/src/elements/PolyAxesHelperElement.ts
+++ b/packages/polycss/src/elements/PolyAxesHelperElement.ts
@@ -84,7 +84,7 @@ export class PolyAxesHelperElement extends ELEMENT_BASE {
       dispose: () => {},
       warnings: [],
     };
-    this._handle = scene.add(parsed, { excludeFromAutoCenter: true });
+    this._handle = scene.add(parsed, { excludeFromAutoCenter: true, merge: false });
   }
 
   private _remount(): void {
diff --git a/packages/polycss/src/elements/PolyDirectionalLightHelperElement.ts b/packages/polycss/src/elements/PolyDirectionalLightHelperElement.ts
index 1bf0f141..49a7dca9 100644
--- a/packages/polycss/src/elements/PolyDirectionalLightHelperElement.ts
+++ b/packages/polycss/src/elements/PolyDirectionalLightHelperElement.ts
@@ -113,6 +113,7 @@ export class PolyDirectionalLightHelperElement extends ELEMENT_BASE {
     this._handle = scene.add(parsed, {
       position: this._meshPosition(),
       excludeFromAutoCenter: true,
+      merge: false,
     });
   }
 
diff --git a/packages/polycss/src/elements/PolySceneElement.test.ts b/packages/polycss/src/elements/PolySceneElement.test.ts
index 68ebfcf4..6df64249 100644
--- a/packages/polycss/src/elements/PolySceneElement.test.ts
+++ b/packages/polycss/src/elements/PolySceneElement.test.ts
@@ -3,6 +3,7 @@
  * connect/disconnect lifecycle, attribute changes.
  */
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { DEFAULT_SEAM_BLEED } from "@layoutit/polycss-core";
 import { PolySceneElement } from "./PolySceneElement";
 
 beforeAll(() => {
@@ -35,6 +36,7 @@ describe("PolySceneElement", () => {
       expect(observed).toContain("rot-y");
       expect(observed).toContain("zoom");
       expect(observed).toContain("texture-quality");
+      expect(observed).toContain("seam-bleed");
       expect(observed).toContain("directional-direction");
       expect(observed).toContain("directional-color");
       expect(observed).toContain("directional-intensity");
@@ -163,6 +165,22 @@ describe("PolySceneElement", () => {
       expect(el.getScene()?.getOptions().autoCenter).toBe(true);
     });
 
+    it("resets seam-bleed to the default when the attribute is removed", () => {
+      const el = document.createElement("poly-scene") as PolySceneElement;
+      el.setAttribute("seam-bleed", "2");
+      host.appendChild(el);
+      expect(el.getScene()?.getOptions().seamBleed).toBe(2);
+      el.removeAttribute("seam-bleed");
+      expect(el.getScene()?.getOptions().seamBleed).toBe(DEFAULT_SEAM_BLEED);
+    });
+
+    it("parses seam-bleed auto", () => {
+      const el = document.createElement("poly-scene") as PolySceneElement;
+      el.setAttribute("seam-bleed", "auto");
+      host.appendChild(el);
+      expect(el.getScene()?.getOptions().seamBleed).toBe("auto");
+    });
+
   });
 
   describe("attributeChangedCallback", () => {
diff --git a/packages/polycss/src/elements/PolySceneElement.ts b/packages/polycss/src/elements/PolySceneElement.ts
index 8eece21f..8c852fbe 100644
--- a/packages/polycss/src/elements/PolySceneElement.ts
+++ b/packages/polycss/src/elements/PolySceneElement.ts
@@ -48,6 +48,7 @@ const OBSERVED_ATTRS = [
   "ambient-intensity",
   "texture-lighting",
   "texture-quality",
+  "seam-bleed",
   "auto-center",
 ] as const;
 
@@ -81,6 +82,11 @@ function parseTextureQuality(value: string | null): PolySceneOptions["textureQua
   return parseNumber(value);
 }
 
+function parseSeamBleed(value: string | null): PolySceneOptions["seamBleed"] | undefined {
+  if (value === "auto") return "auto";
+  return parseNumber(value);
+}
+
 type CameraElement = {
   getCamera(): PolyPerspectiveCameraHandle | PolyOrthographicCameraHandle | null;
 };
@@ -150,6 +156,8 @@ export class PolySceneElement extends ELEMENT_BASE {
     opts.textureLighting = parseTextureLighting(this.getAttribute("texture-lighting")) ?? "baked";
     const textureQuality = parseTextureQuality(this.getAttribute("texture-quality"));
     if (textureQuality !== undefined) opts.textureQuality = textureQuality;
+    const seamBleed = parseSeamBleed(this.getAttribute("seam-bleed"));
+    opts.seamBleed = seamBleed;
     opts.autoCenter = this.hasAttribute("auto-center");
     if (directionalLight) opts.directionalLight = directionalLight;
     if (ambientLight) opts.ambientLight = ambientLight;
diff --git a/packages/polycss/src/elements/PolyShapeElements.ts b/packages/polycss/src/elements/PolyShapeElements.ts
index 0f9cd953..5119051a 100644
--- a/packages/polycss/src/elements/PolyShapeElements.ts
+++ b/packages/polycss/src/elements/PolyShapeElements.ts
@@ -125,6 +125,7 @@ abstract class PolyShapeElement extends ELEMENT_BASE {
           return Number.isFinite(n) ? n : undefined;
         })(),
         rotation: parseVec3Attr(this, "rotation"),
+        merge: false,
       },
     );
   }
diff --git a/packages/polycss/src/index.ts b/packages/polycss/src/index.ts
index bd7195cf..65d20ea2 100644
--- a/packages/polycss/src/index.ts
+++ b/packages/polycss/src/index.ts
@@ -88,6 +88,7 @@ export { PolySelectElement } from "./elements/PolySelectElement";
 export type {
   PolyRenderStrategy,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
   TextureQuality,
   TextureAtlasPlan,
   PackedTextureAtlasEntry,
diff --git a/packages/polycss/src/render/atlas/index.ts b/packages/polycss/src/render/atlas/index.ts
index 07bb2335..309dfc6a 100644
--- a/packages/polycss/src/render/atlas/index.ts
+++ b/packages/polycss/src/render/atlas/index.ts
@@ -10,6 +10,7 @@ export type {
   SolidPaintDefaults,
   TextureAtlasPage,
   ComputeTextureAtlasPlanOptions,
+  PolySeamBleed,
 } from "@layoutit/polycss-core";
 export type {
   RenderTextureAtlasOptions,
@@ -18,7 +19,7 @@ export type {
   RenderTextureAtlasAsyncResult,
 } from "./types";
 export { packTextureAtlasPlansWithScale } from "./packing";
-export { buildTextureEdgeRepairSets } from "@layoutit/polycss-core";
+export { buildTextureEdgeRepairSets, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet } from "@layoutit/polycss-core";
 export { buildAtlasPages } from "./rasterise";
 export {
   isFullRectSolid,
diff --git a/packages/polycss/src/render/atlas/renderPolygons.ts b/packages/polycss/src/render/atlas/renderPolygons.ts
index 79cef5cc..b3f4df52 100644
--- a/packages/polycss/src/render/atlas/renderPolygons.ts
+++ b/packages/polycss/src/render/atlas/renderPolygons.ts
@@ -21,8 +21,13 @@ import {
   PROJECTIVE_QUAD_DENOM_EPS,
   PROJECTIVE_QUAD_MAX_WEIGHT_RATIO,
   PROJECTIVE_QUAD_BLEED,
+  DEFAULT_SEAM_BLEED,
+} from "@layoutit/polycss-core";
+import {
+  buildBasisHints,
+  buildSeamBleedPolygonEdges,
+  computeTextureAtlasPlan,
 } from "@layoutit/polycss-core";
-import { buildBasisHints, computeTextureAtlasPlan } from "@layoutit/polycss-core";
 import { resolveProjectiveQuadGuards } from "./plan";
 import {
   getSolidPaintDefaultsForPlans,
@@ -70,6 +75,10 @@ import {
 } from "./stableTriangle";
 import { stableTriangleMatrixDecimals } from "@layoutit/polycss-core";
 
+type RenderTextureAtlasOptionsWithSeams = RenderTextureAtlasOptions & {
+  seamEdges?: Set<number>;
+};
+
 function yieldToMainThread(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
@@ -80,6 +89,59 @@ async function yieldIfOverBudget(started: number): Promise<number> {
   return performance.now();
 }
 
+function seamTriangleOptions(
+  plan: TextureAtlasPlan,
+  options: RenderTextureAtlasOptions,
+): RenderTextureAtlasOptionsWithSeams {
+  const seamBleed = effectiveSeamBleed(options);
+  return plan.seamBleedEdges?.size
+    ? { ...options, seamBleed, seamEdges: plan.seamBleedEdges }
+    : { ...options, seamBleed: undefined, seamEdges: undefined };
+}
+
+function effectiveSeamBleed(options: RenderTextureAtlasOptions): RenderTextureAtlasOptions["seamBleed"] {
+  return Object.prototype.hasOwnProperty.call(options, "seamBleed")
+    ? options.seamBleed
+    : DEFAULT_SEAM_BLEED;
+}
+
+function shouldApplySeamBleed(seamBleed: RenderTextureAtlasOptions["seamBleed"]): boolean {
+  return seamBleed === "auto" || (
+    typeof seamBleed === "number" &&
+    Number.isFinite(seamBleed) &&
+    seamBleed > 0
+  );
+}
+
+function buildRenderSeamBleedEdges(
+  polygons: Polygon[],
+  options: RenderTextureAtlasOptions,
+): Map<number, Set<number>> | null {
+  return shouldApplySeamBleed(effectiveSeamBleed(options))
+    ? buildSeamBleedPolygonEdges(polygons, {
+        tileSize: options.tileSize,
+        layerElevation: options.layerElevation,
+        directionalLight: options.directionalLight,
+        ambientLight: options.ambientLight,
+      })
+    : null;
+}
+
+function seamAtlasOptions(
+  index: number,
+  seamBleedEdges: Map<number, Set<number>> | null,
+  options: RenderTextureAtlasOptions,
+): RenderTextureAtlasOptionsWithSeams {
+  const seamBleed = effectiveSeamBleed(options);
+  return seamBleedEdges
+    ? {
+        ...options,
+        seamBleed: seamBleedEdges.has(index) ? seamBleed : undefined,
+        seamEdges: seamBleedEdges.get(index),
+      }
+    : options;
+}
+
 export function getSolidPaintDefaults(
   polygons: Polygon[],
   options: RenderTextureAtlasOptions = {},
@@ -116,12 +178,19 @@ export function renderPolygonsWithTextureAtlas(
   const useBorderShape = !disabled.has("i") && borderShapeSupported(doc);
   const basisHints = buildBasisHints(polygons, options);
   const projectiveQuadGuards = resolveProjectiveQuadGuards(doc);
+  const seamBleedEdges = buildRenderSeamBleedEdges(polygons, options);
   const plans = polygons.map((polygon, index) =>
-    computeTextureAtlasPlan(polygon, index, options, projectiveQuadGuards, basisHints[index])
+    computeTextureAtlasPlan(
+      polygon,
+      index,
+      seamAtlasOptions(index, seamBleedEdges, options),
+      projectiveQuadGuards,
+      basisHints[index],
+    )
   );
   const trianglePlans = plans.map((plan) =>
     plan && useStableTriangle && isSolidTrianglePlan(plan)
-      ? computeSolidTrianglePlan(plan.polygon, plan.index, options, {
+      ? computeSolidTrianglePlan(plan.polygon, plan.index, seamTriangleOptions(plan, options), {
           primitive: solidTrianglePrimitive ?? undefined,
         })
       : null
@@ -240,10 +309,17 @@ export async function renderPolygonsWithTextureAtlasAsync(
 
   const basisHints = buildBasisHints(polygons, options);
   const projectiveQuadGuards = resolveProjectiveQuadGuards(doc);
+  const seamBleedEdges = buildRenderSeamBleedEdges(polygons, options);
   let batchStarted = performance.now();
   const plans: Array<TextureAtlasPlan | null> = new Array(polygons.length);
   for (let i = 0; i < polygons.length; i++) {
-    plans[i] = computeTextureAtlasPlan(polygons[i], i, options, projectiveQuadGuards, basisHints[i]);
+    plans[i] = computeTextureAtlasPlan(
+      polygons[i],
+      i,
+      seamAtlasOptions(i, seamBleedEdges, options),
+      projectiveQuadGuards,
+      basisHints[i],
+    );
     batchStarted = await yieldIfOverBudget(batchStarted);
     if (shouldCancel()) return { rendered: [], solidPaintDefaults: {}, dispose: () => {} };
   }
@@ -256,7 +332,7 @@ export async function renderPolygonsWithTextureAtlasAsync(
   for (let i = 0; i < plans.length; i++) {
     const plan = plans[i];
     const trianglePlan = plan && useStableTriangle && isSolidTrianglePlan(plan)
-      ? computeSolidTrianglePlan(plan.polygon, plan.index, { ...options, solidPaintDefaults }, {
+      ? computeSolidTrianglePlan(plan.polygon, plan.index, seamTriangleOptions(plan, { ...options, solidPaintDefaults }), {
           primitive: solidTrianglePrimitive ?? undefined,
         })
       : null;
diff --git a/packages/polycss/src/render/atlas/stableTriangle.test.ts b/packages/polycss/src/render/atlas/stableTriangle.test.ts
index 1ef5b12c..457ec740 100644
--- a/packages/polycss/src/render/atlas/stableTriangle.test.ts
+++ b/packages/polycss/src/render/atlas/stableTriangle.test.ts
@@ -54,6 +54,11 @@ const TRIANGLE_B: Polygon = {
   color: "#00ff00",
 };
 
+const ADJACENT_TRIANGLE_A: Polygon = {
+  vertices: [[1, 0, 0], [1, 1, 0], [0, 1, 0]],
+  color: "#ff0000",
+};
+
 const MOVED_TRIANGLE_A: Polygon = {
   vertices: [[0.1, 0, 0], [1.1, 0, 0], [0.1, 1, 0]],
   color: "#ff0000",
@@ -120,6 +125,21 @@ describe("renderPolygonsWithStableTriangles — initial render", () => {
     result!.dispose();
   });
 
+  it("applies seamBleed to detected shared triangle edges", () => {
+    const doc = makeDoc();
+    const base = renderPolygonsWithStableTriangles([TRIANGLE_A, ADJACENT_TRIANGLE_A], { doc })!;
+    const bleed = renderPolygonsWithStableTriangles([TRIANGLE_A, ADJACENT_TRIANGLE_A], {
+      doc,
+      seamBleed: 2,
+    })!;
+    expect(bleed.rendered[0].element.style.transform)
+      .not.toBe(base.rendered[0].element.style.transform);
+    expect(bleed.rendered[1].element.style.transform)
+      .not.toBe(base.rendered[1].element.style.transform);
+    base.dispose();
+    bleed.dispose();
+  });
+
   it("adds polycss-corner-triangle class when corner-shape is supported", () => {
     const doc = makeDoc({ cornerShape: true });
     const result = renderPolygonsWithStableTriangles([TRIANGLE_A], { doc });
diff --git a/packages/polycss/src/render/atlas/stableTriangle.ts b/packages/polycss/src/render/atlas/stableTriangle.ts
index 878e65c4..981ca007 100644
--- a/packages/polycss/src/render/atlas/stableTriangle.ts
+++ b/packages/polycss/src/render/atlas/stableTriangle.ts
@@ -1,9 +1,11 @@
 import type { Polygon } from "@layoutit/polycss-core";
 import {
+  buildSeamBleedPolygonEdges,
   DEFAULT_TILE,
   SOLID_TRIANGLE_CORNER_CLASS,
   DEFAULT_MATRIX_DECIMALS,
   BASIS_EPS,
+  DEFAULT_SEAM_BLEED,
 } from "@layoutit/polycss-core";
 import type {
   SolidTrianglePlan,
@@ -34,6 +36,53 @@ import { stableTriangleMatrixDecimals } from "@layoutit/polycss-core";
 import { applyPolygonDataAttrs, hasPolygonDataAttrs, clearAtlasImageStyles } from "./emit";
 import { resolveSolidTrianglePrimitive } from "./strategy";
 
+type RenderTextureAtlasOptionsWithSeams = RenderTextureAtlasOptions & {
+  seamEdges?: Set<number>;
+};
+
+function effectiveSeamBleed(options: RenderTextureAtlasOptions): RenderTextureAtlasOptions["seamBleed"] {
+  return Object.prototype.hasOwnProperty.call(options, "seamBleed")
+    ? options.seamBleed
+    : DEFAULT_SEAM_BLEED;
+}
+
+function shouldApplySeamBleed(seamBleed: RenderTextureAtlasOptions["seamBleed"]): boolean {
+  return seamBleed === "auto" || (
+    typeof seamBleed === "number" &&
+    Number.isFinite(seamBleed) &&
+    seamBleed > 0
+  );
+}
+
+function buildStableTriangleSeamEdges(
+  polygons: Polygon[],
+  options: RenderTextureAtlasOptions,
+): Map<number, Set<number>> | null {
+  return shouldApplySeamBleed(effectiveSeamBleed(options))
+    ? buildSeamBleedPolygonEdges(polygons, {
+        tileSize: options.tileSize,
+        layerElevation: options.layerElevation,
+        directionalLight: options.directionalLight,
+        ambientLight: options.ambientLight,
+      })
+    : null;
+}
+
+function stableTriangleSeamOptions(
+  index: number,
+  seamBleedEdges: Map<number, Set<number>> | null,
+  options: RenderTextureAtlasOptions,
+): RenderTextureAtlasOptionsWithSeams {
+  const seamBleed = effectiveSeamBleed(options);
+  return seamBleedEdges
+    ? {
+        ...options,
+        seamBleed: seamBleedEdges.has(index) ? seamBleed : undefined,
+        seamEdges: seamBleedEdges.get(index),
+      }
+    : options;
+}
+
 export function stableTriangleColorState(options: InternalRenderTextureAtlasOptions): StableTriangleColorState {
   return {
     updatesDisabled: options.stableTriangleColorFreezeFrames === 0,
@@ -292,6 +341,7 @@ export function updateStableTriangleElementsStreaming(
     if (item.kind !== "triangle" || item.polygonIndex !== i || !polygons[i]) return false;
   }
 
+  const seamBleedEdges = buildStableTriangleSeamEdges(polygons, options);
   for (let i = 0; i < rendered.length; i++) {
     const element = rendered[i].element as SolidTriangleElement;
     const polygon = polygons[i];
@@ -317,7 +367,7 @@ export function updateStableTriangleElementsStreaming(
       continue;
     }
 
-    const plan = computeSolidTrianglePlan(polygon, i, options, {
+    const plan = computeSolidTrianglePlan(polygon, i, stableTriangleSeamOptions(i, seamBleedEdges, options), {
       basis: element.__polycssSolidTriangleBasis,
       matrixDecimals,
       includeColor: stableTriangleUpdateMode !== "plan-only" &&
@@ -393,6 +443,7 @@ export function captureStableTriangleTransformFrame(
   }
 
   const values = frame.vertices;
+  const seamBleedEdges = buildStableTriangleSeamEdges(polygons, options);
   for (let i = 0; i < rendered.length; i++) {
     const element = rendered[i].element as SolidTriangleElement;
     const polygon = polygons[i]!;
@@ -409,7 +460,7 @@ export function captureStableTriangleTransformFrame(
     const plan = computeSolidTrianglePlanFromCssPoints(
       polygon,
       i,
-      options,
+      stableTriangleSeamOptions(i, seamBleedEdges, options),
       {
         basis: element.__polycssSolidTriangleBasis,
         matrixDecimals,
@@ -464,10 +515,11 @@ export function renderPolygonsWithStableTriangles(
   }
   const matrixDecimals = stableTriangleMatrixDecimals((options as InternalRenderTextureAtlasOptions).stableTriangleMatrixDecimals);
   const rendered: RenderedPoly[] = [];
+  const seamBleedEdges = buildStableTriangleSeamEdges(polygons, options);
 
   for (let i = 0; i < polygons.length; i += 1) {
     const polygon = polygons[i];
-    const plan = computeSolidTrianglePlan(polygon, i, options, {
+    const plan = computeSolidTrianglePlan(polygon, i, stableTriangleSeamOptions(i, seamBleedEdges, options), {
       matrixDecimals,
       primitive: solidTrianglePrimitive,
     });
@@ -527,6 +579,7 @@ export function updatePolygonsWithStableTriangles(
   }
   const nextTrianglePlans: Array<SolidTrianglePlan | null> = new Array(rendered.length);
   const nextTriangleColorPlans: Array<SolidTriangleColorPlan | null> = new Array(rendered.length);
+  const seamBleedEdges = buildStableTriangleSeamEdges(polygons, options);
   for (let i = 0; i < rendered.length; i++) {
     const element = rendered[i].element as SolidTriangleElement;
     if (colorOnly) {
@@ -544,7 +597,7 @@ export function updatePolygonsWithStableTriangles(
         : null;
       continue;
     }
-    nextTrianglePlans[i] = computeSolidTrianglePlan(polygons[i], i, options, {
+    nextTrianglePlans[i] = computeSolidTrianglePlan(polygons[i], i, stableTriangleSeamOptions(i, seamBleedEdges, options), {
       basis: element.__polycssSolidTriangleBasis,
       matrixDecimals,
       includeColor: stableTriangleUpdateMode !== "plan-only" &&
diff --git a/packages/polycss/src/render/atlas/types.ts b/packages/polycss/src/render/atlas/types.ts
index 591c64f4..583259af 100644
--- a/packages/polycss/src/render/atlas/types.ts
+++ b/packages/polycss/src/render/atlas/types.ts
@@ -22,6 +22,7 @@ export interface RenderTextureAtlasOptions {
   textureQuality?: import("@layoutit/polycss-core").TextureQuality;
   solidPaintDefaults?: import("@layoutit/polycss-core").SolidPaintDefaults;
   strategies?: import("@layoutit/polycss-core").PolyRenderStrategiesOption;
+  seamBleed?: import("@layoutit/polycss-core").PolySeamBleed;
 }
 
 export interface InternalRenderTextureAtlasOptions extends RenderTextureAtlasOptions {
@@ -65,4 +66,3 @@ export interface RenderTextureAtlasResult {
 export interface RenderTextureAtlasAsyncResult extends RenderTextureAtlasResult {
   solidPaintDefaults: import("@layoutit/polycss-core").SolidPaintDefaults;
 }
-
diff --git a/packages/polycss/src/render/polyDOM.test.ts b/packages/polycss/src/render/polyDOM.test.ts
index 78451770..105732ec 100644
--- a/packages/polycss/src/render/polyDOM.test.ts
+++ b/packages/polycss/src/render/polyDOM.test.ts
@@ -42,6 +42,24 @@ const SECOND_FLAT_TRIANGLE: Polygon = {
   color: "#ff0000",
 };
 
+const ADJACENT_FLAT_TRIANGLE: Polygon = {
+  vertices: [
+    [1, 0, 0],
+    [1, 1, 0],
+    [0, 1, 0],
+  ],
+  color: "#ff0000",
+};
+
+const HINGED_TRIANGLE: Polygon = {
+  vertices: [
+    [1, 0, 0],
+    [1, 1, 1],
+    [0, 1, 0],
+  ],
+  color: "#ff0000",
+};
+
 const VERTICAL_QUAD: Polygon = {
   vertices: [
     [0, 0, 0],
@@ -52,6 +70,16 @@ const VERTICAL_QUAD: Polygon = {
   color: "#00ff00",
 };
 
+const ADJACENT_VERTICAL_QUAD: Polygon = {
+  vertices: [
+    [1, 0, 0],
+    [2, 0, 0],
+    [2, 0, 1],
+    [1, 0, 1],
+  ],
+  color: "#00ff00",
+};
+
 const NON_RECT_QUAD: Polygon = {
   vertices: [
     [0, 0, 0],
@@ -426,6 +454,91 @@ describe("renderPolygonsWithTextureAtlas", () => {
     result.dispose();
   });
 
+  it("applies seamBleed only to solid primitives with valid shared edges", () => {
+    const baseQuad = renderPolygonsWithTextureAtlas([VERTICAL_QUAD], { tileSize: 1, seamBleed: 0 });
+    const bleedQuad = renderPolygonsWithTextureAtlas([VERTICAL_QUAD], { tileSize: 1, seamBleed: 2 });
+    const baseTriangle = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE, ADJACENT_FLAT_TRIANGLE], {
+      tileSize: 1,
+      seamBleed: 0,
+    });
+    const bleedTriangle = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE, ADJACENT_FLAT_TRIANGLE], { tileSize: 1, seamBleed: 2 });
+    const autoTriangle = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE, ADJACENT_FLAT_TRIANGLE], {
+      tileSize: 1,
+      seamBleed: "auto",
+    });
+
+    expect(bleedQuad.rendered).toHaveLength(baseQuad.rendered.length);
+    expect(bleedTriangle.rendered).toHaveLength(baseTriangle.rendered.length);
+    expect(bleedQuad.rendered[0].element.tagName.toLowerCase()).toBe("b");
+    expect(bleedTriangle.rendered[0].element.tagName.toLowerCase()).toBe("u");
+
+    const baseQuadMatrix = extractMatrix(baseQuad.rendered[0].element);
+    const bleedQuadMatrix = extractMatrix(bleedQuad.rendered[0].element);
+    const baseTriangleMatrix = extractMatrix(baseTriangle.rendered[0].element);
+    const bleedTriangleMatrix = extractMatrix(bleedTriangle.rendered[0].element);
+    const baseTriangleX = Math.hypot(baseTriangleMatrix[0], baseTriangleMatrix[1], baseTriangleMatrix[2]);
+    const baseTriangleY = Math.hypot(baseTriangleMatrix[4], baseTriangleMatrix[5], baseTriangleMatrix[6]);
+    const bleedTriangleX = Math.hypot(bleedTriangleMatrix[0], bleedTriangleMatrix[1], bleedTriangleMatrix[2]);
+    const bleedTriangleY = Math.hypot(bleedTriangleMatrix[4], bleedTriangleMatrix[5], bleedTriangleMatrix[6]);
+    expect(bleedQuad.rendered[0].element.style.transform).toBe(baseQuad.rendered[0].element.style.transform);
+    expect(Math.hypot(bleedQuadMatrix[0], bleedQuadMatrix[1], bleedQuadMatrix[2]))
+      .toBe(Math.hypot(baseQuadMatrix[0], baseQuadMatrix[1], baseQuadMatrix[2]));
+    expect(bleedTriangle.rendered[0].element.style.transform)
+      .not.toBe(baseTriangle.rendered[0].element.style.transform);
+    expect(
+      Math.abs(bleedTriangleX - baseTriangleX) > 1e-6 ||
+      Math.abs(bleedTriangleY - baseTriangleY) > 1e-6,
+    ).toBe(true);
+    expect(autoTriangle.rendered[0].element.style.transform)
+      .not.toBe(baseTriangle.rendered[0].element.style.transform);
+
+    baseQuad.dispose();
+    bleedQuad.dispose();
+    baseTriangle.dispose();
+    bleedTriangle.dispose();
+    autoTriangle.dispose();
+  });
+
+  it("applies seamBleed only along shared sides for rectangular solids", () => {
+    const base = renderPolygonsWithTextureAtlas([VERTICAL_QUAD, ADJACENT_VERTICAL_QUAD], {
+      tileSize: 10,
+      seamBleed: 0,
+    });
+    const bleed = renderPolygonsWithTextureAtlas([VERTICAL_QUAD, ADJACENT_VERTICAL_QUAD], { tileSize: 10, seamBleed: 2 });
+
+    for (let i = 0; i < 2; i += 1) {
+      expect(bleed.rendered[i].element.tagName.toLowerCase()).toBe("b");
+      const baseMatrix = extractMatrix(base.rendered[i].element);
+      const bleedMatrix = extractMatrix(bleed.rendered[i].element);
+      const baseX = Math.hypot(baseMatrix[0], baseMatrix[1], baseMatrix[2]);
+      const baseY = Math.hypot(baseMatrix[4], baseMatrix[5], baseMatrix[6]);
+      const bleedX = Math.hypot(bleedMatrix[0], bleedMatrix[1], bleedMatrix[2]);
+      const bleedY = Math.hypot(bleedMatrix[4], bleedMatrix[5], bleedMatrix[6]);
+      const xChanged = bleedX > baseX + 1e-6;
+      const yChanged = bleedY > baseY + 1e-6;
+      expect([xChanged, yChanged].filter(Boolean)).toHaveLength(1);
+      if (xChanged) expect(bleedY).toBeCloseTo(baseY, 6);
+      else expect(bleedX).toBeCloseTo(baseX, 6);
+    }
+
+    base.dispose();
+    bleed.dispose();
+  });
+
+  it("applies seamBleed to both sides of non-coplanar shared edges", () => {
+    const base = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE, HINGED_TRIANGLE], { tileSize: 1, seamBleed: 0 });
+    const bleed = renderPolygonsWithTextureAtlas([FLAT_TRIANGLE, HINGED_TRIANGLE], { tileSize: 1, seamBleed: 2 });
+
+    expect(bleed.rendered).toHaveLength(base.rendered.length);
+    expect(bleed.rendered[0].element.tagName.toLowerCase()).toBe("u");
+    expect(bleed.rendered[1].element.tagName.toLowerCase()).toBe("u");
+    expect(bleed.rendered[0].element.style.transform).not.toBe(base.rendered[0].element.style.transform);
+    expect(bleed.rendered[1].element.style.transform).not.toBe(base.rendered[1].element.style.transform);
+
+    base.dispose();
+    bleed.dispose();
+  });
+
   it("falls back to atlas for solid triangles on WebKit", () => {
     const canvases: Array<{ width: number; height: number; getContext: () => null }> = [];
     const doc = {
diff --git a/packages/polycss/src/render/textureAtlas.ts b/packages/polycss/src/render/textureAtlas.ts
index 123c25ae..4fa004f9 100644
--- a/packages/polycss/src/render/textureAtlas.ts
+++ b/packages/polycss/src/render/textureAtlas.ts
@@ -9,6 +9,7 @@ export type {
   SolidTriangleFrame,
   SolidPaintDefaults,
   TextureAtlasPage,
+  PolySeamBleed,
   RenderTextureAtlasOptions,
   RenderedPoly,
   RenderTextureAtlasResult,
@@ -18,6 +19,8 @@ export type {
 export {
   packTextureAtlasPlansWithScale,
   buildTextureEdgeRepairSets,
+  buildSeamBleedPolygonEdges,
+  buildSeamBleedPolygonSet,
   buildAtlasPages,
   isFullRectSolid,
   isSolidTrianglePlan,
diff --git a/packages/react/README.md b/packages/react/README.md
index ad8a69f3..11437ba3 100644
--- a/packages/react/README.md
+++ b/packages/react/README.md
@@ -88,6 +88,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `directionalLight` and `ambientLight` control scene lighting.
 - `textureLighting` chooses `"baked"` or `"dynamic"`.
 - `textureQuality` controls atlas raster budget.
+- Seam bleed defaults to `1.5` CSS px on detected shared solid edges; `seamBleed="auto"` fits the amount from each polygon plan.
 - `strategies` can disable selected render strategies for diagnostics.
 - `autoCenter` rotates around the rendered mesh bounds instead of world origin.
 
@@ -98,7 +99,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `polygons` accepts pre-parsed geometry.
 - `position`, `scale`, and `rotation` transform the mesh wrapper.
 - `autoCenter` shifts the mesh bbox center to local origin.
-- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization.
+- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization. Lossy also applies bounded seam repair.
 - `castShadow` emits CSS-projected shadows in dynamic lighting mode.
 
 ### Controls
@@ -177,7 +178,7 @@ polycss renders in the DOM, so performance is mostly determined by how many poly
 - Textured polygons are packed into generated texture atlases.
 - Dynamic lighting runs through CSS custom properties instead of per-frame JavaScript.
 - Voxel-shaped meshes mount only camera-facing leaves when the mesh is eligible.
-- `meshResolution: "lossy"` can merge compatible polygons to reduce DOM node count.
+- `meshResolution: "lossy"` merges compatible polygons, then may spend a small split budget to repair high-risk seams.
 
 For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, which returns mounted polygon leaf counts, shadow counts, surface categories, and bucket counts for an already-rendered scene.
 
diff --git a/packages/react/src/index.ts b/packages/react/src/index.ts
index 46782684..16fcf9ff 100644
--- a/packages/react/src/index.ts
+++ b/packages/react/src/index.ts
@@ -39,6 +39,7 @@ export type {
   InteractionProps,
   PolyRenderStrategy,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
 } from "./scene";
 
 export { Poly } from "./shapes";
@@ -163,6 +164,14 @@ export type {
   TexturePaintMetricsOptions,
   CoverPlanarPolygonsOptions,
   CullInteriorOptions,
+  SeamFacetSplitCandidate,
+  SeamFacetSplitCandidateReason,
+  SeamFacetSplitOptions,
+  SeamFacetSplitReport,
+  SeamOverlapCandidate,
+  SeamOverlapCandidateKind,
+  SeamOverlapDiagnostics,
+  SeamOverlapOptions,
   CameraCullNormalGroup,
   CameraCullRotation,
   ApproximateMergeOptions,
@@ -177,6 +186,12 @@ export {
   mergePolygons,
   coverPlanarPolygons,
   optimizeMeshPolygons,
+  repairMeshSeams,
+  seamFacetSplitPolygons,
+  seamFacetSplitReport,
+  seamOverlapDiagnostics,
+  seamOverlapPolygons,
+  seamOverlapReport,
   cullInteriorPolygons,
   cameraCullNormalGroups,
   cameraCullNormalGroupsFromPolygons,
@@ -223,11 +238,14 @@ export {
   buildSceneContext,
   computeSceneBbox,
   BASE_TILE,
+  DEFAULT_SEAM_BLEED,
   DEFAULT_CAMERA_STATE,
   DEFAULT_PROJECTION,
   normalizeInvertMultiplier,
   createPolyAnimationMixer,
   optimizeAnimatedMeshPolygons,
+  DEFAULT_SEAM_FACET_SPLIT_OPTIONS,
+  DEFAULT_SEAM_OVERLAP_OPTIONS,
   LoopOnce,
   LoopRepeat,
   LoopPingPong,
diff --git a/packages/react/src/scene/PolyMesh.tsx b/packages/react/src/scene/PolyMesh.tsx
index 31bee6b1..27c67ba3 100644
--- a/packages/react/src/scene/PolyMesh.tsx
+++ b/packages/react/src/scene/PolyMesh.tsx
@@ -31,10 +31,17 @@ import type {
   PolyTextureLightingMode,
   Vec3,
 } from "@layoutit/polycss-core";
-import { computeSceneBbox, findOverlappingPolygonDuplicates, inverseRotateVec3, parseHexColor } from "@layoutit/polycss-core";
+import {
+  computeSceneBbox,
+  DEFAULT_SEAM_BLEED,
+  findOverlappingPolygonDuplicates,
+  inverseRotateVec3,
+  parseHexColor,
+} from "@layoutit/polycss-core";
 import type { TransformProps } from "../shapes/types";
 import { usePolyMesh, type UseMeshOptions } from "./useMesh";
 import {
+  buildSeamBleedPolygonEdges,
   buildTextureEdgeRepairSets,
   computeTextureAtlasPlan,
   cssBorderShapeForPlan,
@@ -43,6 +50,7 @@ import {
   isSolidTrianglePlan,
   type TextureAtlasPlan,
   type TextureQuality,
+  type PolySeamBleed,
   type SolidPaintDefaults,
   TextureBorderShapePoly,
   TextureAtlasPoly,
@@ -97,6 +105,8 @@ export interface PolyMeshProps extends TransformProps, InteractionProps {
    *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
    *  raster scale and the 64px sprite. */
   textureQuality?: TextureQuality;
+  /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+  seamBleed?: PolySeamBleed;
   /** Per-polygon override render, or static children mounted inside the mesh wrapper. */
   children?: ((polygon: Polygon, index: number) => ReactNode) | ReactNode;
   /** Loading slot — rendered while `src` is being fetched/parsed. */
@@ -176,6 +186,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
     autoCenter,
     textureLighting,
     textureQuality,
+    seamBleed,
     castShadow,
     children,
     fallback,
@@ -502,6 +513,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
   const sceneCtx = usePolySceneContext();
   const effectiveTextureLighting = textureLighting ?? sceneCtx?.textureLighting ?? "baked";
   const effectiveStrategies = sceneCtx?.strategies;
+  const effectiveSeamBleed = seamBleed ?? sceneCtx?.seamBleed ?? DEFAULT_SEAM_BLEED;
   const effectiveDirectional =
     effectiveTextureLighting === "dynamic" ? undefined : sceneCtx?.directionalLight;
   const effectiveAmbient =
@@ -547,13 +559,25 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
     () => {
       if (renderPolygon) return [];
       const repairEdges = buildTextureEdgeRepairSets(polygons);
+      const seamBleedEdges = effectiveSeamBleed === "auto" || (
+        typeof effectiveSeamBleed === "number" &&
+        Number.isFinite(effectiveSeamBleed) &&
+        effectiveSeamBleed > 0
+      )
+        ? buildSeamBleedPolygonEdges(polygons, {
+            directionalLight: bakedDirectional,
+            ambientLight: effectiveAmbient,
+          })
+        : null;
       return polygons.map((p, i) => computeTextureAtlasPlan(p, i, {
         directionalLight: bakedDirectional,
         ambientLight: effectiveAmbient,
+        seamBleed: seamBleedEdges?.has(i) ? effectiveSeamBleed : undefined,
+        seamEdges: seamBleedEdges?.get(i),
         textureEdgeRepairEdges: repairEdges[i],
       }));
     },
-    [renderPolygon, polygons, bakedDirectional, effectiveAmbient],
+    [renderPolygon, polygons, bakedDirectional, effectiveAmbient, effectiveSeamBleed],
   );
   const textureAtlas = useTextureAtlas(
     atlasPlans,
@@ -637,6 +661,7 @@ export const PolyMesh = forwardRef<PolyMeshHandle, PolyMeshProps>(function PolyM
         ambientLight: effectiveAmbient,
         textureLighting: effectiveTextureLighting,
         strategies: effectiveStrategies,
+        seamBleed: effectiveSeamBleed,
         colorFrame: ++stableTriangleColorFrameRef.current,
         colorSteps: 8,
         colorFreezeFrames: 12,
diff --git a/packages/react/src/scene/PolyScene.tsx b/packages/react/src/scene/PolyScene.tsx
index 42bf7542..35de8042 100644
--- a/packages/react/src/scene/PolyScene.tsx
+++ b/packages/react/src/scene/PolyScene.tsx
@@ -6,18 +6,20 @@ import type {
   PolyAmbientLight,
   PolyTextureLightingMode,
 } from "@layoutit/polycss-core";
-import { BASE_TILE, parseHexColor } from "@layoutit/polycss-core";
+import { BASE_TILE, DEFAULT_SEAM_BLEED, parseHexColor } from "@layoutit/polycss-core";
 import type { ShadowOptions } from "./sceneContext";
 import { useCameraContext } from "../camera/context";
 import { usePolySceneContext } from "./useSceneContext";
 import { injectPolyBaseStyles } from "../styles/styles";
 import type { TransformProps } from "../shapes/types";
 import {
+  buildSeamBleedPolygonEdges,
   buildTextureEdgeRepairSets,
   computeTextureAtlasPlan,
   isProjectiveQuadPlan,
   isSolidTrianglePlan,
   type TextureQuality,
+  type PolySeamBleed,
   type PolyRenderStrategiesOption,
   TextureBorderShapePoly,
   TextureAtlasPoly,
@@ -57,6 +59,8 @@ export interface PolySceneProps extends TransformProps {
    *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
    *  raster scale and the 64px sprite. */
   textureQuality?: TextureQuality;
+  /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+  seamBleed?: PolySeamBleed;
   /**
    * Render strategy overrides. Use `{ disable: ["u"] }` to force solid
    * triangles through the atlas path (`<s>`), or `{ disable: ["b", "i", "u"] }`
@@ -100,6 +104,7 @@ function PolySceneInner({
   ambientLight,
   textureLighting = "baked",
   textureQuality,
+  seamBleed = DEFAULT_SEAM_BLEED,
   strategies,
   autoCenter = false,
   shadow,
@@ -182,8 +187,9 @@ function PolySceneInner({
       directionalLight: directionalForAtlas,
       ambientLight: ambientForAtlas,
       textureLighting,
+      seamBleed,
     };
-  }, [directionalForAtlas, ambientForAtlas, textureLighting]);
+  }, [directionalForAtlas, ambientForAtlas, textureLighting, seamBleed]);
 
   // Bbox center of all auto-centerable meshes in world coords. Kept as a Vec3
   // so it can be added to `target` inside the scene transform — same
@@ -224,12 +230,26 @@ function PolySceneInner({
   const textureAtlasPlans = useMemo(
     () => {
       const repairEdges = buildTextureEdgeRepairSets(polygons);
+      const seamBleedEdges = seamBleed === "auto" || (
+        typeof seamBleed === "number" &&
+        Number.isFinite(seamBleed) &&
+        seamBleed > 0
+      )
+        ? buildSeamBleedPolygonEdges(polygons, {
+            tileSize: polyContext.tileSize,
+            layerElevation: polyContext.layerElevation,
+            directionalLight: directionalForAtlas,
+            ambientLight: ambientForAtlas,
+          })
+        : null;
       return polygons.map((p, i) => computeTextureAtlasPlan(p, i, {
         ...polyContext,
+        seamBleed: seamBleedEdges?.has(i) ? seamBleed : undefined,
+        seamEdges: seamBleedEdges?.get(i),
         textureEdgeRepairEdges: repairEdges[i],
       }));
     },
-    [polygons, polyContext],
+    [polygons, polyContext, seamBleed, directionalForAtlas, ambientForAtlas],
   );
   const textureAtlas = useTextureAtlas(textureAtlasPlans, textureLighting, textureQuality, strategies);
 
@@ -369,10 +389,11 @@ function PolySceneInner({
       directionalLight,
       ambientLight,
       strategies,
+      seamBleed,
       shadow,
       registerShadowCaster,
     }),
-    [textureLighting, directionalLight, ambientLight, strategies, shadow, registerShadowCaster],
+    [textureLighting, directionalLight, ambientLight, strategies, seamBleed, shadow, registerShadowCaster],
   );
 
   return (
diff --git a/packages/react/src/scene/atlas/index.tsx b/packages/react/src/scene/atlas/index.tsx
index 65f6e0ed..14be813e 100644
--- a/packages/react/src/scene/atlas/index.tsx
+++ b/packages/react/src/scene/atlas/index.tsx
@@ -6,12 +6,15 @@ export type {
   SolidPaintDefaults,
   PolyRenderStrategy,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
   TextureQuality,
 } from "@layoutit/polycss-core";
 export {
   isSolidTrianglePlan,
   isProjectiveQuadPlan,
   buildTextureEdgeRepairSets,
+  buildSeamBleedPolygonEdges,
+  buildSeamBleedPolygonSet,
   cssBorderShapeForPlan,
 } from "@layoutit/polycss-core";
 
diff --git a/packages/react/src/scene/atlas/solidTriangleStyle.ts b/packages/react/src/scene/atlas/solidTriangleStyle.ts
index 5e627f26..3ded0c9d 100644
--- a/packages/react/src/scene/atlas/solidTriangleStyle.ts
+++ b/packages/react/src/scene/atlas/solidTriangleStyle.ts
@@ -1,4 +1,10 @@
-import { parsePureColor } from "@layoutit/polycss-core";
+import {
+  isSolidTrianglePlan,
+  offsetConvexPolygonPointsByEdgeAmounts,
+  parsePureColor,
+  resolveSeamBleed,
+  safePlanSeamBleedAmount,
+} from "@layoutit/polycss-core";
 import type {
   TextureAtlasPlan,
   PolyTextureLightingMode,
@@ -6,7 +12,6 @@ import type {
   Vec2,
   Vec3,
 } from "@layoutit/polycss-core";
-import { isSolidTrianglePlan } from "@layoutit/polycss-core";
 import type { CSSProperties } from "react";
 
 // ---------------------------------------------------------------------------
@@ -297,6 +302,34 @@ function offsetStableTrianglePoints(
   return [apexX, apexY, baseLeftX, baseLeftY, baseRightX, baseRightY];
 }
 
+function triangleEdgeIndexForPair(a: number, b: number): number | undefined {
+  if ((a + 1) % 3 === b) return a;
+  if ((b + 1) % 3 === a) return b;
+  return undefined;
+}
+
+function stableTriangleEdgeAmounts(
+  entry: TextureAtlasPlan,
+  a: number,
+  b: number,
+  c: number,
+  screenPts: number[],
+): number[] | null {
+  const seamEdges = entry.seamBleedEdges;
+  if (!seamEdges?.size) return null;
+  const seamAmount = entry.seamBleed === undefined
+    ? SOLID_TRIANGLE_BLEED
+    : entry.seamBleed;
+  const edgePairs: Array<[number, number]> = [[c, a], [a, b], [b, c]];
+  return edgePairs.map(([from, to], localEdgeIndex) => {
+    const edgeIndex = triangleEdgeIndexForPair(from, to);
+    const requested = edgeIndex !== undefined && seamEdges.has(edgeIndex)
+      ? entry.seamBleedEdgeAmounts?.get(edgeIndex) ?? resolveSeamBleed(seamAmount, SOLID_TRIANGLE_BLEED)
+      : 0;
+    return safePlanSeamBleedAmount(screenPts, localEdgeIndex, requested);
+  });
+}
+
 export function formatStableTriangleTransformScalars(
   x0: number, x1: number, x2: number,
   y0: number, y1: number, y2: number,
@@ -406,7 +439,16 @@ export function solidTriangleStyle(
   const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
   const left = Math.max(0, Math.min(baseLength, apexX));
   const right = Math.max(0, baseLength - left);
-  const expanded = offsetConvexPolygonPoints([left, 0, 0, height, left + right, height], SOLID_TRIANGLE_BLEED);
+  const screenPts = [left, 0, 0, height, left + right, height];
+  const edgeAmounts = stableTriangleEdgeAmounts(entry, a, b, c, screenPts);
+  const expanded = edgeAmounts
+    ? offsetConvexPolygonPointsByEdgeAmounts(screenPts, edgeAmounts)
+    : offsetStableTrianglePoints(
+        left,
+        right,
+        height,
+        resolveSeamBleed(entry.seamBleed, SOLID_TRIANGLE_BLEED),
+      );
   const apex2: Vec2 = [expanded[0], expanded[1]];
   const baseLeft2: Vec2 = [expanded[2], expanded[3]];
   const baseRight2: Vec2 = [expanded[4], expanded[5]];
diff --git a/packages/react/src/scene/atlas/stableTriangleDom.ts b/packages/react/src/scene/atlas/stableTriangleDom.ts
index 7f268158..a39f7461 100644
--- a/packages/react/src/scene/atlas/stableTriangleDom.ts
+++ b/packages/react/src/scene/atlas/stableTriangleDom.ts
@@ -4,6 +4,7 @@ import type {
   PolyAmbientLight,
   PolyTextureLightingMode,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
 } from "@layoutit/polycss-core";
 import { isSolidTriangleSupported } from "./detection";
 import {
@@ -37,6 +38,7 @@ export interface StableTriangleDomUpdateOptions {
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
   strategies?: PolyRenderStrategiesOption;
+  seamBleed?: PolySeamBleed;
   colorFrame?: number;
   colorSteps?: number;
   colorFreezeFrames?: number;
diff --git a/packages/react/src/scene/index.ts b/packages/react/src/scene/index.ts
index 3c35f653..563609f8 100644
--- a/packages/react/src/scene/index.ts
+++ b/packages/react/src/scene/index.ts
@@ -1,6 +1,6 @@
 export { PolyScene } from "./PolyScene";
 export type { PolySceneProps } from "./PolyScene";
-export type { PolyRenderStrategy, PolyRenderStrategiesOption } from "./atlas";
+export type { PolyRenderStrategy, PolyRenderStrategiesOption, PolySeamBleed } from "./atlas";
 export { PolyMesh } from "./PolyMesh";
 export type { PolyMeshProps } from "./PolyMesh";
 export { PolyGround } from "./PolyGround";
diff --git a/packages/react/src/scene/sceneContext.ts b/packages/react/src/scene/sceneContext.ts
index 9ec86ae2..b2460ce8 100644
--- a/packages/react/src/scene/sceneContext.ts
+++ b/packages/react/src/scene/sceneContext.ts
@@ -12,7 +12,7 @@ import type {
   PolyTextureLightingMode,
   Polygon,
 } from "@layoutit/polycss-core";
-import type { PolyRenderStrategiesOption } from "./atlas";
+import type { PolyRenderStrategiesOption, PolySeamBleed } from "./atlas";
 
 export interface ShadowOptions {
   color?: string;
@@ -25,6 +25,7 @@ export interface PolySceneContextValue {
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
   strategies?: PolyRenderStrategiesOption;
+  seamBleed?: PolySeamBleed;
   shadow?: ShadowOptions;
   /**
    * Called by PolyMesh to register/unregister itself as a shadow caster.
diff --git a/packages/vue/README.md b/packages/vue/README.md
index ad8a69f3..11437ba3 100644
--- a/packages/vue/README.md
+++ b/packages/vue/README.md
@@ -88,6 +88,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `directionalLight` and `ambientLight` control scene lighting.
 - `textureLighting` chooses `"baked"` or `"dynamic"`.
 - `textureQuality` controls atlas raster budget.
+- Seam bleed defaults to `1.5` CSS px on detected shared solid edges; `seamBleed="auto"` fits the amount from each polygon plan.
 - `strategies` can disable selected render strategies for diagnostics.
 - `autoCenter` rotates around the rendered mesh bounds instead of world origin.
 
@@ -98,7 +99,7 @@ import { PolyCamera, PolyScene, PolyOrbitControls, PolyMesh } from "@layoutit/po
 - `polygons` accepts pre-parsed geometry.
 - `position`, `scale`, and `rotation` transform the mesh wrapper.
 - `autoCenter` shifts the mesh bbox center to local origin.
-- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization.
+- `meshResolution` chooses `"lossy"` (default) or `"lossless"` optimization. Lossy also applies bounded seam repair.
 - `castShadow` emits CSS-projected shadows in dynamic lighting mode.
 
 ### Controls
@@ -177,7 +178,7 @@ polycss renders in the DOM, so performance is mostly determined by how many poly
 - Textured polygons are packed into generated texture atlases.
 - Dynamic lighting runs through CSS custom properties instead of per-frame JavaScript.
 - Voxel-shaped meshes mount only camera-facing leaves when the mesh is eligible.
-- `meshResolution: "lossy"` can merge compatible polygons to reduce DOM node count.
+- `meshResolution: "lossy"` merges compatible polygons, then may spend a small split budget to repair high-risk seams.
 
 For diagnostics, all renderer packages export `collectPolyRenderStats(root)`, which returns mounted polygon leaf counts, shadow counts, surface categories, and bucket counts for an already-rendered scene.
 
diff --git a/packages/vue/src/index.ts b/packages/vue/src/index.ts
index 4eedaf5b..1f3d82b3 100644
--- a/packages/vue/src/index.ts
+++ b/packages/vue/src/index.ts
@@ -13,7 +13,7 @@ export type { PolyCameraContextValue } from "./camera";
 
 export { PolyScene } from "./scene";
 export type { PolySceneProps } from "./scene";
-export type { PolyRenderStrategy, PolyRenderStrategiesOption } from "@layoutit/polycss-core";
+export type { PolyRenderStrategy, PolyRenderStrategiesOption, PolySeamBleed } from "@layoutit/polycss-core";
 export { PolyMesh } from "./scene";
 export type { PolyMeshProps } from "./scene";
 export { PolyGround } from "./scene";
@@ -140,6 +140,14 @@ export type {
   TexturePaintMetricsOptions,
   CoverPlanarPolygonsOptions,
   CullInteriorOptions,
+  SeamFacetSplitCandidate,
+  SeamFacetSplitCandidateReason,
+  SeamFacetSplitOptions,
+  SeamFacetSplitReport,
+  SeamOverlapCandidate,
+  SeamOverlapCandidateKind,
+  SeamOverlapDiagnostics,
+  SeamOverlapOptions,
   CameraCullNormalGroup,
   CameraCullRotation,
   ApproximateMergeOptions,
@@ -154,6 +162,12 @@ export {
   mergePolygons,
   coverPlanarPolygons,
   optimizeMeshPolygons,
+  repairMeshSeams,
+  seamFacetSplitPolygons,
+  seamFacetSplitReport,
+  seamOverlapDiagnostics,
+  seamOverlapPolygons,
+  seamOverlapReport,
   cullInteriorPolygons,
   cameraCullNormalGroups,
   cameraCullNormalGroupsFromPolygons,
@@ -200,11 +214,14 @@ export {
   buildSceneContext,
   computeSceneBbox,
   BASE_TILE,
+  DEFAULT_SEAM_BLEED,
   DEFAULT_CAMERA_STATE,
   DEFAULT_PROJECTION,
   normalizeInvertMultiplier,
   createPolyAnimationMixer,
   optimizeAnimatedMeshPolygons,
+  DEFAULT_SEAM_FACET_SPLIT_OPTIONS,
+  DEFAULT_SEAM_OVERLAP_OPTIONS,
   LoopOnce,
   LoopRepeat,
   LoopPingPong,
diff --git a/packages/vue/src/scene/PolyMesh.ts b/packages/vue/src/scene/PolyMesh.ts
index a4bbb8a3..397fa411 100644
--- a/packages/vue/src/scene/PolyMesh.ts
+++ b/packages/vue/src/scene/PolyMesh.ts
@@ -19,9 +19,16 @@
 import { defineComponent, h, computed, inject, onMounted, onBeforeUnmount, ref, watch } from "vue";
 import type { PropType, VNode, CSSProperties } from "vue";
 import type { MeshResolution, Polygon, PolyTextureLightingMode, Vec3 } from "@layoutit/polycss-core";
-import { computeSceneBbox, inverseRotateVec3, findOverlappingPolygonDuplicates, parseHexColor } from "@layoutit/polycss-core";
+import {
+  computeSceneBbox,
+  DEFAULT_SEAM_BLEED,
+  inverseRotateVec3,
+  findOverlappingPolygonDuplicates,
+  parseHexColor,
+} from "@layoutit/polycss-core";
 import { usePolyMesh } from "./useMesh";
 import {
+  buildSeamBleedPolygonEdges,
   buildTextureEdgeRepairSets,
   computeTextureAtlasPlan,
   cssBorderShapeForPlan,
@@ -29,6 +36,7 @@ import {
   isProjectiveQuadPlan,
   isSolidTrianglePlan,
   type TextureQuality,
+  type PolySeamBleed,
   type SolidPaintDefaults,
   renderTextureBorderShapePoly,
   renderTextureAtlasPoly,
@@ -79,6 +87,8 @@ export interface PolyMeshProps extends InteractionProps {
    *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
    *  raster scale and the 64px sprite. */
   textureQuality?: TextureQuality;
+  /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+  seamBleed?: PolySeamBleed;
   /**
    * When `true` and the scene is in dynamic lighting mode, the renderer emits
    * a flat shadow leaf sibling for each non-duplicate polygon. The shadow is
@@ -153,6 +163,7 @@ export const PolyMesh = defineComponent({
     autoCenter: { type: Boolean, default: false },
     textureLighting: { type: String as PropType<PolyTextureLightingMode>, default: undefined },
     textureQuality: { type: [Number, String] as PropType<TextureQuality>, default: undefined },
+    seamBleed: { type: [Number, String] as PropType<PolySeamBleed>, default: undefined },
     castShadow: { type: Boolean as PropType<boolean>, default: false },
     meshResolution: { type: String as PropType<MeshResolution>, default: undefined },
     class: { type: String },
@@ -218,6 +229,7 @@ export const PolyMesh = defineComponent({
       () => props.textureLighting ?? sceneCtx?.value.textureLighting ?? "baked",
     );
     const atlasStrategies = computed(() => sceneCtx?.value.strategies);
+    const atlasSeamBleed = computed(() => props.seamBleed ?? sceneCtx?.value.seamBleed ?? DEFAULT_SEAM_BLEED);
     const atlasDirectional = computed(() =>
       atlasTextureLighting.value === "dynamic" ? undefined : sceneCtx?.value.directionalLight,
     );
@@ -264,10 +276,22 @@ export const PolyMesh = defineComponent({
     const textureAtlasPlans = computed(() => {
       if (!atlasAutoRender) return [];
       const repairEdges = buildTextureEdgeRepairSets(polygons.value);
+      const seamBleedEdges = atlasSeamBleed.value === "auto" || (
+        typeof atlasSeamBleed.value === "number" &&
+        Number.isFinite(atlasSeamBleed.value) &&
+        atlasSeamBleed.value > 0
+      )
+        ? buildSeamBleedPolygonEdges(polygons.value, {
+            directionalLight: bakedDirectional.value,
+            ambientLight: atlasAmbient.value,
+          })
+        : null;
       return polygons.value.map((p, i) =>
         computeTextureAtlasPlan(p, i, {
           directionalLight: bakedDirectional.value,
           ambientLight: atlasAmbient.value,
+          seamBleed: seamBleedEdges?.has(i) ? atlasSeamBleed.value : undefined,
+          seamEdges: seamBleedEdges?.get(i),
           textureEdgeRepairEdges: repairEdges[i],
         }),
       );
@@ -375,6 +399,7 @@ export const PolyMesh = defineComponent({
             ambientLight: atlasAmbient.value,
             textureLighting: atlasTextureLighting.value,
             strategies: atlasStrategies.value,
+            seamBleed: atlasSeamBleed.value,
             colorFrame: ++stableTriangleColorFrame.value,
             colorSteps: 8,
             colorFreezeFrames: 12,
diff --git a/packages/vue/src/scene/PolyScene.ts b/packages/vue/src/scene/PolyScene.ts
index 9dd76dfa..a9fef9fe 100644
--- a/packages/vue/src/scene/PolyScene.ts
+++ b/packages/vue/src/scene/PolyScene.ts
@@ -27,17 +27,19 @@ import type {
   PolyTextureLightingMode,
   Vec3,
 } from "@layoutit/polycss-core";
-import { parseHexColor } from "@layoutit/polycss-core";
+import { DEFAULT_SEAM_BLEED, parseHexColor } from "@layoutit/polycss-core";
 import { PolyCameraContextKey } from "../camera";
 import { usePolySceneContext } from "./useSceneContext";
 import { injectPolyBaseStyles } from "../styles";
 import { PolySceneContextKey, type PolyShadowOptions, type PolyShadowRegistry } from "./sceneContext";
 import {
+  buildSeamBleedPolygonEdges,
   buildTextureEdgeRepairSets,
   computeTextureAtlasPlan,
   isProjectiveQuadPlan,
   isSolidTrianglePlan,
   type TextureQuality,
+  type PolySeamBleed,
   type PolyRenderStrategiesOption,
   renderTextureBorderShapePoly,
   renderTextureAtlasPoly,
@@ -60,6 +62,8 @@ export interface PolySceneProps {
    *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
    *  raster scale and the 64px sprite. */
   textureQuality?: TextureQuality;
+  /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+  seamBleed?: PolySeamBleed;
   /** Opt out of specific render strategies. Disabled strategies fall through the chain (b→i→s, u→i→s, i→s). `<s>` cannot be disabled. */
   strategies?: PolyRenderStrategiesOption;
   /**
@@ -107,6 +111,7 @@ export const PolyScene = defineComponent({
       default: "baked",
     },
     textureQuality: { type: [Number, String] as PropType<TextureQuality>, default: undefined },
+    seamBleed: { type: [Number, String] as PropType<PolySeamBleed>, default: undefined },
     strategies: { type: Object as PropType<PolyRenderStrategiesOption>, default: undefined },
     autoCenter: { type: Boolean, default: false },
     shadow: { type: Object as PropType<PolyShadowOptions>, default: undefined },
@@ -159,6 +164,7 @@ export const PolyScene = defineComponent({
       directionalLight: props.directionalLight,
       ambientLight: props.ambientLight,
       strategies: props.strategies,
+      seamBleed: props.seamBleed ?? DEFAULT_SEAM_BLEED,
       shadow: props.shadow,
       shadowRegistry,
     }));
@@ -244,12 +250,27 @@ export const PolyScene = defineComponent({
       const directionalForAtlas = dynamic ? undefined : props.directionalLight;
       const ambientForAtlas = dynamic ? undefined : props.ambientLight;
       const repairEdges = buildTextureEdgeRepairSets(sceneResult.value.polygons);
+      const seamBleed = props.seamBleed ?? DEFAULT_SEAM_BLEED;
+      const seamBleedEdges = seamBleed === "auto" || (
+        typeof seamBleed === "number" &&
+        Number.isFinite(seamBleed) &&
+        seamBleed > 0
+      )
+        ? buildSeamBleedPolygonEdges(sceneResult.value.polygons, {
+            tileSize: polyContext.value.tileSize,
+            layerElevation: polyContext.value.layerElevation,
+            directionalLight: directionalForAtlas,
+            ambientLight: ambientForAtlas,
+          })
+        : null;
       return sceneResult.value.polygons.map((p, i) =>
         computeTextureAtlasPlan(p, i, {
           tileSize: polyContext.value.tileSize,
           layerElevation: polyContext.value.layerElevation,
           directionalLight: directionalForAtlas,
           ambientLight: ambientForAtlas,
+          seamBleed: seamBleedEdges?.has(i) ? seamBleed : undefined,
+          seamEdges: seamBleedEdges?.get(i),
           textureEdgeRepairEdges: repairEdges[i],
         })
       );
@@ -380,7 +401,6 @@ export const PolyScene = defineComponent({
           return renderTextureTrianglePoly({
             entry: plan,
             textureLighting: ctx.textureLighting ?? "baked",
-            solidTrianglePrimitive: textureAtlas.solidTrianglePrimitive.value,
           });
         }
         if (textureAtlas.useProjectiveQuad.value && isProjectiveQuadPlan(plan)) {
diff --git a/packages/vue/src/scene/atlas/index.ts b/packages/vue/src/scene/atlas/index.ts
index 7193f89e..20b5bccc 100644
--- a/packages/vue/src/scene/atlas/index.ts
+++ b/packages/vue/src/scene/atlas/index.ts
@@ -6,12 +6,15 @@ export type {
   SolidPaintDefaults,
   PolyRenderStrategy,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
   TextureQuality,
 } from "@layoutit/polycss-core";
 export {
   isSolidTrianglePlan,
   isProjectiveQuadPlan,
   buildTextureEdgeRepairSets,
+  buildSeamBleedPolygonEdges,
+  buildSeamBleedPolygonSet,
   cssBorderShapeForPlan,
 } from "@layoutit/polycss-core";
 
diff --git a/packages/vue/src/scene/atlas/solidTriangleStyle.ts b/packages/vue/src/scene/atlas/solidTriangleStyle.ts
index 0c4e4372..137ec40d 100644
--- a/packages/vue/src/scene/atlas/solidTriangleStyle.ts
+++ b/packages/vue/src/scene/atlas/solidTriangleStyle.ts
@@ -1,4 +1,10 @@
-import { parsePureColor } from "@layoutit/polycss-core";
+import {
+  isSolidTrianglePlan,
+  offsetConvexPolygonPointsByEdgeAmounts,
+  parsePureColor,
+  resolveSeamBleed,
+  safePlanSeamBleedAmount,
+} from "@layoutit/polycss-core";
 import type {
   TextureAtlasPlan,
   PolyTextureLightingMode,
@@ -6,7 +12,6 @@ import type {
   Vec2,
   Vec3,
 } from "@layoutit/polycss-core";
-import { isSolidTrianglePlan } from "@layoutit/polycss-core";
 import type { CSSProperties } from "vue";
 
 // ---------------------------------------------------------------------------
@@ -250,6 +255,97 @@ export function offsetConvexPolygonPoints(points: number[], amount: number): num
   return expanded;
 }
 
+function offsetStableTrianglePoints(
+  left: number,
+  right: number,
+  height: number,
+  amount: number,
+): number[] {
+  const baseWidth = left + right;
+  if (
+    amount <= 0 ||
+    height <= BASIS_EPS ||
+    baseWidth <= BASIS_EPS ||
+    !Number.isFinite(left + right + height + amount)
+  ) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+  const leftLen = Math.sqrt(left * left + height * height);
+  const rightLen = Math.sqrt(right * right + height * height);
+  if (leftLen <= BASIS_EPS || rightLen <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+  const leftOffsetX = -amount * height / leftLen;
+  const leftOffsetY = -amount * left / leftLen;
+  const rightOffsetX = amount * height / rightLen;
+  const rightOffsetY = -amount * right / rightLen;
+  const apexLineLeftX = left + leftOffsetX;
+  const apexLineLeftY = leftOffsetY;
+  const apexLineRightX = baseWidth + rightOffsetX;
+  const apexLineRightY = height + rightOffsetY;
+  const det = -height * baseWidth;
+  if (Math.abs(det) <= BASIS_EPS) {
+    return offsetConvexPolygonPoints([left, 0, 0, height, baseWidth, height], amount);
+  }
+  const qx = apexLineLeftX - apexLineRightX;
+  const qy = apexLineLeftY - apexLineRightY;
+  const t = (qx * height + qy * left) / det;
+  let apexX = apexLineRightX - t * right;
+  let apexY = apexLineRightY - t * height;
+  let baseLeftX = -amount * (left + leftLen) / height;
+  let baseLeftY = height + amount;
+  let baseRightX = baseWidth + amount * (right + rightLen) / height;
+  let baseRightY = baseLeftY;
+  const maxMiter = Math.max(2, amount * 4);
+  const apexDx = apexX - left;
+  const apexDy = apexY;
+  const apexMiter = Math.sqrt(apexDx * apexDx + apexDy * apexDy);
+  if (apexMiter > maxMiter) {
+    apexX = left + (apexDx / apexMiter) * maxMiter;
+    apexY = (apexDy / apexMiter) * maxMiter;
+  }
+  const leftMiter = Math.sqrt(baseLeftX * baseLeftX + amount * amount);
+  if (leftMiter > maxMiter) {
+    baseLeftX = (baseLeftX / leftMiter) * maxMiter;
+    baseLeftY = height + (amount / leftMiter) * maxMiter;
+  }
+  const rightDx = baseRightX - baseWidth;
+  const rightMiter = Math.sqrt(rightDx * rightDx + amount * amount);
+  if (rightMiter > maxMiter) {
+    baseRightX = baseWidth + (rightDx / rightMiter) * maxMiter;
+    baseRightY = height + (amount / rightMiter) * maxMiter;
+  }
+  return [apexX, apexY, baseLeftX, baseLeftY, baseRightX, baseRightY];
+}
+
+function triangleEdgeIndexForPair(a: number, b: number): number | undefined {
+  if ((a + 1) % 3 === b) return a;
+  if ((b + 1) % 3 === a) return b;
+  return undefined;
+}
+
+function stableTriangleEdgeAmounts(
+  entry: TextureAtlasPlan,
+  a: number,
+  b: number,
+  c: number,
+  screenPts: number[],
+): number[] | null {
+  const seamEdges = entry.seamBleedEdges;
+  if (!seamEdges?.size) return null;
+  const seamAmount = entry.seamBleed === undefined
+    ? SOLID_TRIANGLE_BLEED
+    : entry.seamBleed;
+  const edgePairs: Array<[number, number]> = [[c, a], [a, b], [b, c]];
+  return edgePairs.map(([from, to], localEdgeIndex) => {
+    const edgeIndex = triangleEdgeIndexForPair(from, to);
+    const requested = edgeIndex !== undefined && seamEdges.has(edgeIndex)
+      ? entry.seamBleedEdgeAmounts?.get(edgeIndex) ?? resolveSeamBleed(seamAmount, SOLID_TRIANGLE_BLEED)
+      : 0;
+    return safePlanSeamBleedAmount(screenPts, localEdgeIndex, requested);
+  });
+}
+
 function cssPoints(vertices: Vec3[], tile: number, elev: number): Vec3[] {
   return vertices.map((v) => [v[1] * tile, v[0] * tile, v[2] * elev]);
 }
@@ -338,7 +434,16 @@ export function solidTriangleStyle(
   const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
   const left = Math.max(0, Math.min(baseLength, apexX));
   const right = Math.max(0, baseLength - left);
-  const expanded = offsetConvexPolygonPoints([left, 0, 0, height, left + right, height], SOLID_TRIANGLE_BLEED);
+  const screenPts = [left, 0, 0, height, left + right, height];
+  const edgeAmounts = stableTriangleEdgeAmounts(entry, a, b, c, screenPts);
+  const expanded = edgeAmounts
+    ? offsetConvexPolygonPointsByEdgeAmounts(screenPts, edgeAmounts)
+    : offsetStableTrianglePoints(
+        left,
+        right,
+        height,
+        resolveSeamBleed(entry.seamBleed, SOLID_TRIANGLE_BLEED),
+      );
   const apex2: Vec2 = [expanded[0], expanded[1]];
   const baseLeft2: Vec2 = [expanded[2], expanded[3]];
   const baseRight2: Vec2 = [expanded[4], expanded[5]];
diff --git a/packages/vue/src/scene/atlas/stableTriangleDom.ts b/packages/vue/src/scene/atlas/stableTriangleDom.ts
index 8f7ff559..797a491b 100644
--- a/packages/vue/src/scene/atlas/stableTriangleDom.ts
+++ b/packages/vue/src/scene/atlas/stableTriangleDom.ts
@@ -4,6 +4,7 @@ import type {
   PolyAmbientLight,
   PolyTextureLightingMode,
   PolyRenderStrategiesOption,
+  PolySeamBleed,
 } from "@layoutit/polycss-core";
 import { isSolidTriangleSupported } from "./detection";
 import {
@@ -36,6 +37,7 @@ export interface StableTriangleDomUpdateOptions {
   ambientLight?: PolyAmbientLight;
   textureLighting?: PolyTextureLightingMode;
   strategies?: PolyRenderStrategiesOption;
+  seamBleed?: PolySeamBleed;
   colorFrame?: number;
   colorSteps?: number;
   colorFreezeFrames?: number;
diff --git a/packages/vue/src/scene/sceneContext.ts b/packages/vue/src/scene/sceneContext.ts
index de730102..4555c24c 100644
--- a/packages/vue/src/scene/sceneContext.ts
+++ b/packages/vue/src/scene/sceneContext.ts
@@ -12,7 +12,7 @@ import type {
   PolyTextureLightingMode,
   Polygon,
 } from "@layoutit/polycss-core";
-import type { PolyRenderStrategiesOption } from "./atlas";
+import type { PolyRenderStrategiesOption, PolySeamBleed } from "./atlas";
 
 export interface PolyShadowOptions {
   color?: string;
@@ -36,6 +36,7 @@ export interface PolySceneContextValue {
   directionalLight?: PolyDirectionalLight;
   ambientLight?: PolyAmbientLight;
   strategies?: PolyRenderStrategiesOption;
+  seamBleed?: PolySeamBleed;
   shadow?: PolyShadowOptions;
   shadowRegistry?: PolyShadowRegistry;
 }
diff --git a/website/src/components/BuilderWorkbench/BuilderWorkbench.tsx b/website/src/components/BuilderWorkbench/BuilderWorkbench.tsx
index a90e4a03..bcc8a81a 100644
--- a/website/src/components/BuilderWorkbench/BuilderWorkbench.tsx
+++ b/website/src/components/BuilderWorkbench/BuilderWorkbench.tsx
@@ -134,7 +134,7 @@ export default function BuilderWorkbench() {
     mapItems((it) => snapPlacement(it, terrainVertices, sceneOptions.gridResolution));
   }, [terrainVertices, mapItems, sceneOptions.gridResolution]);
 
-  const { renderedPolygonsById, renderItems, gridPolygons } = useSceneRender({
+  const { renderedPolygonsById, interiorShellPolygonsById, renderItems, gridPolygons } = useSceneRender({
     placedItems,
     selectedId,
     sceneOptions,
@@ -281,6 +281,7 @@ export default function BuilderWorkbench() {
             placementDraft={!!placementDraft}
             renderItems={renderItems}
             renderedPolygonsById={renderedPolygonsById}
+            interiorShellPolygonsById={interiorShellPolygonsById}
             selectedId={selectedId}
             gizmoMode={gizmoMode}
             gizmoDragging={gizmoDragging}
diff --git a/website/src/components/BuilderWorkbench/builder-workbench.css b/website/src/components/BuilderWorkbench/builder-workbench.css
index 0b4fd29c..fda84852 100644
--- a/website/src/components/BuilderWorkbench/builder-workbench.css
+++ b/website/src/components/BuilderWorkbench/builder-workbench.css
@@ -162,6 +162,30 @@
   pointer-events: none;
 }
 
+.dn-interior-shell-mesh,
+.dn-interior-shell-mesh *,
+.dn-seam-patches-mesh,
+.dn-seam-patches-mesh * {
+  pointer-events: none !important;
+}
+
+.dn-seam-patches-mesh b,
+.dn-seam-patches-mesh i,
+.dn-seam-patches-mesh s,
+.dn-seam-patches-mesh u {
+  backface-visibility: visible !important;
+  -webkit-backface-visibility: visible !important;
+}
+
+.builder-placed.is-mesh-hidden > b,
+.builder-placed.is-mesh-hidden > i,
+.builder-placed.is-mesh-hidden > s,
+.builder-placed.is-mesh-hidden > u,
+.builder-placed.is-mesh-hidden > q,
+.builder-placed.is-mesh-hidden > .polycss-bucket {
+  display: none !important;
+}
+
 /* Force both faces of every wireframe edge to render. polycss applies
    `backface-visibility: hidden` to polygon leaves via a rule
    `.polycss-scene b/i/s/u {...}` that gets injected at runtime AFTER
diff --git a/website/src/components/BuilderWorkbench/components/BuilderDock.tsx b/website/src/components/BuilderWorkbench/components/BuilderDock.tsx
index 752da64f..f495b065 100644
--- a/website/src/components/BuilderWorkbench/components/BuilderDock.tsx
+++ b/website/src/components/BuilderWorkbench/components/BuilderDock.tsx
@@ -53,7 +53,7 @@ export function BuilderDock({
       />
       <DockRendering
         meshResolution={sceneOptions.meshResolution}
-        meshInteriorFill={sceneOptions.meshInteriorFill}
+        interiorFill={sceneOptions.interiorFill}
         solidMaterials={sceneOptions.solidMaterials}
         textureLighting={sceneOptions.textureLighting}
         textureQuality={sceneOptions.textureQuality}
diff --git a/website/src/components/BuilderWorkbench/components/BuilderScene.tsx b/website/src/components/BuilderWorkbench/components/BuilderScene.tsx
index 043117a3..fb326134 100644
--- a/website/src/components/BuilderWorkbench/components/BuilderScene.tsx
+++ b/website/src/components/BuilderWorkbench/components/BuilderScene.tsx
@@ -20,7 +20,7 @@ import type {
   Polygon,
 } from "@layoutit/polycss-react";
 import { type RefObject } from "react";
-import type { SceneOptionsState, GizmoMode } from "../../types";
+import { meshResolutionShowsMesh, type SceneOptionsState, type GizmoMode } from "../../types";
 import type { PlacedItem } from "../types";
 
 export interface BuilderSceneProps {
@@ -38,6 +38,7 @@ export interface BuilderSceneProps {
   placementDraft: boolean;
   renderItems: Array<PlacedItem & { rawPolygons: Polygon[] }>;
   renderedPolygonsById: Map<string, Polygon[]>;
+  interiorShellPolygonsById: Map<string, Polygon[]>;
   selectedId: string | null;
   gizmoMode: GizmoMode;
   gizmoDragging: boolean;
@@ -61,6 +62,7 @@ export function BuilderScene({
   placementDraft,
   renderItems,
   renderedPolygonsById,
+  interiorShellPolygonsById,
   selectedId,
   gizmoMode,
   gizmoDragging,
@@ -73,12 +75,13 @@ export function BuilderScene({
   selected,
 }: BuilderSceneProps) {
   const Cam = sceneOptions.perspective === false ? PolyOrthographicCamera : PolyPerspectiveCamera;
+  const sceneKey = sceneOptions.meshResolution;
   const camProps = sceneOptions.perspective === false
     ? { zoom: sceneOptions.zoom, rotX: sceneOptions.rotX, rotY: sceneOptions.rotY, target: sceneOptions.target }
     : { zoom: sceneOptions.zoom, rotX: sceneOptions.rotX, rotY: sceneOptions.rotY, target: sceneOptions.target, perspective: sceneOptions.perspective };
 
   return (
-    <Cam {...camProps}>
+    <Cam key={sceneKey} {...camProps}>
       {sceneOptions.dragMode === "pan" ? (
         <PolyMapControls
           drag={sceneOptions.interactive && !gizmoDragging}
@@ -158,20 +161,31 @@ export function BuilderScene({
           />
         )}
         <PolySelect onChange={onSelectionChange} clearOnMiss={true}>
-          {renderItems.map((it) => (
-            <PolyMesh
-              key={it.id}
-              ref={getMeshRefCallback(it.id)}
-              id={it.id}
-              polygons={renderedPolygonsById.get(it.id) ?? it.rawPolygons}
-              position={it.position}
-              rotation={it.rotation}
-              scale={it.fitScale * it.scale}
-              castShadow={sceneOptions.castShadow}
-              style={{ cursor: "pointer" }}
-              className={`builder-placed${it.id === selectedId ? " is-selected" : ""}`}
-            />
-          ))}
+          {renderItems.map((it) => {
+            const shell = interiorShellPolygonsById.get(it.id) ?? [];
+            return (
+              <PolyMesh
+                key={it.id}
+                ref={getMeshRefCallback(it.id)}
+                id={it.id}
+                polygons={renderedPolygonsById.get(it.id) ?? it.rawPolygons}
+                position={it.position}
+                rotation={it.rotation}
+                scale={it.fitScale * it.scale}
+                castShadow={sceneOptions.castShadow}
+                style={{ cursor: "pointer" }}
+                className={[
+                  "builder-placed",
+                  it.id === selectedId ? "is-selected" : "",
+                  !meshResolutionShowsMesh(sceneOptions.meshResolution) ? "is-mesh-hidden" : "",
+                ].filter(Boolean).join(" ")}
+              >
+                {shell.length > 0 ? (
+                  <PolyMesh polygons={shell} className="dn-interior-shell-mesh" />
+                ) : null}
+              </PolyMesh>
+            );
+          })}
         </PolySelect>
         {selected && (
           <PolyTransformControls
diff --git a/website/src/components/BuilderWorkbench/defaults.ts b/website/src/components/BuilderWorkbench/defaults.ts
index 239d330f..870d9ece 100644
--- a/website/src/components/BuilderWorkbench/defaults.ts
+++ b/website/src/components/BuilderWorkbench/defaults.ts
@@ -41,7 +41,7 @@ export const DEFAULT_SCENE: SceneOptionsState = {
   matrixPrecision: "exact",
   borderShapePrecision: "exact",
   meshResolution: "lossy",
-  meshInteriorFill: false,
+  interiorFill: false,
   outlinePolygons: false,
   dragMode: "orbit",
   target: [0, 0, 0],
diff --git a/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts b/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
index 56ef06d2..a0d45931 100644
--- a/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
+++ b/website/src/components/BuilderWorkbench/hooks/usePlacementMode.ts
@@ -11,7 +11,7 @@ import type { Bbox } from "../geometry/ghost";
 import { projectScreenToWorldGround } from "../geometry/screenToWorld";
 import { sampleTerrain, rotationForSlope, type TerrainVertices } from "../geometry/terrain";
 import type { PlacedItem, PlacementDraft, TargetMode } from "../types";
-import type { SceneOptionsState } from "../../types";
+import { activeMeshResolution, type SceneOptionsState } from "../../types";
 
 export interface UsePlacementModeOptions {
   sceneOptions: SceneOptionsState;
@@ -65,7 +65,7 @@ export function usePlacementMode({
     try {
       const loaded = await loadPresetModel(preset, PARSER_DEFAULTS);
       const optimized = optimizeMeshPolygons(loaded.rawPolygons, {
-        meshResolution: sceneOptions.meshResolution,
+        meshResolution: activeMeshResolution(sceneOptions.meshResolution),
       });
       const bboxResult = meshBbox(optimized);
       const fitScale = bboxResult.span > 0 ? NORMALIZED_MAX_DIM / bboxResult.span : 1;
diff --git a/website/src/components/BuilderWorkbench/hooks/usePlacements.ts b/website/src/components/BuilderWorkbench/hooks/usePlacements.ts
index aabe54f9..536a57c0 100644
--- a/website/src/components/BuilderWorkbench/hooks/usePlacements.ts
+++ b/website/src/components/BuilderWorkbench/hooks/usePlacements.ts
@@ -1,15 +1,16 @@
 import { useCallback, useRef, useState, type RefObject } from "react";
 import { optimizeMeshPolygons } from "@layoutit/polycss-react";
-import type { MeshResolution, PolyMeshHandle, Vec3 } from "@layoutit/polycss-react";
+import type { PolyMeshHandle, Vec3 } from "@layoutit/polycss-react";
 import type { PresetModel } from "../../GalleryWorkbench/types";
 import { loadPresetModel } from "../../GalleryWorkbench/helpers/loaders";
 import { PARSER_DEFAULTS, NORMALIZED_MAX_DIM } from "../defaults";
 import { meshBbox } from "../geometry/meshBbox";
 import { placeMeshOnFloor } from "../geometry/placement";
 import type { PlacedItem } from "../types";
+import { activeMeshResolution, type WorkbenchMeshResolution } from "../../types";
 
 export interface UsePlacementsOptions {
-  meshResolution: MeshResolution;
+  meshResolution: WorkbenchMeshResolution;
 }
 
 export interface UsePlacementsResult {
@@ -36,6 +37,7 @@ export interface UsePlacementsResult {
 }
 
 export function usePlacements({ meshResolution }: UsePlacementsOptions): UsePlacementsResult {
+  const effectiveMeshResolution = activeMeshResolution(meshResolution);
   const [placedItems, setPlacedItems] = useState<PlacedItem[]>([]);
   const [selectedId, setSelectedId] = useState<string | null>(null);
   const [meshHandlesTick, setMeshHandlesTick] = useState(0);
@@ -93,7 +95,7 @@ export function usePlacements({ meshResolution }: UsePlacementsOptions): UsePlac
     ): Promise<PlacedItem | null> => {
       try {
         const loaded = await loadPresetModel(preset, PARSER_DEFAULTS);
-        const optimized = optimizeMeshPolygons(loaded.rawPolygons, { meshResolution });
+        const optimized = optimizeMeshPolygons(loaded.rawPolygons, { meshResolution: effectiveMeshResolution });
         const bbox = meshBbox(optimized);
         const fitScale = bbox.span > 0 ? NORMALIZED_MAX_DIM / bbox.span : 1;
         const placement = placeMeshOnFloor(worldX, worldY, bbox, fitScale);
@@ -114,7 +116,7 @@ export function usePlacements({ meshResolution }: UsePlacementsOptions): UsePlac
         return null;
       }
     },
-    [meshResolution],
+    [effectiveMeshResolution],
   );
 
   const appendItems = useCallback((items: PlacedItem[]) => {
diff --git a/website/src/components/BuilderWorkbench/hooks/useSceneLoader.ts b/website/src/components/BuilderWorkbench/hooks/useSceneLoader.ts
index bc16edb5..40f6a9ec 100644
--- a/website/src/components/BuilderWorkbench/hooks/useSceneLoader.ts
+++ b/website/src/components/BuilderWorkbench/hooks/useSceneLoader.ts
@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, type RefObject } from "react";
 import { optimizeMeshPolygons } from "@layoutit/polycss-react";
-import type { MeshResolution, PolyFirstPersonControlsHandle, Vec3 } from "@layoutit/polycss-react";
+import type { PolyFirstPersonControlsHandle, Vec3 } from "@layoutit/polycss-react";
 import type { PresetModel } from "../../GalleryWorkbench/types";
 import { loadPresetModel } from "../../GalleryWorkbench/helpers/loaders";
 import { PARSER_DEFAULTS, NORMALIZED_MAX_DIM } from "../defaults";
@@ -9,7 +9,11 @@ import { placeMeshOnFloor } from "../geometry/placement";
 import { SCENE_PRESETS } from "../scenes";
 import { PRESETS } from "../../GalleryWorkbench/presets";
 import type { PlacedItem } from "../types";
-import type { SceneOptionsState } from "../../types";
+import {
+  activeMeshResolution,
+  type SceneOptionsState,
+  type WorkbenchMeshResolution,
+} from "../../types";
 import type { DragMode } from "../../types";
 
 export interface UseSceneLoaderOptions {
@@ -27,7 +31,7 @@ export interface UseSceneLoaderOptions {
   fpvRenderDistance: number;
   targetWorld: Vec3;
   fpvControlsRef: RefObject<PolyFirstPersonControlsHandle | null>;
-  meshResolution: MeshResolution;
+  meshResolution: WorkbenchMeshResolution;
   updateScene: (partial: Partial<SceneOptionsState>) => void;
 }
 
@@ -47,8 +51,8 @@ export function useSceneLoader({
   meshResolution,
   updateScene,
 }: UseSceneLoaderOptions): UseSceneLoaderResult {
-  const meshResolutionRef = useRef(meshResolution);
-  meshResolutionRef.current = meshResolution;
+  const meshResolutionRef = useRef(activeMeshResolution(meshResolution));
+  meshResolutionRef.current = activeMeshResolution(meshResolution);
 
   // Dedupe in-flight loads so the same item can't kick off twice between
   // the setState callback and the next effect tick.
diff --git a/website/src/components/BuilderWorkbench/hooks/useSceneRender.ts b/website/src/components/BuilderWorkbench/hooks/useSceneRender.ts
index 29dc3488..8b7d45d9 100644
--- a/website/src/components/BuilderWorkbench/hooks/useSceneRender.ts
+++ b/website/src/components/BuilderWorkbench/hooks/useSceneRender.ts
@@ -1,9 +1,9 @@
 import { useMemo, type RefObject } from "react";
 import { optimizeMeshPolygons } from "@layoutit/polycss-react";
 import type { PolyFirstPersonControlsHandle, Polygon } from "@layoutit/polycss-react";
-import { interiorFillPolygons } from "../../GalleryWorkbench/helpers/interiorFill";
+import { interiorShellPolygons } from "../../helpers/interiorShell";
 import { useFpvHost, useFpvCull } from "../../fpv";
-import type { SceneOptionsState } from "../../types";
+import { activeMeshResolution, type SceneOptionsState } from "../../types";
 import { buildGridPolygons } from "../geometry/grid";
 import type { TerrainVertices } from "../geometry/terrain";
 import type { PlacedItem } from "../types";
@@ -22,6 +22,7 @@ export interface UseSceneRenderOptions {
 
 export interface UseSceneRenderResult {
   renderedPolygonsById: Map<string, Polygon[]>;
+  interiorShellPolygonsById: Map<string, Polygon[]>;
   renderItems: Array<PlacedItem & { rawPolygons: Polygon[] }>;
   gridPolygons: Polygon[];
 }
@@ -34,17 +35,43 @@ export function useSceneRender({
   updateScene,
   terrainVertices,
 }: UseSceneRenderOptions): UseSceneRenderResult {
+  const effectiveMeshResolution = activeMeshResolution(sceneOptions.meshResolution);
   const renderedPolygonsById = useMemo(() => {
     const out = new Map<string, Polygon[]>();
     for (const it of placedItems) {
       if (it.rawPolygons === null) continue;
       const optimized = optimizeMeshPolygons(it.rawPolygons, {
-        meshResolution: sceneOptions.meshResolution,
+        meshResolution: effectiveMeshResolution,
       });
-      out.set(it.id, sceneOptions.meshInteriorFill ? [...optimized, ...interiorFillPolygons(optimized)] : optimized);
+      if (it.preset.kind === "vox") {
+        out.set(it.id, optimized);
+        continue;
+      }
+      out.set(it.id, optimized);
+    }
+    return out;
+  }, [
+    placedItems,
+    effectiveMeshResolution,
+  ]);
+
+  const interiorShellPolygonsById = useMemo(() => {
+    const out = new Map<string, Polygon[]>();
+    if (!sceneOptions.interiorFill) return out;
+    for (const it of placedItems) {
+      if (it.rawPolygons === null || it.preset.kind === "vox") continue;
+      const optimized = optimizeMeshPolygons(it.rawPolygons, {
+        meshResolution: effectiveMeshResolution,
+      });
+      const shell = interiorShellPolygons(optimized);
+      if (shell.length > 0) out.set(it.id, shell);
     }
     return out;
-  }, [placedItems, sceneOptions.meshResolution, sceneOptions.meshInteriorFill]);
+  }, [
+    placedItems,
+    sceneOptions.interiorFill,
+    effectiveMeshResolution,
+  ]);
 
   // World-space polygons for FPV bbox sampling. `useFpvHost` only reads
   // vertex extents when `dragMode` transitions to "fpv".
@@ -94,5 +121,5 @@ export function useSceneRender({
     [sceneOptions.gridResolution, terrainVertices],
   );
 
-  return { renderedPolygonsById, renderItems, gridPolygons };
+  return { renderedPolygonsById, interiorShellPolygonsById, renderItems, gridPolygons };
 }
diff --git a/website/src/components/BuilderWorkbench/types.ts b/website/src/components/BuilderWorkbench/types.ts
index d17f418e..0ed36c25 100644
--- a/website/src/components/BuilderWorkbench/types.ts
+++ b/website/src/components/BuilderWorkbench/types.ts
@@ -6,8 +6,8 @@ export interface PlacedItem {
   id: string;
   preset: PresetModel;
   /** Pre-optimization polygons from the parser. Stored so we can re-apply
-   *  `optimizeMeshPolygons` + interior-fill at render time when the Dock's
-   *  meshResolution / meshInteriorFill change without re-fetching the asset.
+   *  `optimizeMeshPolygons` at render time when the Dock's meshResolution
+   *  changes without re-fetching the asset.
    *  `null` means the item is placed but its model hasn't been fetched yet —
    *  scene-preset items load lazily on proximity (see the lazy-load effect
    *  below). Pending items have placeholder `position` + `fitScale` until
diff --git a/website/src/components/Dock/folders/useRenderingFolder.ts b/website/src/components/Dock/folders/useRenderingFolder.ts
index 96f74aa7..b56a3a0b 100644
--- a/website/src/components/Dock/folders/useRenderingFolder.ts
+++ b/website/src/components/Dock/folders/useRenderingFolder.ts
@@ -1,9 +1,10 @@
 /**
  * "Rendering" folder of the Dock GUI.
  *
- * Mesh resolution + Interior fill toggles, plus a single "Texture mode"
- * dropdown that collapses the old separate Solid-materials toggle and
- * Texture-lighting selector into one row (disabled | baked | dynamic).
+ * Mesh resolution + interior fill, plus a single
+ * "Texture mode" dropdown that collapses the old separate Solid-materials
+ * toggle and Texture-lighting selector into one row (disabled | baked |
+ * dynamic).
  *
  * Texture quality is a slider with an Auto checkbox injected inside the
  * slider's `.widget`. Auto handling: the React-side `textureQuality` value
@@ -18,17 +19,17 @@
 import { useEffect, useRef } from "react";
 import type { GUI } from "lil-gui";
 import type {
-  MeshResolution,
   PolyTextureLightingMode,
 } from "@layoutit/polycss-react";
 
 import { useFolder, useOption, useSlider, useToggle } from "../primitives";
+import type { WorkbenchMeshResolution } from "../../types";
 
 export type TextureMode = "disabled" | PolyTextureLightingMode;
 
 export interface RenderingFolderInputs {
-  meshResolution: MeshResolution;
-  meshInteriorFill: boolean;
+  meshResolution: WorkbenchMeshResolution;
+  interiorFill: boolean;
   solidMaterials: boolean;
   textureLighting: PolyTextureLightingMode;
   /** Either "auto" or a number in [0.1, 1]. */
@@ -36,17 +37,18 @@ export interface RenderingFolderInputs {
   hasActiveAnimation: boolean;
   hasSpriteLeaves: boolean;
   onUpdateScene: (partial: {
-    meshResolution?: MeshResolution;
-    meshInteriorFill?: boolean;
+    meshResolution?: WorkbenchMeshResolution;
+    interiorFill?: boolean;
     solidMaterials?: boolean;
     textureLighting?: PolyTextureLightingMode;
     textureQuality?: "auto" | number;
   }) => void;
 }
 
-const MESH_RESOLUTION_OPTIONS: Record<string, MeshResolution> = {
+const MESH_RESOLUTION_OPTIONS: Record<string, WorkbenchMeshResolution> = {
   Lossless: "lossless",
   Lossy: "lossy",
+  Disabled: "disabled",
 };
 
 const TEXTURE_MODE_OPTIONS: Record<string, TextureMode> = {
@@ -62,7 +64,7 @@ function textureModeFor(solidMaterials: boolean, textureLighting: PolyTextureLig
 export function useRenderingFolder(parent: GUI | null, inputs: RenderingFolderInputs): void {
   const {
     meshResolution,
-    meshInteriorFill,
+    interiorFill,
     solidMaterials,
     textureLighting,
     textureQuality,
@@ -87,8 +89,8 @@ export function useRenderingFolder(parent: GUI | null, inputs: RenderingFolderIn
     (value) => onUpdateScene({ meshResolution: value }),
   );
 
-  const meshInteriorFillCtrl = useToggle(folder, "Interior fill", meshInteriorFill, (value) =>
-    onUpdateScene({ meshInteriorFill: value }),
+  const interiorFillCtrl = useToggle(folder, "Interior fill", interiorFill, (value) =>
+    onUpdateScene({ interiorFill: value }),
   );
 
   const textureMode = textureModeFor(solidMaterials, textureLighting);
@@ -122,8 +124,12 @@ export function useRenderingFolder(parent: GUI | null, inputs: RenderingFolderIn
 
   useEffect(() => {
     meshResolutionCtrl?.setEnabled(!hasActiveAnimation);
-    meshInteriorFillCtrl?.setEnabled(!hasActiveAnimation);
-  }, [meshResolutionCtrl, meshInteriorFillCtrl, hasActiveAnimation]);
+    interiorFillCtrl?.setEnabled(!hasActiveAnimation);
+  }, [
+    meshResolutionCtrl,
+    interiorFillCtrl,
+    hasActiveAnimation,
+  ]);
 
   useEffect(() => {
     textureModeCtrl?.setVisible(hasSpriteLeaves);
diff --git a/website/src/components/Dock/primitives.tsx b/website/src/components/Dock/primitives.tsx
index e04e23c5..324af181 100644
--- a/website/src/components/Dock/primitives.tsx
+++ b/website/src/components/Dock/primitives.tsx
@@ -204,15 +204,22 @@ export function useSlider(
   range: { min: number; max: number; step?: number },
   value: number,
   onChange: (next: number) => void,
+  options?: { commit?: "change" | "finish" },
 ): DockController<number> | null {
   // Range captured at mount — changing it would require destroying and re-
   // adding the controller. None of our uses change range at runtime.
   const rangeRef = useRef(range);
   rangeRef.current = range;
+  const commitRef = useRef(options?.commit ?? "change");
+  commitRef.current = options?.commit ?? "change";
   return useControllerLifecycle(parent, label, value, onChange, (folder, proxy, cb) => {
     const r = rangeRef.current;
     const ctrl = folder.add(proxy, "value", r.min, r.max, r.step);
-    ctrl.onChange((v: number) => cb(v));
+    if (commitRef.current === "finish") {
+      ctrl.onFinishChange((v: number) => cb(v));
+    } else {
+      ctrl.onChange((v: number) => cb(v));
+    }
     return ctrl;
   });
 }
diff --git a/website/src/components/DocsHeader.astro b/website/src/components/DocsHeader.astro
index 0d9f541f..35d31fa0 100644
--- a/website/src/components/DocsHeader.astro
+++ b/website/src/components/DocsHeader.astro
@@ -30,7 +30,6 @@ const topLinks = [
     active: pathname.startsWith('/api'),
   },
   { href: '/gallery', label: 'Gallery', active: pathname.startsWith('/gallery') },
-  { href: '/builder', label: 'Builder', active: isBuilder },
 ];
 ---
 
diff --git a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
index 9750695b..dc3fb10e 100644
--- a/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
+++ b/website/src/components/GalleryWorkbench/GalleryWorkbench.tsx
@@ -27,7 +27,12 @@ import {
 import { ModelsSidebar } from "../ModelsSidebar";
 import { DropOverlay } from "../DropOverlay";
 import { StatsOverlay } from "../StatsOverlay";
-import type { GizmoMode, SceneOptionsState, DomMetrics } from "../types";
+import {
+  activeMeshResolution,
+  type GizmoMode,
+  type SceneOptionsState,
+  type DomMetrics,
+} from "../types";
 import "./gallery-workbench.css";
 import type {
   PresetModel,
@@ -119,7 +124,7 @@ const DEFAULT_SCENE: SceneOptionsState = {
   matrixPrecision: "exact",
   borderShapePrecision: "exact",
   meshResolution: "lossy",
-  meshInteriorFill: false,
+  interiorFill: false,
   outlinePolygons: false,
   dragMode: "orbit",
   target: [0, 0, 0],
@@ -433,10 +438,11 @@ export default function GalleryWorkbench() {
     [animationClips, selectedAnimation],
   );
   const hasActiveAnimation = activeAnimation !== null;
+  const effectiveMeshResolution = activeMeshResolution(sceneOptions.meshResolution);
   const renderLoaded = useMemo(() => {
-    if (!loaded || !activeAnimation || sceneOptions.meshResolution !== "lossy") return loaded;
+    if (!loaded || !activeAnimation || effectiveMeshResolution !== "lossy") return loaded;
     const optimized = optimizeAnimatedMeshPolygons(loaded.parseResult, {
-      meshResolution: sceneOptions.meshResolution,
+      meshResolution: effectiveMeshResolution,
     });
     if (optimized === loaded.parseResult) return loaded;
     return {
@@ -446,7 +452,7 @@ export default function GalleryWorkbench() {
       polygons: optimized.polygons,
       animation: optimized.animation,
     };
-  }, [loaded, activeAnimation, sceneOptions.meshResolution]);
+  }, [loaded, activeAnimation, effectiveMeshResolution]);
 
   const animation = useAnimationFrames({
     loaded: renderLoaded,
@@ -457,13 +463,19 @@ export default function GalleryWorkbench() {
     reactMeshRef: meshRef,
   });
 
-  const { modelPolygons, interiorFillPolygons, scenePolygons, helperScale, helperTarget } = useScenePolygons({
+  const {
+    modelPolygons,
+    interiorShellPolygons,
+    scenePolygons,
+    helperScale,
+    helperTarget,
+  } = useScenePolygons({
     loaded: renderLoaded,
     hasActiveAnimation,
     meshResolution: sceneOptions.meshResolution,
     renderer: sceneOptions.renderer,
     reactAnimatedPolygons: animation.reactAnimatedPolygons,
-    meshInteriorFill: sceneOptions.meshInteriorFill,
+    interiorFill: sceneOptions.interiorFill,
   });
   const renderModelPolygons = useMemo(
     () => sceneOptions.solidMaterials
@@ -471,17 +483,9 @@ export default function GalleryWorkbench() {
       : modelPolygons,
     [modelPolygons, sceneOptions.solidMaterials, parserOptions.defaultColor],
   );
-  const renderInteriorFillPolygons = useMemo(
-    () => sceneOptions.solidMaterials
-      ? withSolidMaterials(interiorFillPolygons, parserOptions.defaultColor)
-      : interiorFillPolygons,
-    [interiorFillPolygons, sceneOptions.solidMaterials, parserOptions.defaultColor],
-  );
   const renderPolygons = useMemo(
-    () => renderInteriorFillPolygons.length > 0
-      ? [...renderModelPolygons, ...renderInteriorFillPolygons]
-      : renderModelPolygons,
-    [renderModelPolygons, renderInteriorFillPolygons],
+    () => renderModelPolygons,
+    [renderModelPolygons],
   );
   const hasSpriteLeaves = useMemo(
     () => metrics.sprites > 0 || scenePolygons.some(polygonHasTextureData),
@@ -611,6 +615,7 @@ export default function GalleryWorkbench() {
       sceneOptions.textureLighting,
       sceneOptions.textureQuality,
       sceneOptions.solidMaterials ? "solid-materials" : "authored-materials",
+      sceneOptions.interiorFill ? "interior-fill" : "no-interior-fill",
       sceneOptions.autoCenter,
       sceneOptions.perspective === false ? "none" : sceneOptions.perspective,
       loaded?.label ?? "none",
@@ -622,6 +627,7 @@ export default function GalleryWorkbench() {
       sceneOptions.textureLighting,
       sceneOptions.textureQuality,
       sceneOptions.solidMaterials,
+      sceneOptions.interiorFill,
       sceneOptions.autoCenter,
       sceneOptions.perspective,
       loaded?.label,
@@ -737,8 +743,8 @@ export default function GalleryWorkbench() {
             <VanillaScene
               key={rendererDebugKey}
               polygons={renderModelPolygons}
+              interiorShellPolygons={interiorShellPolygons}
               parseResult={renderLoaded?.parseResult}
-              interiorFillPolygons={renderInteriorFillPolygons}
               options={sceneOptions}
               directionalLight={directionalLight}
               ambientLight={ambientLight}
@@ -767,7 +773,7 @@ export default function GalleryWorkbench() {
               rendererDebugKey={rendererDebugKey}
               sceneOptions={sceneOptions}
               scenePolygons={renderModelPolygons}
-              interiorFillPolygons={renderInteriorFillPolygons}
+              interiorShellPolygons={interiorShellPolygons}
               directionalLight={directionalLight}
               ambientLight={ambientLight}
               textureQuality={textureQuality}
@@ -803,7 +809,7 @@ export default function GalleryWorkbench() {
         />
         <DockRendering
           meshResolution={sceneOptions.meshResolution}
-          meshInteriorFill={sceneOptions.meshInteriorFill}
+          interiorFill={sceneOptions.interiorFill}
           solidMaterials={sceneOptions.solidMaterials}
           textureLighting={sceneOptions.textureLighting}
           textureQuality={sceneOptions.textureQuality}
diff --git a/website/src/components/GalleryWorkbench/gallery-workbench.css b/website/src/components/GalleryWorkbench/gallery-workbench.css
index 5ed54a42..3d6575eb 100644
--- a/website/src/components/GalleryWorkbench/gallery-workbench.css
+++ b/website/src/components/GalleryWorkbench/gallery-workbench.css
@@ -377,20 +377,6 @@
   outline: 1px solid rgba(248, 113, 113, 0.75) !important;
 }
 
-.dn-viewport .dn-interior-fill-mesh {
-  pointer-events: none;
-}
-
-.dn-viewport .dn-interior-fill-mesh i {
-  border-shape: circle(50% at 50% 50%) circle(0 at 50% 50%) !important;
-}
-
-.dn-viewport .dn-interior-fill-mesh b,
-.dn-viewport .dn-interior-fill-mesh s {
-  border-radius: 50% !important;
-  overflow: hidden;
-}
-
 .dn-viewport .polycss-camera,
 .dn-vanilla-host {
   width: 100%;
@@ -473,6 +459,31 @@
   filter: brightness(1.25);
   transition: filter 150ms ease-out;
 }
+
+.dn-interior-shell-mesh,
+.dn-interior-shell-mesh *,
+.dn-seam-patches-mesh,
+.dn-seam-patches-mesh * {
+  pointer-events: none !important;
+}
+
+.dn-seam-patches-mesh b,
+.dn-seam-patches-mesh i,
+.dn-seam-patches-mesh s,
+.dn-seam-patches-mesh u {
+  backface-visibility: visible !important;
+  -webkit-backface-visibility: visible !important;
+}
+
+.dn-model-mesh.is-mesh-hidden > b,
+.dn-model-mesh.is-mesh-hidden > i,
+.dn-model-mesh.is-mesh-hidden > s,
+.dn-model-mesh.is-mesh-hidden > u,
+.dn-model-mesh.is-mesh-hidden > q,
+.dn-model-mesh.is-mesh-hidden > .polycss-bucket {
+  display: none !important;
+}
+
 .polycss-mesh i,
 .polycss-mesh b,
 .polycss-mesh s,
diff --git a/website/src/components/GalleryWorkbench/hooks/useScenePolygons.ts b/website/src/components/GalleryWorkbench/hooks/useScenePolygons.ts
index 38b512e0..c3a3d8ee 100644
--- a/website/src/components/GalleryWorkbench/hooks/useScenePolygons.ts
+++ b/website/src/components/GalleryWorkbench/hooks/useScenePolygons.ts
@@ -1,21 +1,22 @@
 import { useMemo } from "react";
 import { optimizeMeshPolygons } from "@layoutit/polycss-react";
 import type { Polygon } from "@layoutit/polycss-react";
+import { interiorShellPolygons as buildInteriorShellPolygons } from "../../helpers/interiorShell";
+import { activeMeshResolution, type WorkbenchMeshResolution } from "../../types";
 import type { LoadedModel } from "../types";
-import { interiorFillPolygons as buildInteriorFillPolygons } from "../helpers/interiorFill";
 
 export interface UseScenePolygonsOptions {
   loaded: LoadedModel | null;
   hasActiveAnimation: boolean;
-  meshResolution: "lossy" | "lossless";
+  meshResolution: WorkbenchMeshResolution;
   renderer: "react" | "vanilla";
   reactAnimatedPolygons: Polygon[] | null;
-  meshInteriorFill: boolean;
+  interiorFill: boolean;
 }
 
 export interface UseScenePolygonsResult {
   modelPolygons: Polygon[];
-  interiorFillPolygons: Polygon[];
+  interiorShellPolygons: Polygon[];
   scenePolygons: Polygon[];
   helperBbox: { minX: number; minY: number; minZ: number; maxX: number; maxY: number; maxZ: number } | null;
   helperScale: number;
@@ -28,8 +29,9 @@ export function useScenePolygons({
   meshResolution,
   renderer,
   reactAnimatedPolygons,
-  meshInteriorFill,
+  interiorFill,
 }: UseScenePolygonsOptions): UseScenePolygonsResult {
+  const effectiveMeshResolution = activeMeshResolution(meshResolution);
   const modelPolygons = useMemo(() => {
     if (!loaded) return [];
     if (hasActiveAnimation) {
@@ -39,36 +41,30 @@ export function useScenePolygons({
     }
     if (loaded.parseResult.voxelSource) return loaded.rawPolygons;
     return optimizeMeshPolygons(loaded.rawPolygons, {
-      meshResolution,
+      meshResolution: effectiveMeshResolution,
     });
   }, [
     loaded,
     hasActiveAnimation,
-    meshResolution,
+    effectiveMeshResolution,
     renderer,
     reactAnimatedPolygons,
   ]);
 
-  const interiorFillPolygons = useMemo(() => {
-    if (hasActiveAnimation || !meshInteriorFill) {
-      return [];
-    }
-    return buildInteriorFillPolygons(modelPolygons);
-  }, [
-    hasActiveAnimation,
-    modelPolygons,
-    meshInteriorFill,
-  ]);
-
-  const scenePolygons = useMemo(
-    () => interiorFillPolygons.length > 0
-      ? [...modelPolygons, ...interiorFillPolygons]
-      : modelPolygons,
-    [modelPolygons, interiorFillPolygons],
+  const interiorShellPolygons = useMemo(
+    () => interiorFill && !hasActiveAnimation && !loaded?.parseResult.voxelSource
+      ? buildInteriorShellPolygons(modelPolygons)
+      : [],
+    [
+      modelPolygons,
+      interiorFill,
+      hasActiveAnimation,
+      loaded,
+    ],
   );
 
   const helperBbox = useMemo(() => {
-    const polygons = scenePolygons;
+    const polygons = modelPolygons;
     if (polygons.length === 0) return null;
     let minX = Infinity, minY = Infinity, minZ = Infinity;
     let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
@@ -80,7 +76,7 @@ export function useScenePolygons({
       }
     }
     return { minX, minY, minZ, maxX, maxY, maxZ };
-  }, [scenePolygons]);
+  }, [modelPolygons]);
 
   const helperScale = useMemo(() => {
     if (!helperBbox) return 30;
@@ -101,5 +97,12 @@ export function useScenePolygons({
     ];
   }, [helperBbox]);
 
-  return { modelPolygons, interiorFillPolygons, scenePolygons, helperBbox, helperScale, helperTarget };
+  return {
+    modelPolygons,
+    interiorShellPolygons,
+    scenePolygons: modelPolygons,
+    helperBbox,
+    helperScale,
+    helperTarget,
+  };
 }
diff --git a/website/src/components/ReactScene/ReactScene.tsx b/website/src/components/ReactScene/ReactScene.tsx
index 13ea2ac5..2f774a0a 100644
--- a/website/src/components/ReactScene/ReactScene.tsx
+++ b/website/src/components/ReactScene/ReactScene.tsx
@@ -24,7 +24,7 @@ import {
   polygonFacesCamera,
   type TextureQuality,
 } from "@layoutit/polycss";
-import type { GizmoMode, SceneOptionsState } from "../types";
+import { meshResolutionShowsMesh, type GizmoMode, type SceneOptionsState } from "../types";
 
 function canCullCameraBackfaces(polygons: Polygon[]): boolean {
   return isVoxelCameraCullableNormalGroups(cameraCullNormalGroupsFromPolygons(polygons));
@@ -43,7 +43,7 @@ export interface ReactSceneProps {
   rendererDebugKey: string;
   sceneOptions: SceneOptionsState;
   scenePolygons: Polygon[];
-  interiorFillPolygons: Polygon[];
+  interiorShellPolygons: Polygon[];
   directionalLight: PolyDirectionalLight;
   ambientLight: PolyAmbientLight;
   textureQuality: TextureQuality;
@@ -69,7 +69,7 @@ export function ReactScene({
   rendererDebugKey,
   sceneOptions,
   scenePolygons,
-  interiorFillPolygons,
+  interiorShellPolygons,
   directionalLight,
   ambientLight,
   textureQuality,
@@ -94,39 +94,29 @@ export function ReactScene({
   const camProps = sceneOptions.perspective === false
     ? { zoom: sceneOptions.zoom, rotX: sceneOptions.rotX, rotY: sceneOptions.rotY, target: sceneOptions.target }
     : { zoom: sceneOptions.zoom, rotX: sceneOptions.rotX, rotY: sceneOptions.rotY, target: sceneOptions.target, perspective: sceneOptions.perspective };
-  const centerPolygons = useMemo(
-    () => interiorFillPolygons.length > 0
-      ? [...scenePolygons, ...interiorFillPolygons]
-      : scenePolygons,
-    [scenePolygons, interiorFillPolygons],
-  );
+  const centerPolygons = scenePolygons;
   const effectiveMeshRotation = sceneOptions.selection ? meshRotation : undefined;
   const canCullScenePolygons = useMemo(
     () => canCullCameraBackfaces(scenePolygons),
     [scenePolygons],
   );
-  const canCullInteriorFillPolygons = useMemo(
-    () => canCullCameraBackfaces(interiorFillPolygons),
-    [interiorFillPolygons],
-  );
   const visibleScenePolygons = useMemo(
     () => canCullScenePolygons
       ? cullCameraBackfaces(scenePolygons, sceneOptions.rotX, sceneOptions.rotY, effectiveMeshRotation)
       : scenePolygons,
     [scenePolygons, canCullScenePolygons, sceneOptions.rotX, sceneOptions.rotY, effectiveMeshRotation],
   );
-  const visibleInteriorFillPolygons = useMemo(
-    () => canCullInteriorFillPolygons
-      ? cullCameraBackfaces(interiorFillPolygons, sceneOptions.rotX, sceneOptions.rotY, effectiveMeshRotation)
-      : interiorFillPolygons,
-    [interiorFillPolygons, canCullInteriorFillPolygons, sceneOptions.rotX, sceneOptions.rotY, effectiveMeshRotation],
-  );
-  const fillMesh = visibleInteriorFillPolygons.length > 0 ? (
+  const shellMesh = interiorShellPolygons.length > 0 ? (
     <PolyMesh
-      polygons={visibleInteriorFillPolygons}
-      className="dn-interior-fill-mesh"
+      polygons={interiorShellPolygons}
+      className="dn-interior-shell-mesh"
     />
   ) : null;
+  const modelClassName = [
+    "dn-model-mesh",
+    !meshResolutionShowsMesh(sceneOptions.meshResolution) ? "is-mesh-hidden" : "",
+    sceneOptions.hoverEffects && hoveredMeshId === (loaded?.label ?? "model") ? "is-hovered" : "",
+  ].filter(Boolean).join(" ");
   return (
     <Cam key={rendererDebugKey} {...camProps}>
       {sceneOptions.dragMode === "pan" ? (
@@ -164,11 +154,7 @@ export function ReactScene({
               polygons={visibleScenePolygons}
               position={meshPosition}
               rotation={meshRotation}
-              className={
-                sceneOptions.hoverEffects && hoveredMeshId === (loaded?.label ?? "model")
-                  ? "dn-model-mesh is-hovered"
-                  : "dn-model-mesh"
-              }
+              className={modelClassName}
               style={sceneOptions.hoverEffects ? { cursor: "pointer" } : undefined}
               onPointerOver={
                 sceneOptions.hoverEffects
@@ -179,7 +165,7 @@ export function ReactScene({
                 sceneOptions.hoverEffects ? () => setHoveredMeshId(null) : undefined
               }
             >
-              {fillMesh}
+              {shellMesh}
             </PolyMesh>
           </PolySelect>
         ) : null}
@@ -187,9 +173,9 @@ export function ReactScene({
           <PolyMesh
             id={loaded?.label ?? "model"}
             polygons={visibleScenePolygons}
-            className="dn-model-mesh"
+            className={modelClassName}
           >
-            {fillMesh}
+            {shellMesh}
           </PolyMesh>
         ) : null}
         {sceneOptions.selection && selectedMeshes.length > 0 && (
diff --git a/website/src/components/VanillaScene/VanillaScene.tsx b/website/src/components/VanillaScene/VanillaScene.tsx
index 5f76d427..b81bf183 100644
--- a/website/src/components/VanillaScene/VanillaScene.tsx
+++ b/website/src/components/VanillaScene/VanillaScene.tsx
@@ -26,7 +26,7 @@ import type {
   PolyTransformControlsHandle,
   Vec3,
 } from "@layoutit/polycss";
-import type { GizmoMode, SceneOptionsState } from "../types";
+import { meshResolutionShowsMesh, type GizmoMode, type SceneOptionsState } from "../types";
 
 export type { GizmoMode, SceneOptionsState };
 
@@ -180,8 +180,8 @@ function lightHelperPosition(
 
 export interface VanillaSceneProps {
   polygons: Polygon[];
+  interiorShellPolygons: Polygon[];
   parseResult?: ParseResult;
-  interiorFillPolygons: Polygon[];
   options: SceneOptionsState;
   directionalLight: PolyDirectionalLight;
   ambientLight: PolyAmbientLight;
@@ -208,8 +208,8 @@ export interface VanillaSceneProps {
 
 export function VanillaScene({
   polygons,
+  interiorShellPolygons,
   parseResult,
-  interiorFillPolygons,
   options,
   directionalLight,
   ambientLight,
@@ -238,7 +238,7 @@ export function VanillaScene({
   const cameraRef = useRef<PolyPerspectiveCameraHandle | PolyOrthographicCameraHandle | null>(null);
   const controlsRef = useRef<PolyControlsHandle | PolyFirstPersonControlsHandle | null>(null);
   const meshHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
-  const interiorFillHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
+  const interiorShellHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
   const axesHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
   const lightHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
   const groundHandleRef = useRef<VanillaPolyMeshHandle | null>(null);
@@ -265,12 +265,12 @@ export function VanillaScene({
     stableDom: boolean;
   } | null>(null);
 
-  const mountInteriorFillInsideModel = useCallback(() => {
+  const mountChildMeshInsideModel = useCallback((child: VanillaPolyMeshHandle | null) => {
     const modelEl = meshHandleRef.current?.element;
-    const fillEl = interiorFillHandleRef.current?.element;
-    if (!modelEl || !fillEl) return;
-    if (fillEl.parentElement !== modelEl || fillEl.nextSibling !== null) {
-      modelEl.appendChild(fillEl);
+    const childEl = child?.element;
+    if (!modelEl || !childEl) return;
+    if (childEl.parentElement !== modelEl || childEl.nextSibling !== null) {
+      modelEl.appendChild(childEl);
     }
   }, []);
 
@@ -338,6 +338,7 @@ export function VanillaScene({
       stableDom: stableDomForMesh,
     };
     meshHandleRef.current.element.classList.add("dn-model-mesh");
+    meshHandleRef.current.element.classList.toggle("is-mesh-hidden", !meshResolutionShowsMesh(options.meshResolution));
     onMeshHandleChangeRef.current?.(meshHandleRef.current);
     return () => {
       // Tear controls down BEFORE destroying the scene — otherwise the
@@ -348,7 +349,7 @@ export function VanillaScene({
       axesHandleRef.current = null;
       lightHandleRef.current = null;
       groundHandleRef.current = null;
-      interiorFillHandleRef.current = null;
+      interiorShellHandleRef.current = null;
       mountedModelRef.current = null;
       meshHandleRef.current = null;
       sceneRef.current = null;
@@ -366,10 +367,15 @@ export function VanillaScene({
     parseResult,
   ]);
 
+  useEffect(() => {
+    meshHandleRef.current?.element.classList.toggle("is-mesh-hidden", !meshResolutionShowsMesh(options.meshResolution));
+  }, [options.meshResolution]);
+
   // Effect 1.5 — replace geometry on the existing mesh. This is the path
-  // used by animated GLB playback. Interior fill remains a non-shadow mesh,
-  // but its wrapper is mounted inside the model mesh wrapper so it inherits
-  // the same mesh transform.
+  // used by animated GLB playback; seam bleed is already baked into the
+  // polygon list before the mesh reaches this renderer. The interior shell
+  // is a separate non-shadow mesh mounted inside the model wrapper so it
+  // inherits the same mesh transform without changing auto-centering.
   useEffect(() => {
     const handle = meshHandleRef.current;
     const scene = sceneRef.current;
@@ -394,21 +400,21 @@ export function VanillaScene({
       };
     }
 
-    let fillHandle = interiorFillHandleRef.current;
-    if (interiorFillPolygons.length === 0) {
-      fillHandle?.dispose();
-      interiorFillHandleRef.current = null;
-    } else if (fillHandle) {
-      fillHandle.setPolygons(interiorFillPolygons, {
+    let shellHandle = interiorShellHandleRef.current;
+    if (interiorShellPolygons.length === 0) {
+      shellHandle?.dispose();
+      interiorShellHandleRef.current = null;
+    } else if (shellHandle) {
+      shellHandle.setPolygons(interiorShellPolygons, {
         merge: false,
         stableDom: stableDomForMesh,
         recomputeAutoCenter: false,
       });
-      mountInteriorFillInsideModel();
+      mountChildMeshInsideModel(shellHandle);
     } else {
-      fillHandle = scene.add(
+      shellHandle = scene.add(
         {
-          polygons: interiorFillPolygons,
+          polygons: interiorShellPolygons,
           objectUrls: [],
           warnings: [],
           dispose: () => {},
@@ -420,9 +426,9 @@ export function VanillaScene({
           castShadow: false,
         },
       );
-      fillHandle.element.classList.add("dn-interior-fill-mesh");
-      interiorFillHandleRef.current = fillHandle;
-      mountInteriorFillInsideModel();
+      shellHandle.element.classList.add("dn-interior-shell-mesh");
+      interiorShellHandleRef.current = shellHandle;
+      mountChildMeshInsideModel(shellHandle);
     }
 
     requestAnimationFrame(() =>
@@ -430,10 +436,10 @@ export function VanillaScene({
     );
   }, [
     polygons,
-    interiorFillPolygons,
+    interiorShellPolygons,
     mergePolygonsForMesh,
     stableDomForMesh,
-    mountInteriorFillInsideModel,
+    mountChildMeshInsideModel,
   ]);
 
   // Effect 1.6 — live-toggle castShadow without rebuilding the scene.
@@ -700,7 +706,7 @@ export function VanillaScene({
     ambientLight,
   ]);
 
-  // Effect 2b — render strategy toggles. Kept separate from Effect 2 because
+  // Effect 2b — render strategy controls. Kept separate from Effect 2 because
   // these options trigger a full mesh re-render in
   // createPolyScene; folding it into the camera/lighting effect would
   // re-render on every rotation/zoom tick.
diff --git a/website/src/components/GalleryWorkbench/helpers/interiorFill.ts b/website/src/components/helpers/interiorShell.ts
similarity index 57%
rename from website/src/components/GalleryWorkbench/helpers/interiorFill.ts
rename to website/src/components/helpers/interiorShell.ts
index 3d5ca6f6..a3adea9f 100644
--- a/website/src/components/GalleryWorkbench/helpers/interiorFill.ts
+++ b/website/src/components/helpers/interiorShell.ts
@@ -1,5 +1,4 @@
-import type { Polygon, Vec3 } from "@layoutit/polycss";
-import { solidColorToHex } from "./debugPrecision";
+import { parsePureColor, type Polygon, type Vec3 } from "@layoutit/polycss-react";
 
 type AxisIndex = 0 | 1 | 2;
 type Point2 = [number, number];
@@ -9,7 +8,7 @@ interface Segment2 {
   b: Point2;
 }
 
-interface InteriorFillInterval {
+interface InteriorShellInterval {
   row: number;
   y: number;
   x0: number;
@@ -17,7 +16,7 @@ interface InteriorFillInterval {
   length: number;
 }
 
-interface InteriorFillSlice {
+interface InteriorShellSlice {
   fixedAxis: AxisIndex;
   axisA: AxisIndex;
   axisB: AxisIndex;
@@ -26,12 +25,17 @@ interface InteriorFillSlice {
   area: number;
 }
 
-interface InteriorFillComponent {
+interface InteriorShellComponent {
   points: Point2[];
   area: number;
 }
 
-export interface PolygonBounds {
+interface DominantSolidSurface {
+  color: string;
+  polygons: Polygon[];
+}
+
+interface PolygonBounds {
   min: Vec3;
   max: Vec3;
   center: Vec3;
@@ -40,30 +44,43 @@ export interface PolygonBounds {
   maxSpan: number;
 }
 
-const INTERIOR_FILL_MIN_MAX_SPAN = 8;
-const INTERIOR_FILL_MIN_DIAGONAL = 10;
-const INTERIOR_FILL_SOLID_COVERAGE_MIN = 0.2;
-const INTERIOR_FILL_MIN_PLANE_AREA_RATIO = 0.12;
-const INTERIOR_FILL_MIN_SLICE_AREA_RATIO = 0.008;
-const INTERIOR_FILL_SCAN_ROWS = 64;
-const INTERIOR_FILL_SLICE_POSITIONS = [0.28, 0.5, 0.72] as const;
-const INTERIOR_FILL_INTERVAL_MIN_LENGTH_RATIO = 0.18;
-const INTERIOR_FILL_INTERVAL_OVERLAP_RATIO = 0.12;
-const INTERIOR_FILL_MIN_INTERVAL_ROWS = 4;
-const INTERIOR_FILL_MAX_COMPONENTS_PER_SLICE = 2;
-const INTERIOR_FILL_INSET_RATIO = 0.025;
-const INTERIOR_FILL_OVAL_SCALE = 0.82;
-const INTERIOR_FILL_OVAL_MARGIN_RATIO = 0.025;
-const INTERIOR_FILL_OVAL_SAMPLES = 9;
-const INTERIOR_FILL_MAX_SLICES = 9;
+export interface InteriorShellOptions {
+  maxSlices?: number;
+  spread?: number;
+  inset?: number;
+  maxLoopPoints?: number;
+}
+
+export const DEFAULT_INTERIOR_SHELL_OPTIONS = {
+  maxSlices: 4,
+  spread: 0.12,
+  inset: 0.12,
+  maxLoopPoints: 32,
+} satisfies Required<InteriorShellOptions>;
+
+const MIN_MAX_SPAN = 8;
+const MIN_DIAGONAL = 10;
+const MIN_SOLID_COVERAGE = 0.2;
+const MIN_PLANE_AREA_RATIO = 0.12;
+const MIN_SLICE_AREA_RATIO = 0.01;
+const SCAN_ROWS = 96;
+const INTERVAL_MIN_LENGTH_RATIO = 0.18;
+const INTERVAL_OVERLAP_RATIO = 0.12;
+const INTERVAL_SUPPORT_RADIUS_ROWS = 2;
+const MIN_INTERVAL_ROWS = 4;
+const MAX_COMPONENTS_PER_SLICE = 1;
 const EPS = 1e-6;
 
-function clamp(value: number, min: number, max: number): number {
-  if (!Number.isFinite(value)) return min;
-  return Math.min(Math.max(value, min), max);
+function solidColorToHex(value: string): string | null {
+  const parsed = parsePureColor(value);
+  if (!parsed || parsed.alpha < 1) return null;
+  const hex = parsed.rgb
+    .map((channel) => Math.max(0, Math.min(255, Math.round(channel))).toString(16).padStart(2, "0"))
+    .join("");
+  return `#${hex}`;
 }
 
-export function polygonArea(polygon: Polygon): number {
+function polygonArea(polygon: Pick<Polygon, "vertices">): number {
   const [origin] = polygon.vertices;
   if (!origin || polygon.vertices.length < 3) return 0;
   let area = 0;
@@ -85,7 +102,7 @@ export function polygonArea(polygon: Polygon): number {
   return area;
 }
 
-export function polygonBounds(polygons: Polygon[]): PolygonBounds | null {
+function polygonBounds(polygons: Polygon[]): PolygonBounds | null {
   let minX = Infinity;
   let minY = Infinity;
   let minZ = Infinity;
@@ -120,10 +137,11 @@ export function polygonBounds(polygons: Polygon[]): PolygonBounds | null {
   };
 }
 
-export function dominantSolidColor(polygons: Polygon[]): string | null {
+function dominantSolidSurface(polygons: Polygon[]): DominantSolidSurface | null {
   let totalWeight = 0;
   let solidWeight = 0;
   const weights = new Map<string, number>();
+  const polygonsByColor = new Map<string, Polygon[]>();
 
   for (const polygon of polygons) {
     const weight = Math.max(polygonArea(polygon), 1e-4);
@@ -134,11 +152,12 @@ export function dominantSolidColor(polygons: Polygon[]): string | null {
     if (!color) continue;
     solidWeight += weight;
     weights.set(color, (weights.get(color) ?? 0) + weight);
+    const sameColor = polygonsByColor.get(color);
+    if (sameColor) sameColor.push(polygon);
+    else polygonsByColor.set(color, [polygon]);
   }
 
-  if (totalWeight <= 0 || solidWeight / totalWeight < INTERIOR_FILL_SOLID_COVERAGE_MIN) {
-    return null;
-  }
+  if (totalWeight <= 0 || solidWeight / totalWeight < MIN_SOLID_COVERAGE) return null;
 
   let bestColor: string | null = null;
   let bestWeight = 0;
@@ -148,88 +167,100 @@ export function dominantSolidColor(polygons: Polygon[]): string | null {
       bestWeight = weight;
     }
   }
-  return bestColor;
+  return bestColor
+    ? { color: bestColor, polygons: polygonsByColor.get(bestColor) ?? [] }
+    : null;
 }
 
-export function interiorFillPolygons(
-  polygons: Polygon[],
-): Polygon[] {
-  const bounds = polygonBounds(polygons);
-  if (!bounds) return [];
-  if (
-    bounds.maxSpan < INTERIOR_FILL_MIN_MAX_SPAN ||
-    bounds.diagonal < INTERIOR_FILL_MIN_DIAGONAL
-  ) {
-    return [];
-  }
+export function interiorShellPolygons(polygons: Polygon[], options: InteriorShellOptions = {}): Polygon[] {
+  const surface = dominantSolidSurface(polygons);
+  if (!surface || surface.polygons.length === 0) return [];
 
-  const color = dominantSolidColor(polygons);
-  if (!color) return [];
+  const bounds = polygonBounds(surface.polygons);
+  if (!bounds) return [];
+  if (bounds.maxSpan < MIN_MAX_SPAN || bounds.diagonal < MIN_DIAGONAL) return [];
 
-  const planes = candidatePlanes(bounds);
-  const slices: InteriorFillSlice[] = [];
-  for (const plane of planes) {
+  const resolved = resolveInteriorShellOptions(options);
+  const slices: InteriorShellSlice[] = [];
+  for (const plane of candidatePlanes(bounds)) {
     const area = bounds.span[plane.axisA] * bounds.span[plane.axisB];
-    for (const position of INTERIOR_FILL_SLICE_POSITIONS) {
+    for (const position of slicePositions(resolved.spread)) {
       const planeValue = bounds.min[plane.fixedAxis] + bounds.span[plane.fixedAxis] * position;
-      slices.push(...interiorFillSlicesAtPlane(
-        polygons,
+      slices.push(...interiorShellSlicesAtPlane(
+        surface.polygons,
         bounds,
         plane.fixedAxis,
         plane.axisA,
         plane.axisB,
         planeValue,
         area,
+        resolved.inset,
       ));
     }
   }
 
-  slices.sort((a, b) => b.area - a.area);
-  return slices
-    .slice(0, INTERIOR_FILL_MAX_SLICES)
-    .flatMap((slice) => interiorFillPolygonsFromSlice(bounds, slice, color));
+  return selectInteriorShellSlices(slices, resolved.maxSlices)
+    .flatMap((slice) => polygonFromSlice(bounds, slice, surface.color, resolved.maxLoopPoints));
 }
 
-function candidatePlanes(bounds: PolygonBounds): Array<{ fixedAxis: AxisIndex; axisA: AxisIndex; axisB: AxisIndex }> {
+function resolveInteriorShellOptions(options: InteriorShellOptions): Required<InteriorShellOptions> {
+  return {
+    maxSlices: Math.max(1, Math.min(8, Math.round(options.maxSlices ?? DEFAULT_INTERIOR_SHELL_OPTIONS.maxSlices))),
+    spread: Math.max(0, Math.min(0.34, options.spread ?? DEFAULT_INTERIOR_SHELL_OPTIONS.spread)),
+    inset: Math.max(0, Math.min(0.18, options.inset ?? DEFAULT_INTERIOR_SHELL_OPTIONS.inset)),
+    maxLoopPoints: Math.max(4, Math.min(64, Math.round(options.maxLoopPoints ?? DEFAULT_INTERIOR_SHELL_OPTIONS.maxLoopPoints))),
+  };
+}
+
+function slicePositions(spread: number): number[] {
+  if (spread <= EPS) return [0.5];
+  return [0.5, 0.5 - spread, 0.5 + spread];
+}
+
+function candidatePlanes(bounds: PolygonBounds): Array<{ fixedAxis: AxisIndex; axisA: AxisIndex; axisB: AxisIndex; area: number }> {
   const candidates = [
     { fixedAxis: 2 as AxisIndex, axisA: 0 as AxisIndex, axisB: 1 as AxisIndex, area: bounds.span[0] * bounds.span[1] },
     { fixedAxis: 1 as AxisIndex, axisA: 0 as AxisIndex, axisB: 2 as AxisIndex, area: bounds.span[0] * bounds.span[2] },
     { fixedAxis: 0 as AxisIndex, axisA: 1 as AxisIndex, axisB: 2 as AxisIndex, area: bounds.span[1] * bounds.span[2] },
   ].sort((a, b) => b.area - a.area);
-  const minArea = (candidates[0]?.area ?? 0) * INTERIOR_FILL_MIN_PLANE_AREA_RATIO;
+  const minArea = (candidates[0]?.area ?? 0) * MIN_PLANE_AREA_RATIO;
   return candidates.filter((candidate) => candidate.area > minArea);
 }
 
-function interiorFillPolygonsFromSlice(
-  bounds: PolygonBounds,
-  slice: InteriorFillSlice,
-  color: string,
-): Polygon[] {
-  const rect = interiorFillOval2D(slice.points);
-  return rect ? doubleSidedSlicePolygon(bounds, slice, rect, color) : [];
+function selectInteriorShellSlices(slices: InteriorShellSlice[], maxSlices: number): InteriorShellSlice[] {
+  const selected: InteriorShellSlice[] = [];
+  const sorted = [...slices].sort((a, b) => b.area - a.area);
+  for (const slice of sorted) {
+    if (selected.length >= maxSlices) break;
+    const axisCount = selected.filter((current) => current.fixedAxis === slice.fixedAxis).length;
+    if (axisCount >= 2) continue;
+    selected.push(slice);
+  }
+  return selected;
 }
 
-function doubleSidedSlicePolygon(
+function polygonFromSlice(
   bounds: PolygonBounds,
-  slice: InteriorFillSlice,
-  points: Point2[],
+  slice: InteriorShellSlice,
   color: string,
-): [Polygon, Polygon] {
-  const point = ([a, b]: Point2): Vec3 => {
+  maxLoopPoints: number,
+): Polygon[] {
+  const points = simplifyLoop2D(slice.points, maxLoopPoints);
+  if (points.length < 3) return [];
+  const vertices = points.map(([a, b]): Vec3 => {
     const vertex = [...bounds.center] as Vec3;
     vertex[slice.fixedAxis] = slice.planeValue;
     vertex[slice.axisA] = a;
     vertex[slice.axisB] = b;
     return vertex;
-  };
-  const vertices = points.map(point);
+  });
   return [
     { vertices, color },
     { vertices: [...vertices].reverse(), color },
   ];
 }
 
-function interiorFillSlicesAtPlane(
+function interiorShellSlicesAtPlane(
   polygons: Polygon[],
   bounds: PolygonBounds,
   fixedAxis: AxisIndex,
@@ -237,7 +268,8 @@ function interiorFillSlicesAtPlane(
   axisB: AxisIndex,
   planeValue: number,
   candidateArea: number,
-): InteriorFillSlice[] {
+  inset: number,
+): InteriorShellSlice[] {
   const tolerance = Math.max(bounds.diagonal * 1e-5, 1e-4);
   const segments: Segment2[] = [];
   for (const polygon of polygons) {
@@ -246,17 +278,17 @@ function interiorFillSlicesAtPlane(
   }
   if (segments.length < 3) return [];
 
-  const primary = scanlineSliceComponents(segments, false, candidateArea, tolerance);
-  const secondary = scanlineSliceComponents(segments, true, candidateArea, tolerance);
+  const primary = scanlineSliceComponents(segments, false, candidateArea, tolerance, inset);
+  const secondary = scanlineSliceComponents(segments, true, candidateArea, tolerance, inset);
   const components = totalComponentArea(secondary) > totalComponentArea(primary) ? secondary : primary;
-  return components.map((component): InteriorFillSlice => ({
+  return components.map((component): InteriorShellSlice => ({
     fixedAxis,
     axisA,
     axisB,
     planeValue,
     points: component.points,
     area: component.area,
-  })).filter((slice) => slice.area >= candidateArea * INTERIOR_FILL_MIN_SLICE_AREA_RATIO);
+  })).filter((slice) => slice.area >= candidateArea * MIN_SLICE_AREA_RATIO);
 }
 
 function slicePolygonAtAxis(
@@ -269,9 +301,7 @@ function slicePolygonAtAxis(
 ): Segment2 | null {
   const vertices = polygon.vertices;
   if (vertices.length < 3) return null;
-  if (vertices.every((vertex) => Math.abs(vertex[fixedAxis] - planeValue) <= tolerance)) {
-    return null;
-  }
+  if (vertices.every((vertex) => Math.abs(vertex[fixedAxis] - planeValue) <= tolerance)) return null;
 
   const hits: Point2[] = [];
   for (let i = 0; i < vertices.length; i += 1) {
@@ -319,163 +349,101 @@ function scanlineSliceComponents(
   swapAxes: boolean,
   candidateArea: number,
   tolerance: number,
-): InteriorFillComponent[] {
+  inset: number,
+): InteriorShellComponent[] {
   const oriented = segments.map((segment): Segment2 => ({
     a: orientPoint2D(segment.a, swapAxes),
     b: orientPoint2D(segment.b, swapAxes),
   }));
   const intervals = scanlineIntervals(oriented, candidateArea, tolerance);
-  if (intervals.length < INTERIOR_FILL_MIN_INTERVAL_ROWS) return [];
+  if (intervals.length < MIN_INTERVAL_ROWS) return [];
 
   const components = intervalComponents(intervals)
-    .filter((component) => component.length >= INTERIOR_FILL_MIN_INTERVAL_ROWS)
-    .slice(0, INTERIOR_FILL_MAX_COMPONENTS_PER_SLICE);
+    .filter((component) => component.length >= MIN_INTERVAL_ROWS)
+    .slice(0, MAX_COMPONENTS_PER_SLICE);
 
   return components.flatMap((component) => {
-    const loop = loopFromIntervals(component);
+    const safeComponent = insetIntervalComponent(component, inset, candidateArea, tolerance);
+    if (safeComponent.length < MIN_INTERVAL_ROWS) return [];
+    const loop = loopFromIntervals(safeComponent);
     const area = Math.abs(loopArea2D(loop));
-    if (loop.length < 3 || area < candidateArea * INTERIOR_FILL_MIN_SLICE_AREA_RATIO) {
-      return [];
-    }
-    const points = scaleLoopTowardCentroid2D(loop, INTERIOR_FILL_INSET_RATIO)
+    if (loop.length < 3 || area < candidateArea * MIN_SLICE_AREA_RATIO) return [];
+    const points = scaleLoopTowardCentroid2D(loop, inset * 0.75)
       .map((point) => orientPoint2D(point, swapAxes));
     return [{ points, area: Math.abs(loopArea2D(points)) }];
   });
 }
 
-function interiorFillOval2D(points: Point2[]): Point2[] | null {
-  const normal = interiorFillOvalRect2D(points);
-  const transposed = interiorFillOvalRect2D(points.map(transposePoint2D))?.map(transposePoint2D) ?? null;
-  if (!normal) return transposed;
-  if (!transposed) return normal;
-  return Math.abs(loopArea2D(transposed)) > Math.abs(loopArea2D(normal)) ? transposed : normal;
-}
-
-function interiorFillOvalRect2D(points: Point2[]): Point2[] | null {
-  const bounds = bounds2D(points);
-  if (!bounds) return null;
-  const center = loopCentroid2D(points);
-  const centerY = clamp(center[1], bounds.minY + EPS, bounds.maxY - EPS);
-  const centerInterval = widestIntervalAtY2D(points, centerY);
-  if (!centerInterval) return null;
-  const centerX = clamp(center[0], centerInterval[0], centerInterval[1]);
-
-  for (const scale of [INTERIOR_FILL_OVAL_SCALE, 0.68, 0.54, 0.4]) {
-    const halfHeight = bounds.height * scale * 0.5;
-    const halfWidth = bounds.width * scale * 0.5;
-    const y0 = clamp(centerY - halfHeight, bounds.minY, bounds.maxY);
-    const y1 = clamp(centerY + halfHeight, bounds.minY, bounds.maxY);
-    if (y1 - y0 <= EPS) continue;
-
-    let x0 = centerX - halfWidth;
-    let x1 = centerX + halfWidth;
-    for (let i = 0; i < INTERIOR_FILL_OVAL_SAMPLES; i += 1) {
-      const t = INTERIOR_FILL_OVAL_SAMPLES === 1 ? 0.5 : i / (INTERIOR_FILL_OVAL_SAMPLES - 1);
-      const y = y0 + (y1 - y0) * t;
-      const interval = overlappingIntervalAtY2D(points, y, [x0, x1]) ?? widestIntervalAtY2D(points, y);
-      if (!interval) {
-        x1 = x0;
-        break;
-      }
-      x0 = Math.max(x0, interval[0]);
-      x1 = Math.min(x1, interval[1]);
-    }
-    if (x1 - x0 > EPS) {
-      const margin = Math.min(x1 - x0, y1 - y0) * INTERIOR_FILL_OVAL_MARGIN_RATIO;
-      const insetX = Math.min(margin, (x1 - x0) * 0.25);
-      const insetY = Math.min(margin, (y1 - y0) * 0.25);
-      if (x1 - x0 - insetX * 2 <= EPS || y1 - y0 - insetY * 2 <= EPS) continue;
-      return [
-        [x0 + insetX, y0 + insetY],
-        [x1 - insetX, y0 + insetY],
-        [x1 - insetX, y1 - insetY],
-        [x0 + insetX, y1 - insetY],
-      ];
-    }
-  }
-  return null;
-}
+function insetIntervalComponent(
+  component: InteriorShellInterval[],
+  inset: number,
+  candidateArea: number,
+  tolerance: number,
+): InteriorShellInterval[] {
+  const rows = [...component].sort((a, b) => a.row - b.row || b.length - a.length);
+  if (rows.length < MIN_INTERVAL_ROWS) return [];
+  if (inset <= EPS) return rows;
+
+  const trim = Math.min(
+    Math.floor((rows.length - MIN_INTERVAL_ROWS) / 2),
+    Math.max(1, Math.ceil(rows.length * inset * 0.35)),
+  );
+  const trimmed = rows.slice(trim, rows.length - trim);
+  const absoluteMargin = Math.max(Math.sqrt(candidateArea) * 0.004, tolerance * 3);
+
+  const insetRows = trimmed.flatMap((interval): InteriorShellInterval[] => {
+    const margin = Math.max(interval.length * inset * 0.22, absoluteMargin);
+    const x0 = interval.x0 + margin;
+    const x1 = interval.x1 - margin;
+    if (x1 - x0 <= tolerance * 4) return [];
+    return [{
+      ...interval,
+      x0,
+      x1,
+      length: x1 - x0,
+    }];
+  });
 
-function widestIntervalAtY2D(points: Point2[], y: number): [number, number] | null {
-  const intervals = loopIntervalsAtY2D(points, y);
-  let best: [number, number] | null = null;
-  for (const interval of intervals) {
-    if (!best || interval[1] - interval[0] > best[1] - best[0]) best = interval;
-  }
-  return best;
+  return supportedIntervalComponent(insetRows, tolerance);
 }
 
-function overlappingIntervalAtY2D(
-  points: Point2[],
-  y: number,
-  target: [number, number],
-): [number, number] | null {
-  const intervals = loopIntervalsAtY2D(points, y);
-  let best: [number, number] | null = null;
-  let bestOverlap = 0;
-  for (const interval of intervals) {
-    const overlap = Math.min(interval[1], target[1]) - Math.max(interval[0], target[0]);
-    if (overlap > bestOverlap) {
-      best = interval;
-      bestOverlap = overlap;
+function supportedIntervalComponent(
+  component: InteriorShellInterval[],
+  tolerance: number,
+): InteriorShellInterval[] {
+  const rows = [...component].sort((a, b) => a.row - b.row || b.length - a.length);
+  if (rows.length < MIN_INTERVAL_ROWS) return [];
+  const radius = Math.min(INTERVAL_SUPPORT_RADIUS_ROWS, Math.floor((rows.length - 1) / 2));
+  if (radius <= 0) return rows;
+
+  const supported: InteriorShellInterval[] = [];
+  for (let i = 0; i < rows.length; i += 1) {
+    const from = Math.max(0, i - radius);
+    const to = Math.min(rows.length - 1, i + radius);
+    let x0 = rows[i].x0;
+    let x1 = rows[i].x1;
+    for (let j = from; j <= to; j += 1) {
+      x0 = Math.max(x0, rows[j].x0);
+      x1 = Math.min(x1, rows[j].x1);
     }
+    if (x1 - x0 <= tolerance * 4) continue;
+    supported.push({
+      ...rows[i],
+      x0,
+      x1,
+      length: x1 - x0,
+    });
   }
-  return bestOverlap > EPS ? best : null;
-}
 
-function loopIntervalsAtY2D(points: Point2[], y: number): Array<[number, number]> {
-  const xs: number[] = [];
-  for (let i = 0; i < points.length; i += 1) {
-    const a = points[i];
-    const b = points[(i + 1) % points.length];
-    if (Math.abs(b[1] - a[1]) <= EPS) continue;
-    const low = Math.min(a[1], b[1]);
-    const high = Math.max(a[1], b[1]);
-    if (y < low || y >= high) continue;
-    const t = (y - a[1]) / (b[1] - a[1]);
-    xs.push(a[0] + (b[0] - a[0]) * t);
-  }
-  xs.sort((a, b) => a - b);
-  const intervals: Array<[number, number]> = [];
-  for (let i = 0; i + 1 < xs.length; i += 2) {
-    if (xs[i + 1] - xs[i] > EPS) intervals.push([xs[i], xs[i + 1]]);
-  }
-  return intervals;
-}
-
-function bounds2D(points: Point2[]): {
-  minX: number;
-  minY: number;
-  maxX: number;
-  maxY: number;
-  width: number;
-  height: number;
-} | null {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of points) {
-    minX = Math.min(minX, x);
-    minY = Math.min(minY, y);
-    maxX = Math.max(maxX, x);
-    maxY = Math.max(maxY, y);
-  }
-  if (!Number.isFinite(minX) || maxX - minX <= EPS || maxY - minY <= EPS) {
-    return null;
-  }
-  return { minX, minY, maxX, maxY, width: maxX - minX, height: maxY - minY };
-}
-
-function transposePoint2D([x, y]: Point2): Point2 {
-  return [y, x];
+  return intervalComponents(supported)
+    .filter((candidate) => candidate.length >= MIN_INTERVAL_ROWS)[0] ?? [];
 }
 
 function scanlineIntervals(
   segments: Segment2[],
   candidateArea: number,
   tolerance: number,
-): InteriorFillInterval[] {
+): InteriorShellInterval[] {
   let minY = Infinity;
   let maxY = -Infinity;
   for (const segment of segments) {
@@ -484,9 +452,9 @@ function scanlineIntervals(
   }
   if (!Number.isFinite(minY) || maxY - minY <= tolerance) return [];
 
-  const intervals: InteriorFillInterval[] = [];
-  for (let row = 0; row < INTERIOR_FILL_SCAN_ROWS; row += 1) {
-    const y = minY + ((row + 0.5) / INTERIOR_FILL_SCAN_ROWS) * (maxY - minY);
+  const intervals: InteriorShellInterval[] = [];
+  for (let row = 0; row < SCAN_ROWS; row += 1) {
+    const y = minY + ((row + 0.5) / SCAN_ROWS) * (maxY - minY);
     const xs: number[] = [];
     for (const segment of segments) {
       const y0 = segment.a[1];
@@ -513,24 +481,24 @@ function scanlineIntervals(
   if (intervals.length === 0) return [];
   const maxLength = Math.max(...intervals.map((interval) => interval.length));
   const minLength = Math.max(
-    maxLength * INTERIOR_FILL_INTERVAL_MIN_LENGTH_RATIO,
+    maxLength * INTERVAL_MIN_LENGTH_RATIO,
     Math.sqrt(candidateArea) * 0.01,
     tolerance * 4,
   );
   return intervals.filter((interval) => interval.length >= minLength);
 }
 
-function intervalComponents(intervals: InteriorFillInterval[]): InteriorFillInterval[][] {
+function intervalComponents(intervals: InteriorShellInterval[]): InteriorShellInterval[][] {
   const sorted = [...intervals].sort((a, b) => a.row - b.row || b.length - a.length);
-  const components: InteriorFillInterval[][] = [];
-  const active: Array<{ last: InteriorFillInterval; component: InteriorFillInterval[] }> = [];
+  const components: InteriorShellInterval[][] = [];
+  const active: Array<{ last: InteriorShellInterval; component: InteriorShellInterval[] }> = [];
 
   for (const interval of sorted) {
-    let best: { last: InteriorFillInterval; component: InteriorFillInterval[] } | null = null;
+    let best: { last: InteriorShellInterval; component: InteriorShellInterval[] } | null = null;
     for (const current of active) {
       if (interval.row - current.last.row > 1) continue;
       const overlap = Math.min(interval.x1, current.last.x1) - Math.max(interval.x0, current.last.x0);
-      const required = Math.min(interval.length, current.last.length) * INTERIOR_FILL_INTERVAL_OVERLAP_RATIO;
+      const required = Math.min(interval.length, current.last.length) * INTERVAL_OVERLAP_RATIO;
       if (overlap >= required && (!best || current.component.length > best.component.length)) {
         best = current;
       }
@@ -553,8 +521,8 @@ function intervalComponents(intervals: InteriorFillInterval[]): InteriorFillInte
   return components.sort((a, b) => componentArea(b) - componentArea(a));
 }
 
-function loopFromIntervals(intervals: InteriorFillInterval[]): Point2[] {
-  const byRow = new Map<number, InteriorFillInterval>();
+function loopFromIntervals(intervals: InteriorShellInterval[]): Point2[] {
+  const byRow = new Map<number, InteriorShellInterval>();
   for (const interval of intervals) {
     const current = byRow.get(interval.row);
     if (!current || interval.length > current.length) byRow.set(interval.row, interval);
@@ -577,6 +545,38 @@ function cleanLoop2D(points: Point2[]): Point2[] {
   return out;
 }
 
+function simplifyLoop2D(points: Point2[], maxPoints: number): Point2[] {
+  const cleaned = cleanLoop2D(points);
+  if (cleaned.length <= maxPoints) return cleaned;
+
+  const out = [...cleaned];
+  while (out.length > maxPoints) {
+    let removeIndex = -1;
+    let removeScore = Infinity;
+    for (let i = 0; i < out.length; i += 1) {
+      const previous = out[(i + out.length - 1) % out.length];
+      const current = out[i];
+      const next = out[(i + 1) % out.length];
+      const score = triangleArea2D(previous, current, next);
+      if (score < removeScore) {
+        removeScore = score;
+        removeIndex = i;
+      }
+    }
+    if (removeIndex < 0) break;
+    out.splice(removeIndex, 1);
+  }
+  return cleanLoop2D(out);
+}
+
+function triangleArea2D(a: Point2, b: Point2, c: Point2): number {
+  return Math.abs(
+    (a[0] * (b[1] - c[1]) +
+      b[0] * (c[1] - a[1]) +
+      c[0] * (a[1] - b[1])) * 0.5,
+  );
+}
+
 function scaleLoopTowardCentroid2D(points: Point2[], amount: number): Point2[] {
   const center = loopCentroid2D(points);
   return points.map(([x, y]) => [
@@ -585,12 +585,10 @@ function scaleLoopTowardCentroid2D(points: Point2[], amount: number): Point2[] {
   ]);
 }
 
-function componentArea(component: InteriorFillInterval[]): number {
+function componentArea(component: InteriorShellInterval[]): number {
   if (component.length === 0) return 0;
   const rows = [...component].sort((a, b) => a.row - b.row);
-  const rowStep = rows.length > 1
-    ? Math.abs(rows[1].y - rows[0].y)
-    : 1;
+  const rowStep = rows.length > 1 ? Math.abs(rows[1].y - rows[0].y) : 1;
   return rows.reduce((sum, row) => sum + row.length * rowStep, 0);
 }
 
@@ -630,7 +628,7 @@ function loopArea2D(points: Point2[]): number {
   return area / 2;
 }
 
-function totalComponentArea(components: InteriorFillComponent[]): number {
+function totalComponentArea(components: InteriorShellComponent[]): number {
   return components.reduce((sum, component) => sum + component.area, 0);
 }
 
@@ -648,9 +646,9 @@ function loopCentroid2D(points: Point2[]): Point2 {
   for (let i = 0; i < points.length; i += 1) {
     const a = points[i];
     const b = points[(i + 1) % points.length];
-    const cross = a[0] * b[1] - b[0] * a[1];
-    cx += (a[0] + b[0]) * cross;
-    cy += (a[1] + b[1]) * cross;
+    const crossValue = a[0] * b[1] - b[0] * a[1];
+    cx += (a[0] + b[0]) * crossValue;
+    cy += (a[1] + b[1]) * crossValue;
   }
   const factor = 1 / (6 * signedArea);
   return [cx * factor, cy * factor];
diff --git a/website/src/components/types.ts b/website/src/components/types.ts
index bec4f649..1c412899 100644
--- a/website/src/components/types.ts
+++ b/website/src/components/types.ts
@@ -14,6 +14,16 @@ export type DragMode = "orbit" | "pan" | "fpv";
 
 export type PerspectiveMode = "perspective" | "orthographic";
 
+export type WorkbenchMeshResolution = MeshResolution | "disabled";
+
+export function activeMeshResolution(meshResolution: WorkbenchMeshResolution): MeshResolution {
+  return meshResolution === "disabled" ? "lossy" : meshResolution;
+}
+
+export function meshResolutionShowsMesh(meshResolution: WorkbenchMeshResolution): boolean {
+  return meshResolution !== "disabled";
+}
+
 export interface DomMetrics {
   measuredAt: number;
   nodeCount: number;
@@ -50,8 +60,8 @@ export interface SceneOptionsState {
   solidMaterials: boolean;
   matrixPrecision: "exact" | "2" | "3" | "4" | "5" | "6";
   borderShapePrecision: "exact" | "2" | "3" | "4" | "5" | "6";
-  meshResolution: MeshResolution;
-  meshInteriorFill: boolean;
+  meshResolution: WorkbenchMeshResolution;
+  interiorFill: boolean;
   outlinePolygons: boolean;
   dragMode: "orbit" | "pan" | "fpv";
   target: ReactVec3;
diff --git a/website/src/content/docs/api/headless.mdx b/website/src/content/docs/api/headless.mdx
index 6f035ebe..7c050008 100644
--- a/website/src/content/docs/api/headless.mdx
+++ b/website/src/content/docs/api/headless.mdx
@@ -113,7 +113,7 @@ console.log(`${polygons.length} polygons → ${merged.length} after merge`);
 
 ## `optimizeMeshPolygons(polygons, options?)`
 
-Runs the shared mesh-resolution optimizer. It defaults to `meshResolution: "lossy"`. `meshResolution: "lossless"` uses exact candidates; `"lossy"` also tries bounded approximate merge candidates and returns the smallest accepted polygon list.
+Runs the shared mesh-resolution optimizer. It defaults to `meshResolution: "lossy"`. `meshResolution: "lossless"` uses exact candidates; `"lossy"` also tries bounded approximate merge candidates and applies bounded seam repair, so it can add a small number of triangles back to reduce visible crack risk.
 
 ```ts
 import { optimizeMeshPolygons } from "@layoutit/polycss-core";
diff --git a/website/src/content/docs/api/types.mdx b/website/src/content/docs/api/types.mdx
index c3bfe20d..8157fff4 100644
--- a/website/src/content/docs/api/types.mdx
+++ b/website/src/content/docs/api/types.mdx
@@ -199,7 +199,7 @@ interface LoadMeshOptions {
   gltfOptions?: GltfParseOptions;
   /** Forwarded to parseVox. */
   voxOptions?: VoxParseOptions;
-  /** Shared mesh-resolution optimizer. Defaults to "lossy". */
+  /** Shared mesh-resolution optimizer. Defaults to "lossy", including bounded seam repair. */
   meshResolution?: "lossless" | "lossy";
 }
 ```
diff --git a/website/src/content/docs/components/poly-scene.mdx b/website/src/content/docs/components/poly-scene.mdx
index 392c566a..77a3e791 100644
--- a/website/src/content/docs/components/poly-scene.mdx
+++ b/website/src/content/docs/components/poly-scene.mdx
@@ -19,6 +19,7 @@ It's available as a custom element (`<poly-scene>`), via the imperative `createP
 | `ambientLight` | `PolyAmbientLight` | None | Ambient fill light. |
 | `textureLighting` | `"baked" \| "dynamic"` | `"baked"` | Whether texture lighting is rasterized into atlases or computed with CSS variables. |
 | `textureQuality` | `number \| "auto"` | `"auto"` | Atlas bitmap budget and compositor sprite size. Auto caps large runtime bitmaps and uses a larger desktop sprite to avoid Safari/Firefox flattening artifacts; lower numeric values reduce texture memory and detail. |
+| `seamBleed` | `number \| "auto"` | `1.5` | Solid-primitive overscan for detected shared seam edges. `"auto"` fits each edge from the polygon plan; numbers clamp the CSS-pixel amount. |
 | `polygons` | `Polygon[]` | None | (Framework only.) Flat array of polygon objects rendered as direct children. Composes with JSX/slot children. |
 | `children` | None | None | `<poly-mesh>` / `<poly-polygon>` / `<poly-orbit-controls>` (vanilla) or `<PolyMesh>` / `<Poly>` / `<PolyOrbitControls>` (React / Vue). |
 
@@ -36,6 +37,7 @@ It's available as a custom element (`<poly-scene>`), via the imperative `createP
 | `scale` | `number \| Vec3` | Uniform or per-axis scale. |
 | `rotation` | `Vec3` | Euler rotation in degrees `[x, y, z]`. |
 | `textureQuality` | `number \| "auto"` | Atlas bitmap budget and compositor sprite size. React / Vue only; vanilla meshes inherit the scene's `texture-quality`. |
+| `seamBleed` | `number \| "auto"` | Solid-primitive overscan for detected shared seam edges. Defaults to the scene value (`1.5`). `"auto"` fits each edge from the polygon plan; numbers clamp the CSS-pixel amount. React / Vue only; vanilla meshes inherit the scene's `seam-bleed`. |
 | `autoCenter` | `boolean` | Shift the loaded mesh so its bounding-box center sits at the local origin before applying `position`. Useful when assets aren't centered in their file coordinates. |
 | `mtl` | `string` | Companion `.mtl` URL for OBJ models. |
 | `parseOptions` | `UseMeshOptions` | Parser options forwarded to `loadMesh`; `meshResolution` defaults to `"lossy"`. |