partforge 0.40.0 → 0.41.0

package/README.md

@@ -112,9 +112,28 @@ await runtime.ready;   // first successful build (rejects on a first-build error
 runtime.setHostPane("rail");  // narrow layout only: show just the controls
                                // rail ('stage' | 'rail'), suppressing the
                                // built-in tab bar. null hands selection back.
+runtime.setActive(false);      // park the viewer: stop the render loop, release the
+                               // drawing buffer. setActive(true) restores both.
+const off = runtime.onContextLost(() => {});  // WebGL context loss; returns an unsubscribe
 runtime.dispose();     // stops loops, workers, observers, listeners; frees GPU resources
 ```
 
+**Park the viewer when you hide it.** A host that hides the canvas with
+`display: none` needs nothing — the container collapses and the ResizeObserver
+shrinks the drawing buffer for free. A host that hides it any other way
+(`visibility: hidden`, an inactive tab, an off-screen pane) gets no such signal:
+the full-resolution MSAA buffer stays resident and the render loop keeps drawing
+an auto-rotating scene at 60fps that nobody can see. On a phone that is tens of
+megabytes plus continuous GPU work, and it has been enough on its own to get a
+tab killed. Call `runtime.setActive(false)` when the viewer goes off-screen and
+`setActive(true)` when it comes back.
+
+Parking releases both large GPU allocations — the drawing buffer and the cached
+1024² capture target — and stops the render loop. Offscreen captures
+(`captureCurrent`, `captureViews`) keep working while parked and framing is
+unchanged, so a host can still take a build screenshot of a hidden viewer; the
+first capture after parking just re-allocates its target.
+
 Every `elements` entry defaults to the legacy global ID (`#app`, `#controls`,
 `#panel` for `rail`, `#status`/`#busy`/`#phase`, `#part`,
 `#download`/`#download-step`/`#download-3mf`,

package/bin/cli.js

@@ -204,6 +204,9 @@ function printVerify(v) {
     for (const ch of c.checks) {
       const icon = ch.status === "pass" ? "✓" : ch.status === "fail" ? "✗" : ch.status === "warn" ? "⚠" : "·";
       console.log(`    ${icon} ${ch.subpart ?? "_view"} ${ch.metric} ${ch.expr}  (${ch.message})`);
+      // A measurement caveat prints whatever the verdict — "passed, but sampled"
+      // is precisely the line a reader must not miss.
+      if (ch.note) console.log(`        note: ${ch.note}`);
       if (ch.status === "fail" || ch.status === "warn") {
         if (ch.location) console.log(`        at [${ch.location.map((n) => n.toFixed(1)).join(", ")}]`);
         if (ch.hint) console.log(`        hint: ${ch.hint}${ch.pattern ? ` (ERROR-PATTERNS.md#${ch.pattern})` : ""}`);

package/docs/AUTHORING-PARTS.md

@@ -1032,6 +1032,9 @@ carries:
 - `hint` — one self-contained corrective sentence (always present),
 - `pattern` — a stable [ERROR-PATTERNS.md](ERROR-PATTERNS.md) entry ID when one
   applies (follow it with `ERROR-PATTERNS.md#<id>`),
+- `note` — an optional caveat about *how* the value was measured, attached
+  whatever the verdict. Today only `minWall` sets one, when the reading came
+  from a sample rather than every triangle (see below),
 - `location` — `[x, y, z]` in mm where the metric has one: `minWall` (thinnest
   sample point) and `overlaps` (the center of the first offending intersection's
   *bounding box* — a nearby indicator, not an exact point: when a pair overlaps in
@@ -1042,7 +1045,20 @@ carries:
 
 Subpart facts include `minWall` (number or `null` — null exactly when no reading
 exists, e.g. the OCCT backend or min-wall measurement turned off, matching
-`minWallAt`'s null) and `minWallAt` (`[x,y,z]` or `null`); overlap entries are
+`minWallAt`'s null) and `minWallAt` (`[x,y,z]` or `null`). Min wall casts one ray
+per triangle, which is unbounded work on a dense mesh, so past 50,000 triangles
+it casts from a spread, deterministic subset instead — `minWallSampled` (boolean)
+and `minWallSamples` (`{ sampled, total }` or `null`) say whether that happened.
+`sampled` is how many triangles the walk *selected*, not how many rays were
+cast: a degenerate (zero-area) triangle has no normal to cast along and is
+skipped. A sampled reading is an **upper bound**: it can miss a thin spot, never
+invent one — and a sampled run that found no wall at all still reports its
+`minWallSamples`, so a null `minWall` there is "we looked and found nothing",
+not "nobody looked". Everything in `src/parts/` is far below the budget and
+reads exactly. The report's top-level `measuredMinWall` says whether this run
+cast min-wall rays at all — the difference between a null `minWall` that means
+"no wall found" and one that means "not measured".
+Overlap entries are
 `{ a, b, volume, location }`. Pair-distance facts are `gaps` (every sub-part
 pair: `{ a, b, distance, at }`, distance 0 = touching or overlapping) and
 `nearMisses` (the pairs with an unintended-looking gap under 0.5 mm).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/jobs.js

@@ -149,9 +149,21 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // — the main thread only has mesh arrays, so this can only happen here.
       // measure/verify build their own solids via buildView and are cleaned up by
       // the `finally` below.
+      // The two halves overlap: verify always expands a "defaults" case, and for
+      // an unparameterized inspect that case IS this measurement. Seeding it in
+      // (see verify.js's seeding block for the min-wall superset rule that makes
+      // the reuse sound) stops the oracle from rebuilding the same geometry and
+      // re-casting the same min-wall rays a second time. Measuring `{ minWall:
+      // true }` here is what makes the seed usable by any verify run, min-wall
+      // gated or not — the result says so itself (`measuredMinWall`), so this
+      // call and the seed cannot drift apart.
+      const measured = measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true });
       const report = {
-        measure: measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true }),
-        verify: verify(kernel, part, { view: msg.view }),
+        measure: measured,
+        verify: verify(kernel, part, {
+          view: msg.view,
+          seed: { params: msg.params ?? {}, result: measured },
+        }),
       };
       post({ type: "report", ...report });
     }

package/src/framework/mount.js

@@ -31,6 +31,15 @@ export function makeHandle({ ready, dispose, viewer, setParams, listExportablePa
     ready, dispose, setParams,
     captureViews: (viewNames) => viewer.captureCanonicalViews(viewNames),
     captureCurrent: (opts) => viewer.captureCurrent(opts),
+    // Park/unpark the viewer: stops the render loop and frees the drawing
+    // buffer and the cached capture target. For an embedder that hides the
+    // canvas without unmounting it — `visibility: hidden`, an off-screen tab —
+    // where nothing collapses the container and the loop would otherwise run
+    // forever. See the setActive comment in viewer.js for what it costs.
+    setActive: (active) => viewer.setActive(active),
+    // Subscribe to WebGL context loss (returns an unsubscribe), so a host can
+    // say "the 3D view ran out of memory" instead of showing a dead canvas.
+    onContextLost: (listener) => viewer.onContextLost(listener),
     listExportableParts,
     exportParts,
     // Narrow-layout pane selection, for a host that draws its own tab bar
@@ -69,7 +78,7 @@ function createCleanupStack() {
 // mesh-validity cache, and the geometry workers. The app supplies `createWorker(name)`
 // so Vite can bundle the worker (see geometry-service.js).
 //
-// Embedding contract (0.39.0):
+// Embedding contract (0.41.0):
 //   const runtime = mount(part, { createWorker, elements, onBuild, onPick, onDownload });
 //   await runtime.ready;   // first successful build of the default view
 //   runtime.setParams({ openAngle: 45 }); // programmatic edit; pose-only changes apply instantly
@@ -86,6 +95,17 @@ function createCleanupStack() {
 //   runtime.setHostPane("rail");  // narrow layout only: show just the controls
 //                                 // rail ('stage' | 'rail'), suppressing the
 //                                 // built-in tab bar. null hands selection back.
+//   runtime.setActive(false);     // park the viewer: stop the render loop and release
+//                                 // both large GPU allocations (the drawing buffer and
+//                                 // the cached capture target). For a host that hides the
+//                                 // canvas WITHOUT unmounting it (`visibility: hidden`, an
+//                                 // inactive tab) — nothing else can detect that, and the
+//                                 // loop would otherwise render a hidden pane forever.
+//                                 // Captures still work while parked (they re-allocate).
+//                                 // setActive(true) restores it. Safe after dispose().
+//   const off = runtime.onContextLost(() => …);  // WebGL context loss, i.e. the GPU or the
+//                                 // OS gave up — surface it rather than showing a dead
+//                                 // canvas. Returns an unsubscribe.
 //   runtime.dispose();     // full teardown
 // onBuild fires per completed build, so it does NOT fire for a pose-only edit —
 // those are repaired in the viewer and produce no build at all.

package/src/framework/verify-metrics.js

@@ -2,7 +2,9 @@
 // is a hard gate or a warning, and the diagnostics attached to a non-pass check:
 // `hint` (required — the report contract promises one on every fail/warn),
 // `pattern` (optional stable ERROR-PATTERNS.md#<id>), `locate` (optional
-// [x,y,z] source). `manifoldOnly` facts are null on OCCT parts.
+// [x,y,z] source), `note` (optional caveat about HOW the value was measured,
+// attached whatever the status — a passing-but-sampled reading is exactly the
+// case a reader needs told about). `manifoldOnly` facts are null on OCCT parts.
 //
 // This lives in framework/ rather than testing/ deliberately: the set of legal
 // `verify.expect` metrics is part of the PartDefinition CONTRACT, which both the
@@ -32,7 +34,18 @@ export const SUBPART_METRICS = {
   minWall: { kind: "warn", extract: (s) => s.minWall,
     hint: "thinnest wall is at the reported location — increase the governing wall/thickness parameter or reduce the intersecting feature's depth",
     pattern: "minwall-sliver-triangles",
-    locate: (s) => s.minWallAt },
+    locate: (s) => s.minWallAt,
+    // Two sampled outcomes, and the second is the one that most needs saying: a
+    // sampled run that found NO wall reports minWall null, which without this note
+    // is indistinguishable from a part nobody measured. `sampled` counts triangles
+    // the walk selected, not rays cast — degenerate triangles are skipped.
+    note: (s) => {
+      if (!s.minWallSampled || !s.minWallSamples) return null;
+      const { sampled, total } = s.minWallSamples;
+      return s.minWall == null
+        ? `no reading from the ${sampled} of ${total} triangles sampled — not a clean bill of health; a thin spot may exist between samples`
+        : `sampled ${sampled} of ${total} triangles — an upper bound; a thinner spot may exist between samples`;
+    } },
 };
 export const VIEW_METRICS = {
   bbox: { kind: "gate", extract: (r) => r.aggregate.bbox,

package/src/framework/viewer.js

@@ -94,6 +94,10 @@ export function createViewer(container, part) {
   renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
   container.appendChild(renderer.domElement);
 
+  // Declared up here, not beside setActive() below, because the initial resize()
+  // runs during construction and reads it.
+  let active = true;
+
   const scene = new THREE.Scene();
 
   // Light/dark scene palettes (the page chrome is themed separately, via CSS on the
@@ -361,6 +365,10 @@ export function createViewer(container, part) {
   // --- resize ---------------------------------------------------------------
   // Size from the host container (not the window) so embedders control the pane.
   function resize() {
+    // Parked (see setActive): the buffer is deliberately 1x1 and must stay that
+    // way. iOS fires resizes constantly as the URL bar collapses, and every one
+    // of them would otherwise re-allocate a full MSAA buffer for a hidden pane.
+    if (!active) return;
     const w = container.clientWidth || 300, h = container.clientHeight || 150;
     renderer.setSize(w, h);
     camera.aspect = w / h;
@@ -481,12 +489,66 @@ export function createViewer(container, part) {
   }
 
   // --- render loop ----------------------------------------------------------
-  renderer.setAnimationLoop(() => {
+  function renderFrame() {
     controls.update();
     if (cutaway.isEnabled) cutaway.updateForCamera();
     renderer.render(scene, camera);
     cutaway.renderOverlay(renderer, camera);
-  });
+  }
+  renderer.setAnimationLoop(renderFrame);
+
+  // --- active / parked ------------------------------------------------------
+  // For a host that HIDES the viewer without unmounting it. partforge's own
+  // narrow layout uses `display: none` on the stage, which zeroes clientWidth
+  // and lets the ResizeObserver above collapse the buffer for free. An embedder
+  // that cannot do that — partforge-cloud's phone tab bar uses
+  // `visibility: hidden`, because the canvas has to keep its size for build
+  // screenshots — gets no such signal: the full-resolution MSAA drawing buffer
+  // stays resident and this loop keeps rendering an auto-rotating scene at
+  // 60fps behind an invisible pane. On an iPhone that is tens of megabytes and
+  // continuous GPU work nobody can see, so the host has to say so explicitly.
+  //
+  // Parking stops the loop and releases the drawing buffer. `setSize(1, 1,
+  // false)` leaves the canvas element's CSS box alone, so the host's layout
+  // does not move and the pane can be revealed again without a reflow.
+  function setActive(next) {
+    const want = next !== false;
+    if (disposed || want === active) return;
+    active = want;
+    if (!active) {
+      renderer.setAnimationLoop(null);
+      renderer.setSize(1, 1, false);
+      // The cached 1024² 4x-MSAA + stencil capture target is the other large
+      // allocation here — on a phone it is comparable to the canvas itself, so
+      // parking that kept it would leave half the memory behind. Dropping it
+      // costs one re-allocation on the next capture, which a parked viewer
+      // barely notices: the cache only ever hits on an exactly-square request,
+      // and a phone's capture aspect is not square, so those captures were
+      // allocating per call regardless.
+      _rt?.dispose();
+      _rt = null;
+      return;
+    }
+    resize(); // rebuild the buffer at whatever size the container is now
+    renderer.setAnimationLoop(renderFrame);
+  }
+
+  // --- context loss ---------------------------------------------------------
+  // Losing the WebGL context is how a memory-starved phone tells you it gave
+  // up. With no handler the canvas just freezes, indistinguishable from a hang,
+  // and three never re-initialises. preventDefault() is what makes the loss
+  // recoverable (three's own listener re-uploads on restore); the subscribers
+  // let an embedder surface it instead of showing a dead rectangle.
+  const contextLostListeners = new Set();
+  const onContextLostEvent = (event) => {
+    event.preventDefault();
+    for (const listener of [...contextLostListeners]) listener();
+  };
+  renderer.domElement.addEventListener("webglcontextlost", onContextLostEvent);
+  function onContextLost(listener) {
+    contextLostListeners.add(listener);
+    return () => contextLostListeners.delete(listener);
+  }
 
   // --- camera state (read/write for persistence; mount.js owns storage) -------
   function getCameraState() {
@@ -528,6 +590,11 @@ export function createViewer(container, part) {
     disposed = true;
     ro.disconnect();
     renderer.setAnimationLoop(null);
+    // Embedder callbacks must not outlive teardown — a disposed viewer has no
+    // context left to lose, and a surviving listener would keep the embedder's
+    // closure (and whatever it captured) alive.
+    renderer.domElement.removeEventListener("webglcontextlost", onContextLostEvent);
+    contextLostListeners.clear();
     controls.dispose();
     for (const t of flashTimers) clearTimeout(t);
     flashTimers.clear();
@@ -558,6 +625,8 @@ export function createViewer(container, part) {
     captureCanonicalViews,
     captureCurrent,
     setAutoRotate,
+    setActive,
+    onContextLost,
     setTheme,
     getCameraState,
     setCameraState,

package/src/testing/bvh.js

@@ -5,12 +5,56 @@
 // (raycast), nearest surface point (closestPoint), and exact mesh-to-mesh distance
 // (distanceTo). AABB tree, median split on the widest centroid axis, slab ray–box
 // test with pruning.
+//
+// STORAGE — four flat typed arrays, no per-triangle and no per-node JS objects.
+// The nested-array representation this replaced ([[x,y,z],[x,y,z],[x,y,z]] per
+// triangle, wrapped in an object carrying min/max/centroid arrays, hung off object
+// nodes) cost ~950 bytes and ~7 heap objects per triangle: 350 MB for a 400k-triangle
+// mesh, which is what OOM-killed the inspect job in mobile Safari. This costs ~75
+// bytes/triangle for a Manifold soup, and every query allocates only its own stack.
+//
+//   vertices  9 coords per triangle (v0,v1,v2 interleaved), in MESH order — so the
+//             triangle ids in raycast's `tri`/`skipTri` are still mesh indices.
+//             Float32 in, Float32 out: a Manifold soup is already float32, and
+//             widening it would double the footprint without adding a bit of
+//             precision, while a mesh whose positions are plain JS numbers (OCCT,
+//             hand-written fixtures) is kept in a Float64Array. Either copy is
+//             exact, so no reading changes with the representation. Exposed
+//             READ-ONLY: every node bound was computed from these coords at build
+//             time, so writing into the array silently invalidates the whole tree
+//             (queries would prune against boxes that no longer contain their
+//             triangles). Read it through readTriangleInto() rather than
+//             open-coding the stride.
+//   order     Uint32 triangle ids, permuted by the build so each leaf owns a
+//             contiguous run. The vertices themselves never move.
+//   bounds    Float64, 6 per node: [minx,miny,minz, maxx,maxy,maxz]. Kept at double
+//             precision whatever the vertices are — a narrowed bound would have to
+//             be rounded outward to stay conservative, and node bounds are a small
+//             fraction of the total anyway (~0.6 nodes per triangle).
+//   meta      Uint32, 2 per node. A LEAF is [firstIndexIntoOrder, count + 1]; an
+//             INTERNAL node is [rightChildIndex, 0]. The +1 is what lets an empty
+//             mesh's root still read as a leaf instead of as an internal node
+//             pointing at itself. Nodes are laid out in pre-order, so an internal
+//             node's left child is always the next node.
 
 const LEAF = 4; // max triangles per leaf
 
+// Coords per triangle in a `vertices` store: v0,v1,v2 interleaved. The ONE place
+// this layout is decoded outside the queries below — copy triangle `t` of `V` into
+// `out` (9 numbers: x0,y0,z0, x1,y1,z1, x2,y2,z2) and hand callers a reusable
+// buffer, so nobody else has to know the stride and no per-triangle garbage is
+// made. min-wall casts one ray per triangle through this.
+export function readTriangleInto(V, t, out) {
+  const o = t * 9;
+  for (let i = 0; i < 9; i++) out[i] = V[o + i];
+  return out;
+}
+
 // Triangles as [v0,v1,v2] coord triples, from either a Manifold non-indexed soup
 // (positions = 9 floats/triangle, no indices) or an OCCT indexed mesh (positions =
-// 3 floats/vertex + indices = 3 vertex-indices/triangle).
+// 3 floats/vertex + indices = 3 vertex-indices/triangle). A convenience for callers
+// that want plain arrays; the BVH itself reads triangleVertices() below, because
+// this shape costs four heap objects per triangle.
 export function meshTriangles(mesh) {
   const { positions, indices } = mesh;
   if (indices) {
@@ -33,48 +77,68 @@ export function meshTriangles(mesh) {
   return out;
 }
 
-function readTris(mesh) {
-  const triangles = meshTriangles(mesh);
-  return triangles.map(([v0, v1, v2], i) => {
-    const min = [Math.min(v0[0], v1[0], v2[0]), Math.min(v0[1], v1[1], v2[1]), Math.min(v0[2], v1[2], v2[2])];
-    const max = [Math.max(v0[0], v1[0], v2[0]), Math.max(v0[1], v1[1], v2[1]), Math.max(v0[2], v1[2], v2[2])];
-    return { i, v0, v1, v2, min, max, c: [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2] };
-  });
-}
-
-function aabbOf(items) {
-  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
-  for (const it of items) for (let a = 0; a < 3; a++) { if (it.min[a] < min[a]) min[a] = it.min[a]; if (it.max[a] > max[a]) max[a] = it.max[a]; }
-  return { min, max };
+// The same triangles, flat: one typed array of 9 coords per triangle in mesh order.
+// Float32 source → Float32Array (lossless, and half the bytes); anything else →
+// Float64Array (plain JS numbers are doubles and must stay doubles).
+export function triangleVertices(mesh) {
+  const { positions, indices } = mesh;
+  const Store = positions instanceof Float32Array ? Float32Array : Float64Array;
+  if (indices) {
+    const n = indices.length / 3, verts = new Store(n * 9);
+    for (let t = 0; t < n; t++) {
+      const o = t * 9;
+      for (let k = 0; k < 3; k++) {
+        const s = indices[3 * t + k] * 3;
+        verts[o + 3 * k] = positions[s];
+        verts[o + 3 * k + 1] = positions[s + 1];
+        verts[o + 3 * k + 2] = positions[s + 2];
+      }
+    }
+    return verts;
+  }
+  const n = positions.length / 9;
+  if (positions instanceof Float32Array) return positions.slice(0, n * 9);
+  const verts = new Store(n * 9);
+  for (let i = 0; i < n * 9; i++) verts[i] = positions[i];
+  return verts;
 }
 
-function build(items) {
-  const box = aabbOf(items);
-  if (items.length <= LEAF) return { ...box, tris: items };
-  const ext = [box.max[0] - box.min[0], box.max[1] - box.min[1], box.max[2] - box.min[2]];
-  const axis = ext[0] >= ext[1] && ext[0] >= ext[2] ? 0 : ext[1] >= ext[2] ? 1 : 2;
-  const sorted = items.slice().sort((p, q) => p.c[axis] - q.c[axis]);
-  const mid = sorted.length >> 1;
-  const left = sorted.slice(0, mid), right = sorted.slice(mid);
-  if (left.length === 0 || right.length === 0) return { ...box, tris: items }; // degenerate split
-  return { ...box, left: build(left), right: build(right) };
+// Node count for a subtree of `len` triangles. The split is a pure function of the
+// length (median at len>>1, leaf at <= LEAF), so the tree's shape — and therefore
+// its exact size — is known before a single triangle is sorted. That is what lets
+// `bounds`/`meta` be allocated once at the right size rather than grown or trimmed.
+function countNodes(len, memo) {
+  if (len <= LEAF) return 1;
+  const hit = memo.get(len);
+  if (hit !== undefined) return hit;
+  const mid = len >> 1;
+  const n = 1 + countNodes(mid, memo) + countNodes(len - mid, memo);
+  memo.set(len, n);
+  return n;
 }
 
-// slab test: returns the entry distance if the ray meets [min,max] within (tMin,best], else Infinity
-function rayBox(o, invD, min, max, tMin, best) {
+// slab test: does the ray meet node `nb`'s box within (tMin, best]?
+function rayHitsBox(ox, oy, oz, ix, iy, iz, B, nb, tMin, best) {
   let t0 = tMin, t1 = best;
-  for (let a = 0; a < 3; a++) {
-    let lo = (min[a] - o[a]) * invD[a], hi = (max[a] - o[a]) * invD[a];
-    if (lo > hi) { const tmp = lo; lo = hi; hi = tmp; }
-    if (lo > t0) t0 = lo; if (hi < t1) t1 = hi;
-    if (t0 > t1) return Infinity;
-  }
-  return t0;
+  let lo = (B[nb] - ox) * ix, hi = (B[nb + 3] - ox) * ix;
+  if (lo > hi) { const s = lo; lo = hi; hi = s; }
+  if (lo > t0) t0 = lo; if (hi < t1) t1 = hi;
+  if (t0 > t1) return false;
+  lo = (B[nb + 1] - oy) * iy; hi = (B[nb + 4] - oy) * iy;
+  if (lo > hi) { const s = lo; lo = hi; hi = s; }
+  if (lo > t0) t0 = lo; if (hi < t1) t1 = hi;
+  if (t0 > t1) return false;
+  lo = (B[nb + 2] - oz) * iz; hi = (B[nb + 5] - oz) * iz;
+  if (lo > hi) { const s = lo; lo = hi; hi = s; }
+  if (lo > t0) t0 = lo; if (hi < t1) t1 = hi;
+  return t0 <= t1;
 }
 
-// nearest point on triangle to P (Ericson), returns { point, d2 }
-function closestOnTri(P, tri) {
-  const A = tri.v0, B = tri.v1, C = tri.v2;
+// nearest point on triangle `base` of `V` to P (Ericson), returns { point, d2 }
+function closestOnTri(P, V, base) {
+  const A = [V[base], V[base + 1], V[base + 2]];
+  const B = [V[base + 3], V[base + 4], V[base + 5]];
+  const C = [V[base + 6], V[base + 7], V[base + 8]];
   const sub = (p, q) => [p[0]-q[0], p[1]-q[1], p[2]-q[2]];
   const dot = (p, q) => p[0]*q[0] + p[1]*q[1] + p[2]*q[2];
   const add = (p, q) => [p[0]+q[0], p[1]+q[1], p[2]+q[2]];
@@ -98,21 +162,23 @@ function closestOnTri(P, tri) {
   return { point: Q, d2: dot(pq, pq) };
 }
 
-// squared distance from point to an AABB (0 inside)
-function distSqBox(p, min, max) {
-  let s = 0;
-  for (let a = 0; a < 3; a++) { const v = p[a] < min[a] ? min[a] - p[a] : p[a] > max[a] ? p[a] - max[a] : 0; s += v * v; }
-  return s;
+// squared distance from a point to node `nb`'s AABB (0 inside)
+function distSqBox(px, py, pz, B, nb) {
+  const x = px < B[nb] ? B[nb] - px : px > B[nb + 3] ? px - B[nb + 3] : 0;
+  const y = py < B[nb + 1] ? B[nb + 1] - py : py > B[nb + 4] ? py - B[nb + 4] : 0;
+  const z = pz < B[nb + 2] ? B[nb + 2] - pz : pz > B[nb + 5] ? pz - B[nb + 5] : 0;
+  return x * x + y * y + z * z;
 }
 
 // summed extent of a node's AABB — the "which node is larger" heuristic for dual traversal
-const nodeExtent = (n) => (n.max[0] - n.min[0]) + (n.max[1] - n.min[1]) + (n.max[2] - n.min[2]);
+const nodeExtent = (B, nb) => (B[nb + 3] - B[nb]) + (B[nb + 4] - B[nb + 1]) + (B[nb + 5] - B[nb + 2]);
 
-// squared distance between two AABBs (0 when they overlap)
-function boxBoxDistSq(a, b) {
+// squared distance between two nodes' AABBs (0 when they overlap)
+function boxBoxDistSq(A, na, B, nb) {
   let s = 0;
   for (let ax = 0; ax < 3; ax++) {
-    const v = a.min[ax] > b.max[ax] ? a.min[ax] - b.max[ax] : b.min[ax] > a.max[ax] ? b.min[ax] - a.max[ax] : 0;
+    const v = A[na + ax] > B[nb + 3 + ax] ? A[na + ax] - B[nb + 3 + ax]
+      : B[nb + ax] > A[na + 3 + ax] ? B[nb + ax] - A[na + 3 + ax] : 0;
     s += v * v;
   }
   return s;
@@ -146,32 +212,34 @@ function closestSegSeg(P1, Q1, P2, Q2) {
   return { a: A, b: B, d2: dot(pq, pq) };
 }
 
-// exact min distance between two triangles → { d2, a, b } (a on t1, b on t2).
-// Non-intersecting triangles realize their minimum at a vertex-face or edge-edge
-// feature pair; a piercing edge (interior×interior crossing) is caught first with
-// rayTri, since feature distances alone would miss it. rayTri's t is in units of
-// the unnormalized edge direction, so 0 < t <= 1 means the segment itself pierces;
-// parallel/grazing edges return Infinity and the coplanar cases fall to the
-// feature distances.
-function triTriDist(t1, t2) {
-  const edges = (t) => [[t.v0, t.v1], [t.v1, t.v2], [t.v2, t.v0]];
+// exact min distance between triangle `b1` of `V1` and triangle `b2` of `V2`
+// → { d2, a, b } (a on the first, b on the second). Non-intersecting triangles
+// realize their minimum at a vertex-face or edge-edge feature pair; a piercing
+// edge (interior×interior crossing) is caught first with rayTri, since feature
+// distances alone would miss it. rayTri's t is in units of the unnormalized edge
+// direction, so 0 < t <= 1 means the segment itself pierces; parallel/grazing
+// edges return Infinity and the coplanar cases fall to the feature distances.
+function triTriDist(V1, b1, V2, b2) {
+  const verts = (V, b) => [[V[b], V[b+1], V[b+2]], [V[b+3], V[b+4], V[b+5]], [V[b+6], V[b+7], V[b+8]]];
+  const t1 = verts(V1, b1), t2 = verts(V2, b2);
+  const edges = (t) => [[t[0], t[1]], [t[1], t[2]], [t[2], t[0]]];
   for (const [p, q] of edges(t1)) {
     const d = [q[0] - p[0], q[1] - p[1], q[2] - p[2]];
-    const t = rayTri(p, d, t2, 0);
+    const t = rayTri(p[0], p[1], p[2], d[0], d[1], d[2], V2, b2, 0);
     if (t <= 1) { const at = [p[0] + d[0] * t, p[1] + d[1] * t, p[2] + d[2] * t]; return { d2: 0, a: at, b: at }; }
   }
   for (const [p, q] of edges(t2)) {
     const d = [q[0] - p[0], q[1] - p[1], q[2] - p[2]];
-    const t = rayTri(p, d, t1, 0);
+    const t = rayTri(p[0], p[1], p[2], d[0], d[1], d[2], V1, b1, 0);
     if (t <= 1) { const at = [p[0] + d[0] * t, p[1] + d[1] * t, p[2] + d[2] * t]; return { d2: 0, a: at, b: at }; }
   }
   let best = { d2: Infinity, a: null, b: null };
-  for (const v of [t2.v0, t2.v1, t2.v2]) {
-    const r = closestOnTri(v, t1);
+  for (const v of t2) {
+    const r = closestOnTri(v, V1, b1);
     if (r.d2 < best.d2) best = { d2: r.d2, a: r.point, b: v };
   }
-  for (const v of [t1.v0, t1.v1, t1.v2]) {
-    const r = closestOnTri(v, t2);
+  for (const v of t1) {
+    const r = closestOnTri(v, V2, b2);
     if (r.d2 < best.d2) best = { d2: r.d2, a: v, b: r.point };
   }
   for (const [p1, q1] of edges(t1)) for (const [p2, q2] of edges(t2)) {
@@ -181,58 +249,154 @@ function triTriDist(t1, t2) {
   return best;
 }
 
-// Möller–Trumbore; returns t>tMin or Infinity
-function rayTri(o, d, tri, tMin) {
-  const e1 = [tri.v1[0] - tri.v0[0], tri.v1[1] - tri.v0[1], tri.v1[2] - tri.v0[2]];
-  const e2 = [tri.v2[0] - tri.v0[0], tri.v2[1] - tri.v0[1], tri.v2[2] - tri.v0[2]];
-  const p = [d[1] * e2[2] - d[2] * e2[1], d[2] * e2[0] - d[0] * e2[2], d[0] * e2[1] - d[1] * e2[0]];
-  const det = e1[0] * p[0] + e1[1] * p[1] + e1[2] * p[2];
+// Möller–Trumbore against triangle `base` of `V`; returns t>tMin or Infinity.
+// Scalars throughout — this is the inner loop of every raycast, and min-wall casts
+// one ray per sampled triangle.
+function rayTri(ox, oy, oz, dx, dy, dz, V, base, tMin) {
+  const ax = V[base], ay = V[base + 1], az = V[base + 2];
+  const e1x = V[base + 3] - ax, e1y = V[base + 4] - ay, e1z = V[base + 5] - az;
+  const e2x = V[base + 6] - ax, e2y = V[base + 7] - ay, e2z = V[base + 8] - az;
+  const px = dy * e2z - dz * e2y, py = dz * e2x - dx * e2z, pz = dx * e2y - dy * e2x;
+  const det = e1x * px + e1y * py + e1z * pz;
   if (det > -1e-12 && det < 1e-12) return Infinity;
   const inv = 1 / det;
-  const tv = [o[0] - tri.v0[0], o[1] - tri.v0[1], o[2] - tri.v0[2]];
-  const u = (tv[0] * p[0] + tv[1] * p[1] + tv[2] * p[2]) * inv;
+  const tx = ox - ax, ty = oy - ay, tz = oz - az;
+  const u = (tx * px + ty * py + tz * pz) * inv;
   if (u < 0 || u > 1) return Infinity;
-  const q = [tv[1] * e1[2] - tv[2] * e1[1], tv[2] * e1[0] - tv[0] * e1[2], tv[0] * e1[1] - tv[1] * e1[0]];
-  const v = (d[0] * q[0] + d[1] * q[1] + d[2] * q[2]) * inv;
+  const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+  const v = (dx * qx + dy * qy + dz * qz) * inv;
   if (v < 0 || u + v > 1) return Infinity;
-  const t = (e2[0] * q[0] + e2[1] * q[1] + e2[2] * q[2]) * inv;
+  const t = (e2x * qx + e2y * qy + e2z * qz) * inv;
   return t > tMin ? t : Infinity;
 }
 
+// The BVH for `mesh`, memoized in a CALLER-OWNED Map keyed on the mesh object.
+// THE ONE HOME for the caller-owned-Map doctrine; the callers below just point here.
+//
+// Exists because two passes over the same posed meshes each want an index —
+// min-wall casts rays, meshGaps measures pair distances — and building both is a
+// second full index per sub-part at ~77 bytes/triangle. measure() owns the Map and
+// hands the same one (or, for min-wall, the resolved index) to both passes.
+//
+// `cache` is optional everywhere, and with none this is exactly buildBVH: the
+// direct callers that have no second pass to share with (assemblyGaps' bare
+// meshGaps, the tests) keep today's behaviour of building fresh. The Map is
+// deliberately the caller's, not a module-level WeakMap: a WeakMap keyed on
+// meshes would keep an index alive for as long as anything held its mesh, which
+// is the quiet retention this pass exists to remove. Here the index's lifetime is
+// visibly the caller's scope.
+export function cachedBVH(mesh, cache) {
+  if (!cache) return buildBVH(mesh);
+  let bvh = cache.get(mesh);
+  if (!bvh) cache.set(mesh, (bvh = buildBVH(mesh)));
+  return bvh;
+}
+
 export function buildBVH(mesh) {
-  const tris = readTris(mesh);
-  const root = build(tris);
+  const verts = triangleVertices(mesh);
+  const count = verts.length / 9;
+
+  const order = new Uint32Array(count);
+  // AABB-midpoint centroids, one Float64 triple per triangle. Transient: only the
+  // median split reads them, and they are released explicitly below.
+  let cent = new Float64Array(count * 3);
+  for (let t = 0; t < count; t++) {
+    order[t] = t;
+    const o = t * 9;
+    for (let a = 0; a < 3; a++) {
+      const p = verts[o + a], q = verts[o + 3 + a], r = verts[o + 6 + a];
+      const lo = p < q ? (p < r ? p : r) : (q < r ? q : r);
+      const hi = p > q ? (p > r ? p : r) : (q > r ? q : r);
+      cent[t * 3 + a] = (lo + hi) / 2;
+    }
+  }
+
+  const bounds = new Float64Array(countNodes(count, new Map()) * 6);
+  const meta = new Uint32Array(bounds.length / 3);
+  let next = 0;
+
+  // Pre-order emit: a node claims its slot, writes its own AABB, then either
+  // becomes a leaf over order[start, start+len) or sorts that range by the widest
+  // centroid axis and recurses. The left child lands at self+1 by construction, so
+  // only the right child's index needs storing.
+  function emit(start, len) {
+    const self = next++, nb = self * 6;
+    let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+    for (let k = 0; k < len; k++) {
+      const o = order[start + k] * 9;
+      for (let j = 0; j < 9; j += 3) {
+        const x = verts[o + j], y = verts[o + j + 1], z = verts[o + j + 2];
+        if (x < x0) x0 = x; if (x > x1) x1 = x;
+        if (y < y0) y0 = y; if (y > y1) y1 = y;
+        if (z < z0) z0 = z; if (z > z1) z1 = z;
+      }
+    }
+    bounds[nb] = x0; bounds[nb + 1] = y0; bounds[nb + 2] = z0;
+    bounds[nb + 3] = x1; bounds[nb + 4] = y1; bounds[nb + 5] = z1;
+    if (len <= LEAF) { meta[self * 2] = start; meta[self * 2 + 1] = len + 1; return self; }
+    const ex = x1 - x0, ey = y1 - y0, ez = z1 - z0;
+    const axis = ex >= ey && ex >= ez ? 0 : ey >= ez ? 1 : 2;
+    order.subarray(start, start + len).sort((p, q) => cent[p * 3 + axis] - cent[q * 3 + axis]);
+    // No empty-half guard: len > LEAF here (LEAF >= 1), so mid = len>>1 >= 2 and
+    // len - mid >= 3 — both halves always non-empty. The nested-array build this
+    // replaced carried such a check; it was dead code there too, and countNodes()
+    // assumes this same split, so a guard that ever fired would mis-size `bounds`.
+    const mid = len >> 1;
+    emit(start, mid);
+    meta[self * 2] = emit(start + mid, len - mid);
+    meta[self * 2 + 1] = 0;
+    return self;
+  }
+  emit(0, count);
+  // Dropped explicitly, not left to scope: `emit` and the three query closures below
+  // share one function context, so a `cent` merely gone out of use would still be
+  // reachable from every returned BVH — 24 bytes/triangle of dead weight for the
+  // life of the index.
+  cent = null;
 
   function raycast(origin, dir, { tMin = 1e-6, tMax = Infinity, skipTri = -1 } = {}) {
-    const invD = [1 / dir[0], 1 / dir[1], 1 / dir[2]];
+    const ox = origin[0], oy = origin[1], oz = origin[2];
+    const dx = dir[0], dy = dir[1], dz = dir[2];
+    const ix = 1 / dx, iy = 1 / dy, iz = 1 / dz;
     let best = tMax, bestTri = -1;
-    const stack = [root];
+    const stack = [0];
     while (stack.length) {
-      const node = stack.pop();
-      if (rayBox(origin, invD, node.min, node.max, tMin, best) === Infinity) continue;
-      if (node.tris) {
-        for (const tri of node.tris) {
-          if (tri.i === skipTri) continue;
-          const t = rayTri(origin, dir, tri, tMin);
-          if (t < best) { best = t; bestTri = tri.i; }
+      const n = stack.pop();
+      if (!rayHitsBox(ox, oy, oz, ix, iy, iz, bounds, n * 6, tMin, best)) continue;
+      const packed = meta[n * 2 + 1];
+      if (packed) {
+        const start = meta[n * 2];
+        for (let k = 0; k < packed - 1; k++) {
+          const tri = order[start + k];
+          if (tri === skipTri) continue;
+          const t = rayTri(ox, oy, oz, dx, dy, dz, verts, tri * 9, tMin);
+          if (t < best) { best = t; bestTri = tri; }
         }
-      } else { stack.push(node.left, node.right); }
+      } else { stack.push(n + 1, meta[n * 2]); }
     }
     return bestTri === -1 ? null : { t: best, tri: bestTri };
   }
 
   function closestPoint(p) {
+    const px = p[0], py = p[1], pz = p[2];
     let best2 = Infinity, bestPt = null, bestTri = -1;
-    const stack = [root];
+    const stack = [0];
     while (stack.length) {
-      const node = stack.pop();
-      if (distSqBox(p, node.min, node.max) > best2) continue;
-      if (node.tris) {
-        for (const tri of node.tris) { const r = closestOnTri(p, tri); if (r.d2 < best2) { best2 = r.d2; bestPt = r.point; bestTri = tri.i; } }
+      const n = stack.pop();
+      if (distSqBox(px, py, pz, bounds, n * 6) > best2) continue;
+      const packed = meta[n * 2 + 1];
+      if (packed) {
+        const start = meta[n * 2];
+        for (let k = 0; k < packed - 1; k++) {
+          const tri = order[start + k];
+          const r = closestOnTri(p, verts, tri * 9);
+          if (r.d2 < best2) { best2 = r.d2; bestPt = r.point; bestTri = tri; }
+        }
       } else {
         // visit the nearer child first for better pruning
-        const dl = distSqBox(p, node.left.min, node.left.max), dr = distSqBox(p, node.right.min, node.right.max);
-        if (dl < dr) { stack.push(node.right, node.left); } else { stack.push(node.left, node.right); }
+        const l = n + 1, r = meta[n * 2];
+        const dl = distSqBox(px, py, pz, bounds, l * 6), dr = distSqBox(px, py, pz, bounds, r * 6);
+        if (dl < dr) { stack.push(r, l); } else { stack.push(l, r); }
       }
     }
     return { point: bestPt, dist: Math.sqrt(best2), tri: bestTri };
@@ -240,28 +404,31 @@ export function buildBVH(mesh) {
 
   // Exact minimum surface-to-surface distance to another buildBVH result.
   // Dual traversal pruned by AABB–AABB distance; exact triangle–triangle
-  // distance at leaf pairs; early-exits at 0 (touching/intersecting).
+  // distance at leaf pairs; early-exits at 0 (touching/intersecting). The stack
+  // holds node-index PAIRS, pushed and popped two entries at a time.
   function distanceTo(other) {
+    const oV = other.vertices, oB = other._bounds, oM = other._meta, oO = other._order;
     let best = { d2: Infinity, a: null, b: null };
-    const stack = [[root, other._root]];
+    const stack = [0, 0];
     while (stack.length && best.d2 > 0) {
-      const [na, nb] = stack.pop();
-      if (boxBoxDistSq(na, nb) >= best.d2) continue;
-      const aLeaf = !!na.tris, bLeaf = !!nb.tris;
-      if (aLeaf && bLeaf) {
-        for (const ta of na.tris) for (const tb of nb.tris) {
-          const r = triTriDist(ta, tb);
+      const nb = stack.pop(), na = stack.pop();
+      if (boxBoxDistSq(bounds, na * 6, oB, nb * 6) >= best.d2) continue;
+      const pa = meta[na * 2 + 1], pb = oM[nb * 2 + 1];
+      if (pa && pb) {
+        const sa = meta[na * 2], sb = oM[nb * 2];
+        for (let i = 0; i < pa - 1; i++) for (let j = 0; j < pb - 1; j++) {
+          const r = triTriDist(verts, order[sa + i] * 9, oV, oO[sb + j] * 9);
           if (r.d2 < best.d2) best = r;
         }
-      } else if (!aLeaf && (bLeaf || nodeExtent(na) >= nodeExtent(nb))) {
+      } else if (!pa && (pb || nodeExtent(bounds, na * 6) >= nodeExtent(oB, nb * 6))) {
         // descend the larger node; push the nearer child last so it pops first
-        const dl = boxBoxDistSq(na.left, nb), dr = boxBoxDistSq(na.right, nb);
-        if (dl < dr) stack.push([na.right, nb], [na.left, nb]);
-        else stack.push([na.left, nb], [na.right, nb]);
+        const l = na + 1, r = meta[na * 2];
+        const dl = boxBoxDistSq(bounds, l * 6, oB, nb * 6), dr = boxBoxDistSq(bounds, r * 6, oB, nb * 6);
+        if (dl < dr) stack.push(r, nb, l, nb); else stack.push(l, nb, r, nb);
       } else {
-        const dl = boxBoxDistSq(na, nb.left), dr = boxBoxDistSq(na, nb.right);
-        if (dl < dr) stack.push([na, nb.right], [na, nb.left]);
-        else stack.push([na, nb.left], [na, nb.right]);
+        const l = nb + 1, r = oM[nb * 2];
+        const dl = boxBoxDistSq(bounds, na * 6, oB, l * 6), dr = boxBoxDistSq(bounds, na * 6, oB, r * 6);
+        if (dl < dr) stack.push(na, r, na, l); else stack.push(na, l, na, r);
       }
     }
     if (best.a === null) return { distance: Infinity, at: null, pointA: null, pointB: null }; // empty mesh
@@ -269,5 +436,28 @@ export function buildBVH(mesh) {
     return { distance: Math.sqrt(best.d2), at, pointA: best.a, pointB: best.b };
   }
 
-  return { raycast, closestPoint, distanceTo, _root: root };
+  return {
+    raycast, closestPoint, distanceTo,
+    triangleCount: count,
+    // Flat, 9 per triangle, mesh order — min-wall casts from these. READ-ONLY (see
+    // the STORAGE note up top); decode a triangle with readTriangleInto().
+    vertices: verts,
+    // The root node's AABB, [minx,miny,minz, maxx,maxy,maxz] — a copy, so reading
+    // it cannot disturb the tree. It is the mesh's own bounding box over exactly
+    // the vertices the triangles reference, already computed by the build; min-wall
+    // uses it for its default ray cap instead of rescanning mesh.positions.
+    rootBounds: [bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]],
+    // Diagnostic self-report: the four typed arrays' byte lengths, summed at build.
+    // NOT a measurement of retained memory — it counts only what this function
+    // knows it allocated, and cannot see a regression that reintroduces per-triangle
+    // JS objects (test/bvh.test.js weighs that in a child process). What it does
+    // pin, and the child-process bound is too loose to catch, is the index's
+    // COMPOSITION — widening `vertices` to Float64 would show up here.
+    bytesAllocated: verts.byteLength + order.byteLength + bounds.byteLength + meta.byteLength,
+    // Private to this module: only distanceTo reads them, off the OTHER BVH — a
+    // dual traversal walks two trees at once, and JS has no cross-instance private
+    // access to reach for. Nothing outside bvh.js touches them, and nothing should:
+    // they are raw node storage whose meaning is the packing rules in the header.
+    _bounds: bounds, _meta: meta, _order: order,
+  };
 }

package/src/testing/gaps.js

@@ -1,5 +1,5 @@
 import { buildView } from "./build.js";
-import { buildBVH } from "./bvh.js";
+import { cachedBVH } from "./bvh.js";
 
 // A measured pair distance at or below this (mm) counts as touching — absorbs
 // posing float error while staying far below any real print clearance.
@@ -17,12 +17,15 @@ export const pairKey = (a, b) => [a, b].sort().join("×");
 // meshes ([{ name, mesh }] — buildView output). Distance 0 = touching or
 // interpenetrating surfaces; callers filter. Pairs involving an empty mesh are
 // skipped (the watertight gate owns that failure). Pure mesh math — both backends.
+// `bvhCache` is an optional caller-owned Map — see cachedBVH for the doctrine;
+// measure() draws min-wall's index out of the same one, so each sub-part mesh is
+// indexed once, not twice.
 //   → [{ a, b, distance, at: [x,y,z] }]
-export function meshGaps(built) {
+export function meshGaps(built, { bvhCache } = {}) {
   const hasTris = (m) => (m.indices ? m.indices.length > 0 : m.positions.length > 0);
   const bvhs = built
     .filter(({ mesh }) => hasTris(mesh))
-    .map(({ name, mesh }) => ({ name, bvh: buildBVH(mesh) }));
+    .map(({ name, mesh }) => ({ name, bvh: cachedBVH(mesh, bvhCache) }));
   const out = [];
   for (let i = 0; i < bvhs.length; i++) {
     for (let j = i + 1; j < bvhs.length; j++) {

package/src/testing/measure.js

@@ -1,4 +1,5 @@
 import { buildView } from "./build.js";
+import { cachedBVH } from "./bvh.js";
 import { assemblyOverlaps } from "../framework/assembly.js";
 import { meshGaps, pairKey, CONTACT_EPS, GAP_THRESHOLD } from "./gaps.js";
 import { bounds, meshArea, meshCentroid } from "./mesh.js";
@@ -15,14 +16,29 @@ const unionBounds = (list) => list.reduce(
 // the assembly overlap check plus pair gap distances (near misses are reported,
 // never folded into `ok`). All solid facts are read BEFORE assemblyOverlaps,
 // which frees the shared kernel's objects at its end.
-//   → { part, view, subparts[], aggregate, overlaps[], gaps[], nearMisses[], ok }
+//   → { part, view, measuredMinWall, subparts[], aggregate, overlaps[], gaps[],
+//       nearMisses[], ok }
 export function measure(kernel, part, view = Object.keys(part.views)[0], params = {}, opts = {}) {
   const built = buildView(kernel, part, view, params);
+  // ONE BVH per sub-part mesh for this call, shared by the two passes that need
+  // one: min-wall (inward rays per triangle) and meshGaps (pair distances). They
+  // used to index the same mesh objects independently, so every sub-part of a
+  // multi-part view was built into a BVH twice — at ~77 bytes/triangle that is a
+  // whole second index's worth of build time and peak memory for nothing.
+  //
+  // This Map is the caller-owned cache cachedBVH documents — see there for why it
+  // is a Map of ours and not a module-level WeakMap. It dies with the call. Peak
+  // memory is unchanged (meshGaps already held every sub-part's index at once);
+  // the cache just fills it earlier. min-wall indexes exactly one mesh, so it is
+  // handed the resolved BVH rather than the Map.
+  const bvhCache = new Map();
   const subBounds = [];
   const subparts = built.map(({ name, solid, mesh }) => {
     const b = bounds(mesh.positions);
     subBounds.push(b);
-    const mw = opts.minWall ? minWall(mesh) : null;
+    // Resolved lazily and only when asked for: without min-wall, a single-sub-part
+    // view (no meshGaps) must still build no index at all.
+    const mw = opts.minWall ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache) }) : null;
     return {
       name,
       bbox: size(b),
@@ -35,6 +51,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       holes: typeof solid.genus === "function" ? solid.genus() : null,
       minWall: mw?.value ?? null,
       minWallAt: mw?.location ?? null,
+      // Sampling accounting, so a report can tell a guaranteed minimum from an
+      // upper bound: on a dense mesh min-wall casts from a spread subset rather
+      // than every triangle (see min-wall.js). Exact readings say so explicitly,
+      // and a sampled run that found no wall still fills these in — `minWall`
+      // null with samples accounted for is "looked, found nothing"; null with
+      // `measuredMinWall` false is "never looked".
+      minWallSampled: mw?.sampled ?? false,
+      minWallSamples: mw ? { sampled: mw.sampledTriangles, total: mw.totalTriangles } : null,
     };
   });
 
@@ -42,7 +66,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // so this reads on OCCT too. nearMisses = the issue-#29 signal: pairs that
   // *almost* touch; overlapping pairs are excluded by name (a fully-contained
   // sub-part has surface distance > 0 but is the overlap gate's business).
-  const gaps = built.length > 1 ? meshGaps(built) : [];
+  const gaps = built.length > 1 ? meshGaps(built, { bvhCache }) : [];
 
   // Rebuilds with the same kernel and cleans up at its end — every solid fact
   // above is already read, so this is safe.
@@ -73,6 +97,12 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   return {
     part: part.meta?.title ?? view,
     view,
+    // Whether this measurement cast min-wall rays at all — stamped by the pass
+    // that did (or didn't) do the work, so a consumer never has to be told. A
+    // result with this false carries `minWall: null` on every sub-part because
+    // nothing measured it, which reads identically to "no reading available";
+    // verify's seeding rule turns on exactly this distinction (see verify.js).
+    measuredMinWall: !!opts.minWall,
     subparts,
     aggregate,
     overlaps,

package/src/testing/min-wall.js

@@ -3,36 +3,96 @@
 // voxel/SDF approach on both accuracy and speed). For each surface triangle, cast a ray
 // inward (reverse of its outward normal) from the centroid; the nearest hit is the local
 // material thickness. The minimum across samples is the reported min wall.
-// Works with both Manifold non-indexed meshes and OCCT indexed meshes (via meshTriangles).
-import { buildBVH, meshTriangles } from "./bvh.js";
+// Works with both Manifold non-indexed meshes and OCCT indexed meshes (via the BVH's
+// flat vertex store — never materialize a triangle-per-object list here, that is the
+// allocation this pass exists to avoid).
+//
+// SAMPLING CONTRACT. One ray per triangle is unbounded work, and a dense mesh makes it
+// the dominant cost of the inspect job: ~1.9 s and hundreds of megabytes of transient
+// garbage at 400k triangles on a laptop, several times that on a phone. Past
+// MAX_SAMPLES triangles the pass casts from a spread subset instead, and SAYS SO —
+// the result always carries { sampled, sampledTriangles, totalTriangles }, so a
+// report consumer can tell a guaranteed minimum from a lower-confidence one. A
+// sampled reading is an upper bound on the true minimum: it can miss a thin spot,
+// never invent one. `sampledTriangles` is the SAMPLE BUDGET — how many triangles
+// the walk selected — not a count of rays actually cast: a degenerate (zero-area)
+// triangle has no normal to cast along and is skipped without a ray.
+//
+// Only an EMPTY mesh reads as no result at all (`null`). A mesh whose sampled rays
+// all miss returns the usual object with `value: null`, because the sampling
+// accounting is exactly what a reader needs in that case — "we looked at 50k of
+// 400k triangles and found no wall" is a very different statement from "nobody
+// measured", and the two used to be indistinguishable downstream.
+import { buildBVH, readTriangleInto } from "./bvh.js";
 
-export function minWall(mesh, { maxThickness } = {}) {
-  const pos = mesh.positions;
-  const tris = meshTriangles(mesh);
-  if (tris.length === 0) return null;
+// Triangle budget above which minWall samples. Chosen so the parts people actually
+// author stay exact: everything in src/parts/ is 200–10,000 triangles, and a
+// preview-quality mesh of a fairly ornate part lands in the low tens of thousands.
+// 50,000 is comfortably above both while capping the pass at roughly a quarter
+// second — dense enough meshes (a high-facet lathe, a big imported STEP tessellation)
+// are the only ones that engage it. Override per call with `{ maxSamples }`.
+const MAX_SAMPLES = 50_000;
 
-  // bbox diagonal as the default cap (a ray exiting into open air gets no hit anyway).
+const gcd = (a, b) => { while (b) { const t = a % b; a = b; b = t; } return a; };
+
+// Stride for the sampling walk: near n/φ and coprime to n, so stepping by it visits
+// a permutation of the triangle list — the first `budget` steps are distinct and, by
+// the three-distance theorem, near-uniformly spread over the WHOLE mesh (measured
+// max gap on a 480-triangle mesh sampled 100 times: 8). A contiguous slice would
+// read one region of the surface, and a plain n/budget stride can beat against a
+// mesh's own periodicity (a lathed part's segment count) and sample one side of it.
+// No RNG anywhere, so the same mesh always reads the same wall.
+function sampleStride(n) {
+  let s = Math.max(1, Math.round(n * 0.6180339887498949)) % n || 1;
+  while (gcd(s, n) !== 1) s = s + 1 < n ? s + 1 : 1;
+  return s;
+}
+
+// `bvh` is an already-built index for THIS mesh — one mesh, one index, so there is
+// nothing to key here: measure() resolves it out of the Map it shares with meshGaps
+// (see cachedBVH for why that Map is the caller's) and passes the value. Omit it and
+// one is built. It does not interact with sampling — sampling picks WHICH rays to
+// cast, not how the index is built, so a shared BVH is equally valid sampled or exact.
+export function minWall(mesh, { maxThickness, maxSamples = MAX_SAMPLES, bvh = buildBVH(mesh) } = {}) {
+  const n = bvh.triangleCount;
+  if (n === 0) return null;
+  const V = bvh.vertices;
+
+  // bbox diagonal as the default cap (a ray exiting into open air gets no hit
+  // anyway). The BVH's root node bounds ARE that box, already computed — rescanning
+  // mesh.positions would be an O(n) pass on the hot path for a number we have. (On
+  // an indexed mesh they are also marginally tighter, since unreferenced vertices
+  // are not in the tree; that only shrinks a ray cap, never a reading.)
   if (maxThickness == null) {
-    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
-    for (let i = 0; i < pos.length; i += 3) for (let a = 0; a < 3; a++) { if (pos[i + a] < min[a]) min[a] = pos[i + a]; if (pos[i + a] > max[a]) max[a] = pos[i + a]; }
-    maxThickness = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) + 1;
+    const rb = bvh.rootBounds;
+    maxThickness = Math.hypot(rb[3] - rb[0], rb[4] - rb[1], rb[5] - rb[2]) + 1;
   }
 
-  const bvh = buildBVH(mesh);
-  let best = Infinity, loc = null;
-  for (let t = 0; t < tris.length; t++) {
-    const [v0, v1, v2] = tris[t];
-    const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
-    const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
-    let nx = e1[1] * e2[2] - e1[2] * e2[1], ny = e1[2] * e2[0] - e1[0] * e2[2], nz = e1[0] * e2[1] - e1[1] * e2[0];
+  // `maxSamples: 0` (or any non-positive) is the explicit "no cap, cast everything"
+  // escape hatch — the exact reading, however long it takes.
+  const budget = maxSamples > 0 && n > maxSamples ? Math.floor(maxSamples) : n;
+  const sampled = budget < n;
+  const stride = sampled ? sampleStride(n) : 1;   // stride 1 = every triangle, in mesh order
+
+  let best = Infinity, loc = null, t = 0;
+  const tri = new Float64Array(9);                  // reused per triangle; no per-ray garbage
+  for (let s = 0; s < budget; s++, t = t + stride < n ? t + stride : t + stride - n) {
+    readTriangleInto(V, t, tri);
+    const v0x = tri[0], v0y = tri[1], v0z = tri[2];
+    const e1x = tri[3] - v0x, e1y = tri[4] - v0y, e1z = tri[5] - v0z;
+    const e2x = tri[6] - v0x, e2y = tri[7] - v0y, e2z = tri[8] - v0z;
+    let 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) continue;                       // degenerate triangle
+    if (len < 1e-9) continue;                       // degenerate triangle: no normal, no ray
     nx /= len; ny /= len; nz /= len;                // outward normal (manifold winding)
-    const c = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
+    const c = [(v0x + tri[3] + tri[6]) / 3, (v0y + tri[4] + tri[7]) / 3, (v0z + tri[5] + tri[8]) / 3];
     const dir = [-nx, -ny, -nz];                    // inward
     const origin = [c[0] + dir[0] * 1e-4, c[1] + dir[1] * 1e-4, c[2] + dir[2] * 1e-4];
     const hit = bvh.raycast(origin, dir, { tMax: maxThickness, skipTri: t });
     if (hit && hit.t < best) { best = hit.t; loc = c; }
   }
-  return best === Infinity ? null : { value: best, location: loc };
+  // No hit anywhere still reports HOW it looked (see the header): a `value: null`
+  // with the sampling accounting intact, never a bare null that reads downstream as
+  // "min wall was never measured".
+  return { value: best === Infinity ? null : best, location: loc, sampled, sampledTriangles: budget, totalTriangles: n };
 }

package/src/testing/verify.js

@@ -118,14 +118,23 @@ function check(scope, subpart, metric, spec, registry, factsObj) {
   if (actual === null || actual === undefined) {
     if (reg.manifoldOnly) return { ...base, actual, status: "skip", pass: null, message: "n/a (OCCT backend)" };
     if (metric === "minWall") {
-      return { ...base, actual, status: "warn", pass: null, message: "min wall unavailable",
+      const out = { ...base, actual, status: "warn", pass: null, message: "min wall unavailable",
         hint: partHint ?? "no min-wall reading for this mesh — treat thin features as unverified" };
+      // A missing reading still has a HOW: a sampled run whose rays all missed says
+      // so here, rather than reading like a mesh min-wall never looked at.
+      const note = reg.note?.(factsObj);
+      if (note) out.note = note;
+      return out;
     }
     return { ...base, actual, status: "skip", pass: null, message: "unavailable" };
   }
   const { pass, message } = evaluateAssertion(parseAssertion(expr), actual);
   const status = pass ? "pass" : reg.kind === "warn" ? "warn" : "fail";
   const out = { ...base, actual, status, pass, message };
+  // A measurement caveat rides along whatever the verdict — a min-wall reading
+  // taken from a sample still passed, but the reader should know it was a sample.
+  const note = reg.note?.(factsObj);
+  if (note) out.note = note;
   if (!pass) {
     out.hint = partHint ?? reg.hint;
     if (reg.pattern) out.pattern = reg.pattern;
@@ -158,7 +167,10 @@ export function evaluateCase(facts, { profile, expect, subPartNames }) {
   return checks;
 }
 
-export function verify(kernel, part, { process, view, measureFn = defaultMeasure } = {}) {
+// `seed` lets a caller that has ALREADY measured this part hand the result in so
+// verify does not recompute it — see the seeding block below for the shape and
+// the one correctness rule that governs it.
+export function verify(kernel, part, { process, view, measureFn = defaultMeasure, seed } = {}) {
   view = view ?? Object.keys(part.views)[0];
   const profileSpec = process ?? part.verify?.process;
   const profile = profileSpec ? resolveProfile(profileSpec) : null;
@@ -185,6 +197,50 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
       : [...readKeys.entries()].map(([name, keys]) => `${name}:${relevanceHash([...keys], params)}`).join("|");
 
   const memo = new Map();
+
+  // SEEDING. expandCases always yields a "defaults" case, and the inspect job
+  // (framework/jobs.js) measures those exact params immediately before calling
+  // verify — so without this the oracle rebuilds the same geometry, casts the
+  // same min-wall rays and re-indexes the same meshes a second time. On a
+  // single-case part that is half the job.
+  //   seed = { params, result } — the params the result was measured with, and
+  //   the measure() output itself. Nothing else: every fact the rule below needs
+  //   is read off the artifact, so a caller cannot assert it wrongly.
+  //
+  // THE MIN-WALL SUPERSET RULE, which is the trap here. measureCase asks for
+  // `{ minWall: needMinWall }`, and needMinWall is false whenever no profile and
+  // no expectation mentions min wall. A result measured WITH min wall is a strict
+  // superset of one measured without: the extra fields are only ever read by the
+  // minWall metric, which by definition this run never checks. Reuse in that
+  // direction is free. The reverse is NOT safe — a seed taken without min wall
+  // carries `minWall: null` on every sub-part, which the registry reports as
+  // "min wall unavailable", silently downgrading a real gate to a warning. So the
+  // seed is consulted only when `seed.result.measuredMinWall || !needMinWall` —
+  // and `measuredMinWall` is stamped by measure() itself, not claimed by whoever
+  // holds the result. Otherwise the seed is ignored and the case measured properly.
+  //
+  // ALIASING. A consulted seed is memoized BY REFERENCE, so the caller's result
+  // and every case that hits it are the same object — the inspect job's
+  // `report.measure` and `report.verify.cases[0]`'s facts included. Nothing here
+  // mutates facts (evaluateCase only reads), and that is what makes the sharing
+  // safe; a future check that wants to annotate a fact must copy first.
+  //
+  // Keyed through the SAME signature() the memo uses, never a JSON compare of the
+  // raw params — a separate compare would miss cases that share a signature (a
+  // preset touching only params the build never reads) and, worse, could hit on
+  // params that merely look equal. The seed's params are layered over
+  // part.defaults first because a caller's `{}` and the defaults case's
+  // `{...part.defaults}` build identical geometry but hash differently
+  // (JSON.stringify({}) is not JSON.stringify(defaults), and relevanceHash reads
+  // params[k] straight through). The view is checked too: measure()'s output is
+  // per-view, and a seed from another view would be a silent wrong answer.
+  //
+  // Non-default measure options (a custom `gapThreshold`) are the caller's
+  // responsibility: seed only a measurement taken the way verify would take it.
+  if (seed?.result && (seed.result.measuredMinWall || !needMinWall) && seed.result.view === view) {
+    memo.set(signature({ ...part.defaults, ...(seed.params ?? {}) }), seed.result);
+  }
+
   const measureCase = (params) => {
     const key = signature(params);
     if (!memo.has(key)) memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall }));