partforge 0.70.0 → 0.71.0

package/docs/KERNEL-CONTRACT.md

@@ -98,11 +98,25 @@ them loses sub-part caching and mesh-topology gates (`holes`, emptiness), nothin
 a part (never inside a `beginSubPart`/`endSubPart` bracket), it drops cache partitions that
 have gone unbuilt for three consecutive rebinds.
 
+`beginSubPart`/`endSubPart` brackets MAY nest: only the outermost pair opens and
+commits a round, and an inner pair is a balanced no-op. Nesting is real rather than
+theoretical — `buildView` opens a round of its own, so any caller that brackets around
+a view build contains one. A backend that keeps a single open round (rather than a
+stack) must collapse inner pairs this way; committing on the inner `end()` would close
+the outer round early and leave the rest of that build uncached.
+
 Sub-part brackets bound cache RETENTION, not reuse: a solid one sub-part builds is reused
 by any other that asks for the same content hash, so a sheet of identical cells split
 across row sub-parts evaluates each distinct cell once rather than once per row. An adopted
 entry is retained by both partitions and disposed only when the last one drops it.
 
+The oracle (`buildView`, `assemblyOverlaps`) brackets under partition names of its
+own rather than the display sub-part names, and a host adding another oracle-side build
+should do the same. Both reuse the display build's solids through the cross-partition
+index, so measuring a view costs almost nothing right after drawing it; keeping them in
+separate partitions is what stops a measurement's own geometry — verify walks cases with
+params of their own — from displacing the geometry the viewer is showing.
+
 **Transform hoisting.** Booleans commute with rigid transforms, so a conforming backend MAY
 lift a transform every operand shares out of the boolean and apply it to the result
 instead — which is what lets N identically-built copies share one evaluation. Two

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.70.0",
+  "version": "0.71.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/assembly.js

@@ -9,10 +9,17 @@ import { viewSubParts, resolveParams, buildPosed } from "./part-model.js";
 //   → [{ a, b, volume, location }] for each offending pair (empty = no collisions)
 export function assemblyOverlaps(kernel, part, view, params = {}, { tolerance = 1 } = {}) {
   const { p, d } = resolveParams(part, params);
-  const posed = viewSubParts(part, view, p).map((name) => ({
-    name,
-    solid: buildPosed(kernel, part, name, { purpose: "display", view, p, d }),
-  }));
+  // Same posed solids buildView builds, so this round is almost entirely hits off
+  // that one; only the pairwise intersects below are new. Its own oracle partition,
+  // for the reason buildView's comment gives.
+  kernel.beginSubPart?.(`oracle:overlaps:${view}`);
+  let posed;
+  try {
+    posed = viewSubParts(part, view, p).map((name) => ({
+      name,
+      solid: buildPosed(kernel, part, name, { purpose: "display", view, p, d }),
+    }));
+  } catch (e) { kernel.endSubPart?.(); throw e; } // never strand the round on a failed build
 
   const overlaps = [];
   for (let i = 0; i < posed.length; i++) {
@@ -27,6 +34,7 @@ export function assemblyOverlaps(kernel, part, view, params = {}, { tolerance =
       }
     }
   }
-  kernel.cleanup?.(); // free the per-check WASM objects
+  kernel.endSubPart?.();
+  kernel.cleanup?.(); // free the per-check WASM objects (cached solids are pinned)
   return overlaps;
 }

package/src/framework/geometry/solid-cache.js

@@ -15,6 +15,7 @@ export function createSolidCache() {
   const lastBuilt = new Map(); // name -> rebind generation of the partition's last begin()
   let generation = 0;          // bumped only by sweep() (i.e. per part rebind)
   let name = null, active = null, prev = null;
+  let depth = 0;               // bracket nesting; only the OUTERMOST one is real (see begin)
   let hits = 0, misses = 0;
 
   // One partition stops retaining `entry`. Disposal waits for the LAST holder:
@@ -30,9 +31,19 @@ export function createSolidCache() {
   };
 
   return {
-    begin(n) { name = n; lastBuilt.set(n, generation); prev = caches.get(n) ?? new Map(); active = new Map(); },
+    // Nested brackets collapse into the outermost one. There is a single open
+    // round (name/active/prev), not a stack, so an inner begin() would otherwise
+    // rebind it and the inner end() would commit-and-close the OUTER round early —
+    // evicting its entries and leaving the rest of that build uncached. Callers
+    // nest legitimately now that buildView brackets: an outer bracket is free to
+    // contain one, and the inner pair becomes a no-op.
+    begin(n) {
+      if (depth++ > 0) return;
+      name = n; lastBuilt.set(n, generation); prev = caches.get(n) ?? new Map(); active = new Map();
+    },
 
     end() {
+      if (depth > 0 && --depth > 0) return; // inner bracket — the outer one still owns the round
       if (name == null) return;
       for (const [hash, entry] of prev) {
         if (!active.has(hash)) release(hash, entry); // this partition drops it

package/src/framework/oracle/build.js

@@ -7,8 +7,19 @@ import { viewSubParts, resolveParams, buildPosed } from "../part-model.js";
 // before they free the kernel. Meshes are JS-owned arrays and survive cleanup.
 export function buildView(kernel, part, view, params = {}) {
   const { p, d } = resolveParams(part, params);
-  return viewSubParts(part, view, p).map((name) => {
-    const solid = buildPosed(kernel, part, name, { purpose: "display", view, p, d });
-    return { name, solid, mesh: solid.toMesh() };
-  });
+  // Cache round for the whole view. The name is the ORACLE's, deliberately not the
+  // display sub-part names the generate path brackets under: a distinct partition
+  // still reuses those solids (the cache indexes entries by content hash across
+  // partitions), while keeping this round's own eviction away from the geometry the
+  // viewer is showing — bracketing under the display names would make running the
+  // oracle throw away the display cache. One name per view also bounds retention:
+  // verify walks its cases through here, so each case evicts the previous rather
+  // than accumulating every case's geometry at once.
+  kernel.beginSubPart?.(`oracle:view:${view}`);
+  try {
+    return viewSubParts(part, view, p).map((name) => {
+      const solid = buildPosed(kernel, part, name, { purpose: "display", view, p, d });
+      return { name, solid, mesh: solid.toMesh() };
+    });
+  } finally { kernel.endSubPart?.(); }
 }