partforge 0.31.0 → 0.33.0

package/src/framework/controls.js

@@ -218,6 +218,7 @@ export function buildControls(root, parameters, params, onDirty) {
   const info = createInfoPopover();
   const controls = []; // { key, el } per control element
   const sections = []; // { el, keys:Set } per rendered section
+  const syncFns = []; // { key, sync } for every widget that can re-read params
   for (const sec of parameters) {
     if (!sectionRenders(sec)) continue;
     const section = el("div", "section");
@@ -225,7 +226,11 @@ export function buildControls(root, parameters, params, onDirty) {
     attachInfo(title, sec.description, info);
     section.append(title);
     const keys = new Set();
-    const register = (key, node) => { controls.push({ key, el: node }); keys.add(key); };
+    const register = (key, node, sync) => {
+      controls.push({ key, el: node });
+      keys.add(key);
+      if (sync) syncFns.push({ key, sync });
+    };
     if (sec.features) buildFeatureSection(section, sec, params, onDirty, register, info);
     else buildPresetSection(section, sec, params, onDirty, register, info);
     root.append(section);
@@ -233,6 +238,12 @@ export function buildControls(root, parameters, params, onDirty) {
   }
   return {
     applyRelevance: (relevant) => applyRelevance(relevant, controls, sections),
+    // Re-read params into the widgets — all of them, or just `keys`. The
+    // programmatic twin of a user edit (setParams); never fires onDirty.
+    syncValues: (keys) => {
+      const only = keys && new Set(keys);
+      for (const { key, sync } of syncFns) if (!only || only.has(key)) sync();
+    },
     dispose: () => { info.dispose(); root.replaceChildren(); },
   };
 }
@@ -263,7 +274,7 @@ function buildPresetSection(section, sec, params, onDirty, register, info) {
     attachInfo(lbl, t.description, info);
     row.append(box, lbl);
     box.addEventListener("change", () => { params[t.key] = box.checked ? (t.on ?? 1) : 0; onDirty?.(); });
-    register(t.key, row);
+    register(t.key, row, () => { box.checked = params[t.key] > 0; });
     section.append(row);
   }
 
@@ -274,8 +285,11 @@ function buildPresetSection(section, sec, params, onDirty, register, info) {
     for (const def of advanced) {
       const s = makeParameterControl(def, params, () => { if (preset) preset.value = "Custom"; onDirty?.(); }, info);
       adv.append(s.wrap);
-      syncs[def.key] = s.sync;
-      register(def.key, s.wrap);
+      syncs[def.key] = s.sync; // raw: preset APPLICATION must not mark itself Custom
+      // A programmatic edit diverges from the preset exactly as a user edit does,
+      // so the picker falls back to Custom — leaving a stale preset name selected
+      // would also make it unre-appliable (no change event for the current option).
+      register(def.key, s.wrap, () => { s.sync(); if (preset) preset.value = "Custom"; });
     }
     section.append(toggle, adv);
   }
@@ -306,7 +320,12 @@ function buildFeatureSection(section, sec, params, onDirty, register, info) {
     const featLabel = el("span", "", feat.label);
     attachInfo(featLabel, feat.description, info);
     checkRow.append(box, featLabel);
-    register(feat.key, checkRow);
+    // `group` is created just below — the sync only ever runs after this
+    // function returns, so the closure is safely bound by then.
+    register(feat.key, checkRow, () => {
+      box.checked = params[feat.key] > 0;
+      group.classList.toggle("hidden", !box.checked);
+    });
 
     const group = el("div", "feat-group");
     const syncs = [];
@@ -314,7 +333,7 @@ function buildFeatureSection(section, sec, params, onDirty, register, info) {
       const s = makeParameterControl(def, params, onDirty, info);
       group.append(s.wrap);
       syncs.push(s.sync);
-      register(def.key, s.wrap);
+      register(def.key, s.wrap, s.sync);
     }
     group.classList.toggle("hidden", !box.checked);
 

package/src/framework/debug-overlay.js

@@ -43,13 +43,21 @@ export function createDebugOverlay({ initialCachingOn = true, onToggle } = {}) {
 
   cb.addEventListener("change", () => onToggle?.(cb.checked));
 
+  // What's currently on screen. update() MERGES over it, so a caller reporting one
+  // figure doesn't blank the others: a pose-only edit ran no build and no L2 ops,
+  // and would otherwise wipe the last build's timing back to "—" on its way to
+  // showing a posed count.
+  const shown = { ms: null, hits: 0, misses: 0, skipped: 0, rebuilt: 0, posed: 0 };
+
   return {
-    update({ ms, hits = 0, misses = 0, skipped = 0, rebuilt = 0 } = {}) {
+    update(counts = {}) {
+      Object.assign(shown, counts);
+      const { ms, hits, misses, skipped, rebuilt, posed } = shown;
       const l2 = cb.checked ? `${hits} hit / ${misses} miss` : "off";
       readout.textContent =
         `build: ${ms != null ? Math.round(ms) + " ms" : "—"}\n` +
         `L2 ops: ${l2}\n` +
-        `L1 parts: ${skipped} skipped / ${rebuilt} rebuilt`;
+        `L1 parts: ${skipped} skipped / ${rebuilt} rebuilt / ${posed} posed`;
     },
     detach: () => box.remove(),
   };

package/src/framework/geometry/kernel-front.js

@@ -25,6 +25,7 @@ const opentype = typeof opentypeNamespace.parse === "function"
 import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
 import { textGlyphs } from "./text2d.js";
+import { beveledExtrude } from "./rim-bevel.js";
 import { DEFAULT_FONT_BYTES } from "./fonts/default-font.js";
 import { convexHull, hullPoints } from "./hull.js";
 
@@ -45,6 +46,16 @@ export function finishKernel(k) {
     };
   }
 
+  // extrude({ bevel }) desugars here — before the spec-wrapped op ever sees it —
+  // into extrude + loft + intersect (rim-bevel.js), so both backends share one
+  // implementation and the probe records no CAD-only op. beveledExtrude calls
+  // back into the wrapped k.extrude/k.loft, so caching and validation apply.
+  const specExtrude = k.extrude;
+  k.extrude = (...a) =>
+    a.length === 1 && isPlainOptions(a[0]) && a[0].bevel !== undefined
+      ? beveledExtrude(k, a[0])
+      : specExtrude(...a);
+
   k.toSTEP ??= () => { throw new KernelCapabilityError("toSTEP requires the OCCT backend"); };
   k.shape2d ??= () => { throw new KernelCapabilityError("shape2d requires the Manifold backend"); };
 

package/src/framework/geometry/kernel.js

@@ -22,10 +22,12 @@ export const KERNEL_OPS = [
   "loft", "sweep", "helixSweptTube", "union", "shape2d", "text2d", "hull", "hullChain", "toSTEP",
 ];
 
-// Backend-optional kernel ops: the Manifold cache brackets + WASM lifetime hooks.
-// jobs.js calls all of these via `?.`, so a backend may simply omit them.
+// Backend-optional kernel ops: the sub-part cache brackets + WASM lifetime hooks.
+// Both in-repo backends implement the brackets (only `cleanup` is Manifold-specific —
+// OCCT's replicad shapes need no dispose bookkeeping). jobs.js calls all of these via
+// `?.`, so a third-party backend may simply omit them.
 export const KERNEL_OPTIONAL_OPS = [
-  "beginSubPart", "endSubPart", "cacheStats", "resetCacheStats", "cleanup",
+  "beginSubPart", "endSubPart", "sweepCache", "cacheStats", "resetCacheStats", "cleanup",
 ];
 
 // Ops every Solid must implement (including the sugar addSugar() attaches).
@@ -99,7 +101,7 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(o:{r?:number,d?:number}) => Solid} sphere   sphere centred at the origin; {r|d}; bare sphere(r) stays valid
  * @property {(o:{size?:number[],center?:boolean,min?:number[],max?:number[]}) => Solid} box   {size} = centered X/Y, base z=0 ({center:true} centers Z too) or {min,max}; legacy (min,max) accepted until v2
  * @property {(o:{points:number[][],h:number,twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0; legacy (points,h,opts) accepted until v2
- * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number}) => Solid} extrude   polygon-with-holes region from z=0; legacy (profile,h,opts) accepted until v2
+ * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   polygon-with-holes region from z=0; bevel = 45° rim bevel (any profile form incl. Shape2D, materialized to point rings; no twist/scaleTop); legacy (profile,h,opts) accepted until v2
  * @property {(o:{rings:{polygon?:number[][],sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[],ruled?:boolean,closed?:boolean}) => Solid} loft   stack polygon cross-sections; legacy (rings,opts) accepted until v2
  * @property {(o:{profile:number[][],path:number[][],closed?:boolean,cornerRadius?:number,ruled?:boolean,smooth?:boolean}) => Solid} sweep   sweep a 2-D profile along a 3-D polyline; legacy (profile,path,opts) accepted until v2
  * @property {(o:{profile:number[][],degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted until v2
@@ -109,8 +111,9 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(inputs: (Shape2D|number[][]|{start:number[],segments:object[]})[]) => Shape2D} hull   convex hull of all inputs → a convex Shape2D (faceted; pure-JS monotone chain)
  * @property {(inputs: (Shape2D|number[][]|{start:number[],segments:object[]})[]) => Shape2D} hullChain   swept hull over an ordered sequence (≥2): union of hull([inᵢ,inᵢ₊₁])
  * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only (Manifold throws KernelCapabilityError)
- * @property {(name:string) => void} [beginSubPart]   open a per-sub-part solid-cache round (Manifold only)
+ * @property {(name:string) => void} [beginSubPart]   open a per-sub-part solid-cache round (both backends)
  * @property {() => void} [endSubPart]                close the cache round (always pair with beginSubPart)
+ * @property {() => void} [sweepCache]   drop cache partitions idle for 3 rebinds; call once per setPart, never mid-bracket
  * @property {() => {hits:number,misses:number}} [cacheStats]
  * @property {() => void} [resetCacheStats]
  * @property {() => void} [cleanup]   free per-job WASM objects (Manifold backend); call after each job

package/src/framework/geometry/manifold-backend.js

@@ -246,6 +246,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     shape2d,
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
+    sweepCache: () => cache.sweep(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
     // Free every WASM object created since the last cleanup EXCEPT solids the cache

package/src/framework/geometry/occt-backend.js

@@ -473,6 +473,7 @@ export function createOcctKernel(replicad) {
     },
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
+    sweepCache: () => cache.sweep(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
   });

package/src/framework/geometry/occt-repair.js

@@ -42,7 +42,9 @@ export function createOcctRepair(measureVolume) {
   // WASM heap doesn't grow across regenerates.
   const validChamfer = (shape, finderFn, distance) => {
     if (!(distance > 0)) return shape.clone();
+    let attempts = 0;
     const tryAt = (d) => {
+      attempts++;
       const probe = shape.clone();
       let res;
       try { res = probe.chamfer(d, finderFn); } catch { return null; } // probe consumed by the op
@@ -50,6 +52,7 @@ export function createOcctRepair(measureVolume) {
       res.delete?.();
       return null;
     };
+    const t0 = performance.now();
     let best = tryAt(distance);
     if (best) return best;                                   // requested distance is valid
     let lo = 0, hi = distance, bestD = 0;
@@ -58,7 +61,12 @@ export function createOcctRepair(measureVolume) {
       const res = tryAt(mid);
       if (res) { best?.delete?.(); best = res; bestD = mid; lo = mid; } else hi = mid;
     }
-    if (best) { console.info(`partforge: chamfer ${distance} reduced to ${bestD.toFixed(2)} (largest valid for this geometry)`); return best; }
+    // The rescue re-ran the chamfer per attempt — on a many-edge selection that
+    // multiplies an already-expensive op by ~8x, so make the cost loud enough to
+    // act on (lower the distance, or bevel profile rims with a loft instead).
+    const cost = `${attempts} attempts, ${((performance.now() - t0) / 1000).toFixed(1)}s — see ERROR-PATTERNS.md#chamfer-rescue-bisection`;
+    if (best) { console.warn(`partforge: chamfer ${distance} over-ran the geometry — reduced to ${bestD.toFixed(2)} (largest valid; ${cost})`); return best; }
+    console.warn(`partforge: chamfer ${distance} has no valid distance for this geometry — feature skipped (${cost})`);
     return shape.clone();                                    // nothing valid — skip the chamfer
   };
 

package/src/framework/geometry/op-options.js

@@ -103,7 +103,10 @@ export function prismArgs(o) {
 }
 
 export function extrudeArgs(o) {
-  checkKeys("extrude", o, ["profile", "h", "twist", "scaleTop"]);
+  // `bevel` is accepted here so the validating probe (lint) doesn't flag it, but
+  // it never reaches the positional backend op — kernel-front.js desugars a
+  // bevel call into extrude + loft + intersect before this normalizer runs.
+  checkKeys("extrude", o, ["profile", "h", "twist", "scaleTop", "bevel"]);
   return [req("extrude", o, "profile"), req("extrude", o, "h"), ...tail(o, ["twist", "scaleTop"])];
 }
 

package/src/framework/geometry/pose.js

@@ -3,11 +3,16 @@
 // the underlying B-rep shape; composePose folds them (in application order) into
 // one column-major mat4, and transformPositions re-poses a cached tessellation's
 // vertices with it. Pure JS — unit-testable without booting a kernel.
+//
+// The same math backs the viewer's pose fast path: when a param change only
+// moves a sub-part, `poseDelta` (via `invertRigid`) gives the matrix carrying an
+// already-delivered mesh from the pose it was built at to the new one, so the
+// viewer re-poses instead of rebuilding.
 
 const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
 // column-major 4x4 product: (A·B)[c][r] = Σk A[k][r]·B[c][k]
-function mul(A, B) {
+function mulMat4(A, B) {
   const o = new Array(16);
   for (let c = 0; c < 4; c++)
     for (let r = 0; r < 4; r++)
@@ -28,13 +33,13 @@ function rotationAbout(deg, center, axis) {
     x * z * C + y * s, y * z * C - x * s, c + z * z * C, 0,
     0, 0, 0, 1,
   ];
-  return mul(translation(center), mul(R, translation([-center[0], -center[1], -center[2]])));
+  return mulMat4(translation(center), mulMat4(R, translation([-center[0], -center[1], -center[2]])));
 }
 
 const stepMatrix = (s) => (s.t === "translate" ? translation(s.v) : rotationAbout(s.deg, s.center, s.axis));
 
 // Fold steps so the EARLIEST step applies first: p' = Mn · … · M1 · p.
-export const composePose = (steps) => steps.reduce((m, s) => mul(stepMatrix(s), m), IDENTITY);
+export const composePose = (steps) => steps.reduce((m, s) => mulMat4(stepMatrix(s), m), IDENTITY);
 
 // Apply a mat4 to an interleaved xyz Float32Array in place.
 export function transformPositions(positions, m) {
@@ -45,3 +50,30 @@ export function transformPositions(positions, m) {
     positions[i + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
   }
 }
+
+// Invert a rigid mat4 (rotation + translation only): Rᵀ, t' = −Rᵀ·t. Valid only
+// for matrices produced by composePose — transposing the 3x3 block inverts a
+// rotation, so any scale or shear in it yields garbage rather than an inverse.
+export function invertRigid(m) {
+  const r0 = m[0], r1 = m[1], r2 = m[2],
+        r4 = m[4], r5 = m[5], r6 = m[6],
+        r8 = m[8], r9 = m[9], r10 = m[10],
+        tx = m[12], ty = m[13], tz = m[14];
+  return [
+    r0, r4, r8, 0,
+    r1, r5, r9, 0,
+    r2, r6, r10, 0,
+    -(r0 * tx + r1 * ty + r2 * tz),
+    -(r4 * tx + r5 * ty + r6 * tz),
+    -(r8 * tx + r9 * ty + r10 * tz),
+    1,
+  ];
+}
+
+// The matrix that carries a mesh delivered at `oldSteps` to the pose `newSteps`:
+// compose(new) · compose(old)⁻¹. Both step lists come from the pose probe.
+export const poseDelta = (newSteps, oldSteps) => {
+  const target = composePose(newSteps);
+  const inv = invertRigid(composePose(oldSteps));
+  return mulMat4(target, inv);
+};

package/src/framework/geometry/rim-bevel.js

@@ -0,0 +1,132 @@
+// Rim bevel for extruded profiles — extrude({ profile, h, bevel }). Composed
+// entirely from existing kernel ops (extrude + loft + intersect/cut) at the
+// backend-shared front, so both backends get identical semantics for free and
+// the probe sees no CAD-only op: a beveled extrusion stays on the fast Manifold
+// backend instead of routing the whole part to OCCT. (OCCT's native chamfer is
+// per-edge; on a many-point profile rim — a gear — one call costs seconds. The
+// loft envelope costs one boolean regardless of point count.)
+//
+// Accepted profiles: point array, arc/curve contour, { outer, holes } region,
+// or a Shape2D (multi-region Shape2Ds bevel each region and union). Curved
+// profiles are MATERIALIZED to point rings first — the loft envelope needs
+// rings in 1:1 point correspondence — so a beveled extrusion is faceted at the
+// sampling LOD even in STEP export (the same fidelity class as loft rings).
+// Arc contours sample at a fixed pure-JS LOD (backend-identical, like hull);
+// a Shape2D materializes via its own backend's toRegions (hull's Shape2D
+// parity class). The body is built from the SAME materialized rings as the
+// envelope — mixing a curve-exact body with a faceted envelope would leave
+// sliver artifacts where the smooth wall crosses the faceted one.
+//
+// Geometry: a 45° bevel, exactly what chamfer({d, edges:{inPlane}}) would cut.
+// The outer rim insets toward the material; a hole's rim flares the other way
+// (the opening is larger at the face). Outer bevels come from intersecting a
+// loft envelope extended 1 mm past both faces (so its end caps never coincide
+// with the extrusion's faces — coincident caps leave sliver-triangle shading
+// artifacts). Hole bevels are separate per-rim flare cutters that meet the
+// hole wall only along a ring (a curve, not a face), keeping the booleans away
+// from coincident-face degeneracies on the B-rep backend.
+import { offsetPolygon } from "./polygon.js";
+import { tessellateProfile } from "./profile.js";
+import { ringArea } from "./shape2d-regions.js";
+
+// Fixed pure-JS sampling LOD for arc/curve contours — hull.js precedent: not a
+// backend's own segment count, so both backends materialize bit-identically.
+const BEVEL_SEGS = 64;
+
+// Normalize `bevel` (number = both rims, {bottom, top} = per rim) and validate
+// against the height. Exported for direct unit testing.
+export function resolveBevel(bevel, h) {
+  let bottom, top;
+  if (typeof bevel === "number") { bottom = bevel; top = bevel; }
+  else if (bevel !== null && typeof bevel === "object") {
+    for (const key of Object.keys(bevel)) if (key !== "bottom" && key !== "top")
+      throw new Error(`extrude: unknown bevel option ${JSON.stringify(key)} (valid: bottom, top)`);
+    bottom = bevel.bottom ?? 0; top = bevel.top ?? 0;
+  } else throw new Error("extrude: bevel must be a number or { bottom?, top? }");
+  if (!(Number.isFinite(bottom) && bottom >= 0) || !(Number.isFinite(top) && top >= 0))
+    throw new Error("extrude: bevel distances must be finite numbers >= 0");
+  if (bottom + top >= h)
+    throw new Error("extrude: bevel must fit the height (bottom + top < h)");
+  return { bottom, top };
+}
+
+// offsetPolygon needs CCW input; toRegions/hand-written holes may wind either
+// way. Tessellated arc contours close back onto their start point — drop that
+// duplicate, or the offset ring's point count never matches and fit() gives up.
+const ccw = (r) => {
+  const [x0, y0] = r[0], [xn, yn] = r[r.length - 1];
+  const ring = Math.abs(x0 - xn) < 1e-9 && Math.abs(y0 - yn) < 1e-9 ? r.slice(0, -1) : r;
+  return ringArea(ring) >= 0 ? ring : [...ring].reverse();
+};
+
+// The largest offset (inset for the outer rim, outset for a hole rim — the sign
+// of `delta`) the ring can take, starting from the requested distance. Narrow
+// features cap the bevel (the same geometric limit OCCT's chamfer hits — see
+// ERROR-PATTERNS.md#chamfer-rescue-bisection), but each attempt here is pure JS
+// on the 2-D outline, not a kernel op, so backing off is effectively free. The
+// loop is deterministic, preserving build purity. `corners: "sharp"` keeps the
+// offset 1:1 with the input points — loft stitching requires every ring to
+// share the profile's exact point count (a mismatch is treated as a failed try).
+const fit = (ring, delta, what) => {
+  const requested = Math.abs(delta), sign = Math.sign(delta);
+  let c = requested;
+  for (;;) {
+    try {
+      const off = offsetPolygon(ring, sign * c, { corners: "sharp" });
+      if (off.length === ring.length) {
+        if (c < requested)
+          console.warn(`partforge: extrude bevel ${requested} exceeds what the ${what} can take — reduced to ${c.toFixed(2)}`);
+        return { ring: off, c };
+      }
+    } catch { /* offset collapsed or self-intersected — try smaller */ }
+    c *= 0.85;
+    if (c < 0.05) {
+      console.warn(`partforge: extrude bevel ${requested} has no valid offset for this ${what} — rim left square`);
+      return null;
+    }
+  }
+};
+
+const outerRings = (outer, h, b, t) => {
+  const rings = [];
+  if (b) rings.push({ polygon: b.ring, z: -1 }, { polygon: b.ring, z: 0 }, { polygon: outer, z: b.c });
+  else rings.push({ polygon: outer, z: -1 });
+  if (t) rings.push({ polygon: outer, z: h - t.c }, { polygon: t.ring, z: h }, { polygon: t.ring, z: h + 1 });
+  else rings.push({ polygon: outer, z: h + 1 });
+  return rings;
+};
+
+const bevelRegion = (k, region, h, bottom, top) => {
+  const outer = ccw(region.outer);
+  const holes = (region.holes ?? []).map(ccw);
+  let s = k.extrude({ profile: holes.length ? { outer, holes } : outer, h });
+  const b = bottom > 0 ? fit(outer, -bottom, "profile") : null;
+  const t = top > 0 ? fit(outer, -top, "profile") : null;
+  if (b || t) s = s.intersect(k.loft({ rings: outerRings(outer, h, b, t) }));
+  const cutters = [];
+  for (const hole of holes) {
+    const hb = bottom > 0 ? fit(hole, bottom, "hole") : null;
+    if (hb) cutters.push(k.loft({ rings: [
+      { polygon: hb.ring, z: -1 }, { polygon: hb.ring, z: 0 }, { polygon: hole, z: hb.c },
+    ] }));
+    const ht = top > 0 ? fit(hole, top, "hole") : null;
+    if (ht) cutters.push(k.loft({ rings: [
+      { polygon: hole, z: h - ht.c }, { polygon: ht.ring, z: h }, { polygon: ht.ring, z: h + 1 },
+    ] }));
+  }
+  return cutters.length ? s.cutAll(cutters) : s;
+};
+
+export function beveledExtrude(k, { profile, h, twist, scaleTop, bevel }) {
+  if (twist !== undefined || scaleTop !== undefined)
+    throw new Error("extrude: bevel cannot combine with twist or scaleTop");
+  const { bottom, top } = resolveBevel(bevel, h);
+  // bevel: 0 must hash identically to the plain call — hand the original
+  // profile straight through (curve-exact on OCCT, no materialization).
+  if (bottom === 0 && top === 0) return k.extrude({ profile, h });
+  const regions = profile != null && typeof profile.toRegions === "function"
+    ? profile.toRegions()
+    : [tessellateProfile(profile, BEVEL_SEGS)];
+  if (regions.length === 0) throw new Error("extrude: bevel profile produced no regions");
+  return regions.map((r) => bevelRegion(k, r, h, bottom, top)).reduce((a, x) => a.union(x));
+}

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

@@ -6,11 +6,13 @@
 export function createSolidCache() {
   const caches = new Map(); // name -> Map(hash -> { value, pin, dispose })
   const pinned = new Set();  // every live `pin` across all sub-parts
+  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 hits = 0, misses = 0;
 
   return {
-    begin(n) { name = n; prev = caches.get(n) ?? new Map(); active = new Map(); },
+    begin(n) { name = n; lastBuilt.set(n, generation); prev = caches.get(n) ?? new Map(); active = new Map(); },
 
     end() {
       if (name == null) return;
@@ -21,6 +23,20 @@ export function createSolidCache() {
       name = null; active = prev = null;
     },
 
+    // Rebind hygiene: called once per setPart() (never mid-bracket — the worker's
+    // job queue is serial). Partitions a rebind renamed or deleted would otherwise
+    // pin their last build's solids until worker death; three idle generations is
+    // the eviction line, so recently-viewed views stay warm across edits.
+    sweep() {
+      generation++;
+      for (const [n, entries] of caches) {
+        if (generation - (lastBuilt.get(n) ?? 0) < 3) continue;
+        for (const entry of entries.values()) { pinned.delete(entry.pin); entry.dispose(); }
+        caches.delete(n);
+        lastBuilt.delete(n);
+      }
+    },
+
     lookup(hash, make) {
       if (name == null) return make().value; // not bracketed → no caching
       if (active.has(hash)) { hits++; return active.get(hash).value; }

package/src/framework/jobs.js

@@ -45,6 +45,9 @@ export function buildPosed(kernel, part, name, { purpose, view, p, d, onProgress
 //   { type:"generate", subparts, view, params } → { type:"meshes", meshes, ms }
 //   { type:"export-stl", view, params }         → { type:"download-parts", ext, mime, parts }
 //   { type:"export-step", view, params }        → { type:"download", data, filename, mime }
+// A generate also accepts `opts.isStale` — a caller-supplied predicate checked at each
+// sub-part boundary — and answers { type:"superseded" } instead of `meshes` when it
+// stops early (a build that ended without meshes, not an error; see KERNEL-CONTRACT.md).
 // Each result branch declares its own transferables (the big binary buffers,
 // zero-copy across the worker boundary) right where the buffers are created —
 // so a new job type can't silently regress to structured-cloning its payload.
@@ -53,7 +56,8 @@ export function buildPosed(kernel, part, name, { purpose, view, p, d, onProgress
 // preview generates stay quiet (no callback) to avoid flicker during slider drags.
 const bufferOf = (data) => (ArrayBuffer.isView(data) ? data.buffer : data);
 
-export async function handle(kernel, part, msg, post) {
+export async function handle(kernel, part, msg, post, opts = {}) {
+  const isStale = opts.isStale ?? (() => false);
   const onProgress = (phase) => post({ type: "progress", phase });
   const label = (name) => part.parts[name].label ?? name;
   const exportName = (name) => part.parts[name].export?.name ?? name;
@@ -78,7 +82,7 @@ export async function handle(kernel, part, msg, post) {
       const useCache = msg.cache !== false; // ?debug toggle can disable caching (cache:false)
       const meshes = [];
       kernel.resetCacheStats?.(); // count hits/misses for just this job
-      for (const name of msg.subparts) {
+      for (const [i, name] of msg.subparts.entries()) {
         if (useCache) kernel.beginSubPart?.(name); // open the per-sub-part cache round
         try {
           const m = posed(name, "display").toMesh({ quality: "preview" });
@@ -87,6 +91,15 @@ export async function handle(kernel, part, msg, post) {
           if (useCache) kernel.endSubPart?.(); // always close the bracket — a throw mid-build must not strand pinned solids
           kernel.cleanup?.();                  // free this round's transients (cached/pinned solids survive)
         }
+        // Cooperative cancel: yield one macrotask so queued messages (a newer
+        // generate, a part rebind) can be seen, then stop at this boundary if
+        // this build is stale. The last sub-part skips the yield — nothing
+        // follows it. Completed sub-parts have already committed their cache
+        // brackets, so an abort here strands nothing.
+        if (i < msg.subparts.length - 1) {
+          await new Promise((r) => setTimeout(r, 0));
+          if (isStale()) return void post({ type: "superseded" });
+        }
       }
       const transfer = meshes.flatMap((m) =>
         [m.positions.buffer, m.normals?.buffer, m.indices?.buffer, m.edges?.buffer, m.featureIds?.buffer].filter(Boolean));