partforge 0.60.1 → 0.61.0

package/docs/AUTHORING-PARTS.md

@@ -2052,6 +2052,22 @@ OCCT: rounding a profile before extruding keeps you on fast Manifold. Force the
 `meta.backend: "occt" | "manifold"` if you ever need to. Because an OCCT part is built
 entirely on OCCT, its fillets are exact in the STEP **and** present in the printed STL.
 
+The probe re-runs with the **live parameters on every regen**, and routing works in both
+directions: turn a fillet on and the part moves to OCCT; dial it back to 0 (or take the
+branch that skips it) and the part drops back to Manifold automatically. A zero magnitude
+— `fillet(0)`, `chamfer({ d: 0 })` — is the **identity** on both backends (see
+KERNEL-CONTRACT.md), so an unguarded `s.fillet(p.r)` needs no `if (p.r > 0)` wrapper to
+get the fast preview back when the slider hits 0. (`shell` is the exception: `t: 0` is
+degenerate, not identity, so a shell call always routes to OCCT.)
+
+**Preview routing is per sub-part.** Each sub-part is probed and routed independently, and
+a mixed part's regen fans out to both workers in parallel — a filleted body pays for OCCT
+while a plain lid rebuilds at Manifold speed beside it. This makes it worth isolating a
+CAD-op solid in its own sub-part rather than folding it into a bigger build. Two scopes
+still route whole-part (the max over the sub-parts): **exports** (one STL/STEP/3MF job
+builds everything in one worker) and the **CLI** (a single Node process boots exactly one
+kernel). Within one sub-part's build there is no per-op backend mixing.
+
 **Shading intent.** The kernel decides what shades smooth and where edge lines
 draw — spheres, cylinders and fillets are smooth by construction; boolean cut
 seams always shade hard and draw a line; a loft's facets shade flat when its

package/docs/ERROR-PATTERNS.md

@@ -52,8 +52,8 @@ The framework itself rebuilds each sub-part fresh per job and applies `place` on
 ## probe-routed-to-occt
 
 - **Symptom:** A part builds far slower than expected (preview takes seconds instead of milliseconds), and the worker logs show it running on the `occt` worker.
-- **Cause:** The geometry-free probe runs `build` against a recording proxy (dummy query values), and a **Solid** `fillet`/`chamfer`/`shell` call it reaches — including a branch the real build wouldn't take, since queries return dummies — routes the whole part to OCCT. (`Shape2D.fillet`/`.chamfer` are the shared pure-JS implementation and do **not** route; the probe tracks which handle kind an op ran on.)
-- **Fix:** Remove the CAD-only call the probe reaches unnecessarily, or force the backend with `meta.backend: "manifold"` (or `"occt"`). If the rounding is on a 2-D profile, `Shape2D.fillet` before extruding keeps the part on Manifold. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Fillet & chamfer (automatic OCCT backend)".
+- **Cause:** The geometry-free probe runs `build` against a recording proxy (dummy query values), and a **Solid** `fillet`/`chamfer`/`shell` call it reaches — including a branch the real build wouldn't take, since queries return dummies — routes that sub-part to OCCT (preview routing is per sub-part; exports and the CLI route the whole part to the max over its sub-parts, since those jobs run in one worker/kernel). (`Shape2D.fillet`/`.chamfer` are the shared pure-JS implementation and do **not** route; the probe tracks which handle kind an op ran on. A magnitude that is provably `0` — `fillet(0)`, `chamfer({d: 0})` — is the identity and does not route either, so a fillet param dialed to 0 reverts the part to Manifold with no guard; a magnitude the probe can't prove zero — e.g. computed from a dummy query value — routes conservatively.)
+- **Fix:** Remove the CAD-only call the probe reaches unnecessarily, or force the backend with `meta.backend: "manifold"` (or `"occt"`). If the rounding is on a 2-D profile, `Shape2D.fillet` before extruding keeps the part on Manifold. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Fillet & chamfer (automatic OCCT backend)". (Routing re-runs with live params on every regen — even after a runtime `needs-occt` reroute, which pins OCCT only until the params next change — so a stale backend choice never outlives a parameter edit.)
 
 ## fillet-chamfer-many-edges-slow
 

package/docs/KERNEL-CONTRACT.md

@@ -33,10 +33,16 @@ carries the conformance semantics and that one the usage guidance;
 **Core class.** A conforming core kernel implements every op in `KERNEL_OPS` and
 every `Solid` op in `SOLID_OPS`, *except* that the B-rep ops (`fillet`, `chamfer`,
 `shell` — the `OCCT_ONLY_OPS` list — and `toSTEP`) may instead throw
-`KernelCapabilityError`. The in-repo Manifold backend is the reference core kernel.
-Kernels built from this repo get the stubs for free: `addSugar()` generates the
-Solid-level stubs from `OCCT_ONLY_OPS`, and `finishKernel()` stubs `toSTEP` (a
-kernel-level op, so it is not in that Solid-op list).
+`KernelCapabilityError`. Exception to the exception: `fillet(0)` / `chamfer({d: 0})`
+(a magnitude that is exactly the number `0`, either calling convention) is the
+**identity** on every class — it returns the solid unchanged and must not throw, so a
+parametric radius dialed to 0 builds on a core kernel with no guard in the part.
+`shell` has no identity form (`t: 0` means zero-thickness walls — degenerate, not
+identity) and always throws on core. The in-repo Manifold backend is the reference
+core kernel. Kernels built from this repo get the stubs for free: `addSugar()`
+generates the Solid-level stubs (including the zero-magnitude identity) from
+`OCCT_ONLY_OPS`, and `finishKernel()` stubs `toSTEP` (a kernel-level op, so it is
+not in that Solid-op list).
 
 **B-rep class.** Core plus native `fillet`/`chamfer`/`shell` and `toSTEP`. The in-repo
 OCCT/replicad backend is the reference.
@@ -51,10 +57,12 @@ have gone unbuilt for three consecutive rebinds.
 
 `KernelCapabilityError` is a *routing signal*, not a failure: partforge's geometry-free
 probe (`probe.js`) runs `build` against a fake kernel, and any use of an `OCCT_ONLY_OPS`
-op **on a Solid handle** routes the whole part to a B-rep-class kernel (the probe tracks
+op **on a Solid handle** routes the build to a B-rep-class kernel (the probe tracks
 handle kinds, so the same names on a `Shape2D` — shared pure JS, backend-identical — do
-not route). A host with only a core kernel must surface the error ("this part needs a
-B-rep backend") rather than swallow it.
+not route). Routing granularity is a host choice: the in-repo framework routes preview
+builds per sub-part (each sub-part builds wholly on one kernel) and exports/CLI whole-
+part; a single-kernel host routes everything whole-part. A host with only a core kernel
+must surface the error ("this part needs a B-rep backend") rather than swallow it.
 
 ## Global semantics
 
@@ -266,7 +274,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `toMesh({quality?})` | Render mesh: `{positions, normals, indices?, triangles, edges?, featureIds?, features?}`. `indices` optional (a backend may emit soup or indexed); `normals` and `edges` are authoritative shading intent from both backends — see [Shading intent](#shading-intent-tomesh-normals-and-edges) below; `featureIds`/`features` are optional metadata. |
 | `toSTL({quality?})` | `Promise<ArrayBuffer>`, binary STL, outward CCW winding. Stored facet normals may be zero — slicers recompute them (the mesh backend happens to write them). |
 | `toIndexedMesh({quality?})` | `{positions, indices}` indexed mesh (3MF path); defaults to `"print"` like `toSTL`. Coincident vertices need NOT be welded — the 3MF writer welds, because that format reads topology from the indices rather than re-stitching soup by position the way an STL consumer does. |
-| `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | B-rep class (core throws `KernelCapabilityError`). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` hollows inward, keeping outer dimensions; `open` (face selector) is required. |
+| `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | B-rep class (core throws `KernelCapabilityError`), *except* a zero magnitude — `fillet(0)` / `chamfer({d: 0})` — which is the identity on every class (returns the solid unchanged, never throws; `shell` excluded, `t: 0` is degenerate). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` hollows inward, keeping outer dimensions; `open` (face selector) is required. |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for
 speed and a backend may bake it at kernel creation (Manifold does). A part must never

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.60.1",
+  "version": "0.61.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/app-mixed-smoke.js

@@ -0,0 +1,9 @@
+import part from "./parts/mixed-smoke.js";
+import { mount } from "./framework/index.js";
+
+// Dev/CI-only app for the mixed-backend smoke fixture — see parts/mixed-smoke.js.
+// Handle stashed for scripts/check-app.mjs, same as the other smoke apps.
+window.__pfRuntime = mount(part, {
+  createWorker: (name) =>
+    new Worker(new URL("./mixed-smoke-worker.js", import.meta.url), { type: "module", name }),
+});

package/src/framework/backend-select.js

@@ -2,27 +2,86 @@
 // This is framework-level policy, not geometry-kernel plumbing: it knows the full
 // PartDefinition shape (meta.backend, defaults, parts[name].build), unlike
 // everything in geometry/, which is part-agnostic.
-import { OCCT_ONLY_OPS } from "./geometry/kernel.js";
 import { createProbeKernel } from "./geometry/probe.js";
+import { isZeroMagnitudeCadOp } from "./geometry/op-options.js";
 import { resolveDerived } from "./derive.js";
 
-const OCCT_ONLY = new Set(OCCT_ONLY_OPS);
-
-export function detectBackend(part, params = {}) {
-  if (part.meta?.backend) return part.meta.backend;
+/**
+ * Per-sub-part routing: probe each sub-part's build independently and map it to
+ * its own backend, so a mixed part previews its plain sub-parts on fast Manifold
+ * while only the CAD-op ones pay for OCCT. Sub-parts build independently by
+ * construction (buildPosed builds one at a time), which is what makes splitting
+ * them across the two workers sound.
+ */
+export function detectBackends(part, params = {}) {
+  const forced = part.meta?.backend;
   const p = { ...part.defaults, ...params };
   let d = {};
   // A throwing derive must not escape here — this runs on the main thread mid
   // regen (after the busy spinner goes up). Probe with an empty `d`; the worker
   // build hits the same throw and posts a proper error for the UI.
   try { d = resolveDerived(part, p); } catch { /* fall through with d = {} */ }
-  const { kernel, solidUsed } = createProbeKernel();
+  const backends = {};
   for (const name of Object.keys(part.parts)) {
+    if (forced) { backends[name] = forced; continue; }
+    const { kernel, cadCalls } = createProbeKernel();
     try { part.parts[name].build(kernel, p, d); } catch { /* probe miss → capability backstop covers it */ }
+    // cadCalls holds only Solid-handle fillet/chamfer/shell — `Shape2D.fillet`/
+    // `.chamfer` are the shared pure-JS implementation (backend-identical) and must
+    // not drag a sub-part onto OCCT. A provably zero magnitude is the identity (see
+    // KERNEL-CONTRACT.md) and doesn't route either, so a fillet param dialed to 0
+    // drops the sub-part back onto Manifold with no `if (r > 0)` guard in the build.
+    backends[name] = cadCalls.some(({ op, args }) => !isZeroMagnitudeCadOp(op, args))
+      ? "occt"
+      : "manifold";
   }
-  // solidUsed, not used: `Shape2D.fillet`/`.chamfer` are the shared pure-JS
-  // implementation (backend-identical) and must not drag a part onto OCCT — only
-  // the same names called on a Solid are CAD-only.
-  for (const op of solidUsed) if (OCCT_ONLY.has(op)) return "occt";
-  return "manifold";
+  return backends;
+}
+
+// Whole-part detection: the max over detectBackends. This is the routing for
+// anything that must build every sub-part in ONE worker — exports (a single
+// STL/STEP/3MF job) and the single-process CLI, which can't mix kernels at all.
+export function detectBackend(part, params = {}) {
+  return Object.values(detectBackends(part, params)).includes("occt") ? "occt" : "manifold";
+}
+
+// The mount-time backend chooser. detectBackends() re-runs per regen with live
+// params, so backend choice already follows the parameters in both directions —
+// this wrapper exists for the runtime backstop: when the probe under-detects
+// (a CAD-only call it can't reach — e.g. gated on a real geometry query the
+// probe answers with dummies) the Manifold build throws NEEDS_OCCT and the
+// worker asks for a reroute. That must not pin OCCT for the rest of the session,
+// or turning the OCCT-only feature off never reverts to Manifold. Instead the
+// reroute is latched per (sub-part, params snapshot): the exact combination that
+// failed skips the doomed Manifold retry, and ANY param change re-consults the
+// probe. A part the probe chronically under-detects costs one cheap failed
+// Manifold dispatch per param change — the price of automatic reversion.
+export function createBackendPolicy(part, { forced = null } = {}) {
+  let latchedParams = null;  // JSON snapshot of the params proven at runtime to need OCCT
+  let latchedNames = null;   // the sub-parts that proved it (null = all of them)
+  const latched = (params, name) =>
+    latchedParams !== null && latchedParams === JSON.stringify(params) &&
+    (latchedNames === null || latchedNames.has(name));
+  return {
+    // name → backend for a preview generate; mount groups sub-parts by this.
+    backendsFor(params) {
+      const backends = detectBackends(part, params);
+      for (const name of Object.keys(backends)) {
+        if (forced) backends[name] = forced;
+        else if (latched(params, name)) backends[name] = "occt";
+      }
+      return backends;
+    },
+    // Whole-part max, for jobs that need one worker (exports).
+    backendFor(params) {
+      if (forced) return forced;
+      return Object.values(this.backendsFor(params)).includes("occt") ? "occt" : "manifold";
+    },
+    // `subparts` names the failed job's sub-parts; omitted (an export job, which
+    // doesn't carry them) it latches the whole part for these params.
+    noteNeedsOcct(params, subparts) {
+      latchedParams = JSON.stringify(params);
+      latchedNames = subparts ? new Set(subparts) : null;
+    },
+  };
 }

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

@@ -208,6 +208,9 @@ export function createOcctKernel(replicad) {
         const key = h("fillet", hash, radius, selKey(selector));
         return cached(key, () => {
           const a = mat();
+          // radius 0 is the identity per the contract — skip the kernel call so it
+          // can't trip the repair path's "feature skipped" warning.
+          if (radius === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
           return wrap(safeOp(a._s.clone(), (sh) => sh.fillet(radius, toEdgeFinder(selector)), `fillet(${radius})`), cloneLabels(a._labels), key);
         });
       },
@@ -216,6 +219,7 @@ export function createOcctKernel(replicad) {
         // validChamfer probes on internal clones and never consumes its input.
         return cached(key, () => {
           const a = mat();
+          if (distance === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key); // identity, same as fillet(0)
           return wrap(validChamfer(a._s, toEdgeFinder(selector), distance), cloneLabels(a._labels), key);
         });
       },

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

@@ -280,8 +280,8 @@ export const KERNEL_OP_SPECS = {
 };
 
 // Solid ops under the options convention; addSugar() wraps these when the
-// backend provides them natively (OCCT). The Manifold KernelCapabilityError
-// stubs ignore arguments, so options-form calls still throw the routing error.
+// backend provides them natively (OCCT). The Manifold stubs check only for the
+// zero-magnitude identity case below, then throw the routing error unnormalized.
 export const SOLID_OP_SPECS = {
   fillet:  { toArgs: (o) => { checkKeys("fillet", o, ["r", "edges"]);
     return [req("fillet", o, "r"), ...(o.edges !== undefined ? [o.edges] : [])]; } },
@@ -290,3 +290,17 @@ export const SOLID_OP_SPECS = {
   shell:   { toArgs: (o) => { checkKeys("shell", o, ["t", "open"]);
     return [req("shell", o, "t"), req("shell", o, "open")]; } },
 };
+
+// A zero-magnitude fillet/chamfer is the identity on every conformance class
+// (KERNEL-CONTRACT.md), so it neither routes a part to OCCT nor throws the
+// Manifold capability error. True only when the magnitude is PROVABLY the number
+// 0 in either calling convention — anything unprovable stays conservative
+// (routes/throws). shell is excluded: t = 0 means zero-thickness walls, which is
+// degenerate, not identity.
+export function isZeroMagnitudeCadOp(op, args) {
+  const key = op === "fillet" ? "r" : op === "chamfer" ? "d" : null;
+  if (!key) return false;
+  const a0 = args[0];
+  const v = typeof a0 === "number" ? a0 : isPlainOptions(a0) ? a0[key] : undefined;
+  return v === 0;
+}

package/src/framework/geometry/probe.js

@@ -15,7 +15,7 @@
 // lists, which test/kernel-contract.test.js pins to both backend implementations.
 import {
   KERNEL_OPS, KERNEL_OPTIONAL_OPS,
-  SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS,
+  SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS, OCCT_ONLY_OPS,
 } from "./kernel.js";
 import { KERNEL_OP_SPECS, SOLID_OP_SPECS, isPlainOptions } from "./op-options.js";
 
@@ -92,15 +92,22 @@ function makeProbe(onCall) {
   return { kernel, proxy, shape2d };
 }
 
+const CAD_OPS = new Set(OCCT_ONLY_OPS);
+
 export function createProbeKernel() {
   const used = new Set();       // every op name, any handle kind
   const solidUsed = new Set();  // ops recorded on kernel/Solid handles only — the
                                 // routing set: Shape2D.fillet must not look like Solid.fillet
-  const { kernel } = makeProbe((scope, key) => {
+  const cadCalls = [];          // Solid-handle fillet/chamfer/shell calls WITH args —
+                                // routing needs the magnitude (fillet(0) is identity, stays on Manifold)
+  const { kernel } = makeProbe((scope, key, args) => {
     used.add(key);
-    if (scope !== "shape2d") solidUsed.add(key);
+    if (scope !== "shape2d") {
+      solidUsed.add(key);
+      if (CAD_OPS.has(key)) cadCalls.push({ op: key, args });
+    }
   });
-  return { kernel, used, solidUsed };
+  return { kernel, used, solidUsed, cadCalls };
 }
 
 export function createValidatingProbe({ maxOps = MAX_PROBE_OPS } = {}) {

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

@@ -12,7 +12,7 @@
 //     the needs-occt reroute works without hand-written per-backend stubs.
 import { KernelCapabilityError } from "./errors.js";
 import { OCCT_ONLY_OPS } from "./kernel.js";
-import { isPlainOptions, SOLID_OP_SPECS } from "./op-options.js";
+import { isPlainOptions, isZeroMagnitudeCadOp, SOLID_OP_SPECS } from "./op-options.js";
 
 const ORIGIN = [0, 0, 0];
 const AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
@@ -59,14 +59,21 @@ export function addSugar(s) {
 
   // Options-object calling convention for the multi-param B-rep ops. Wrap only
   // when the backend provides the op natively (OCCT); the Manifold stubs below
-  // ignore their arguments, so options-form calls still throw the routing error.
+  // read their arguments just enough to spot the zero-magnitude identity case,
+  // and throw the routing error for everything else.
   for (const [op, { toArgs }] of Object.entries(SOLID_OP_SPECS)) {
     const raw = s[op];
     if (raw) s[op] = (...a) => raw(...(a.length === 1 && isPlainOptions(a[0]) ? toArgs(a[0]) : a));
   }
 
   for (const op of OCCT_ONLY_OPS) {
-    s[op] ??= () => { throw new KernelCapabilityError(`${op} requires the OCCT backend`); };
+    // Zero magnitude is the identity per the contract — return a fresh handle
+    // (same idiom as along("+Z")) so an unguarded `.fillet(p.r)` at r = 0 builds
+    // on the core kernel instead of throwing the routing error.
+    s[op] ??= (...a) => {
+      if (isZeroMagnitudeCadOp(op, a)) return s.translate(ORIGIN);
+      throw new KernelCapabilityError(`${op} requires the OCCT backend`);
+    };
   }
 
   return Object.assign(s, SUGAR);

package/src/framework/jobs.js

@@ -244,7 +244,9 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       post({ type: "report", ...report }, match?.map((m) => m.delta.data.buffer) ?? []);
     }
   } catch (err) {
-    if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt", jobId: msg.jobId });
+    // `subparts` (generate jobs only) tells the reroute policy which sub-parts the
+    // failed job covered, so only those latch to OCCT — not the whole part.
+    if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt", jobId: msg.jobId, subparts: msg.subparts });
     else post({ type: "error", message: String(err?.message || err), jobId: msg.jobId });
   } finally {
     kernel.cleanup?.();

package/src/framework/mount.js

@@ -13,7 +13,7 @@ import { createMeshCache } from "./mesh-cache.js";
 import { createGeometryService } from "./geometry-service.js";
 import { viewSubParts } from "./part-model.js";
 import { resolveDerived } from "./derive.js";
-import { detectBackend } from "./backend-select.js";
+import { createBackendPolicy } from "./backend-select.js";
 import { createDebugOverlay } from "./debug-overlay.js";
 import { createRegenLoop } from "./regen-loop.js";
 import { createPoseFastPath } from "./pose-fast-path.js";
@@ -253,10 +253,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
     cleanup.defer(() => ui.setStatus(""));
     cleanup.defer(() => ui.hideBusy());
 
-    // ?backend=occt|manifold forces the backend; otherwise it's detected per part.
+    // ?backend=occt|manifold forces the backend; otherwise it's re-detected per
+    // regen with the live params (so a fillet dialed to 0 reverts to Manifold),
+    // with a params-keyed latch for runtime needs-occt reroutes — see
+    // createBackendPolicy for why the latch must not outlive a param change.
     let forcedBackend = new URLSearchParams(location.search).get("backend");
     if (forcedBackend !== "occt" && forcedBackend !== "manifold") forcedBackend = null;
-    const backendFor = () => forcedBackend ?? detectBackend(part, params);
+    const backendPolicy = createBackendPolicy(part, { forced: forcedBackend });
+    const backendFor = () => backendPolicy.backendFor(params);
 
     // ?debug shows the cache debug overlay; ?debug&nocache starts with caching off.
     const qs = new URLSearchParams(location.search);
@@ -398,6 +402,10 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
 
     // The regenerate state machine (ready gating / debounce / stale-redo) lives in
     // regen-loop.js; this send callback is the one place a build job is dispatched.
+    // Routing is per SUB-part: the missing set splits by backend and each group goes
+    // to its own worker in parallel, so a mixed part previews its plain sub-parts at
+    // Manifold speed while only the filleted ones wait on OCCT. The return value is
+    // the job count — the loop holds the cycle open until every group has replied.
     const loop = createRegenLoop({
       missingParts,
       send: (missing) => {
@@ -406,7 +414,15 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
         lastGen = { skipped: needed.length - missing.length, rebuilt: missing.length, posed: pendingPosed.size };
         pendingPosed.clear(); // consumed — never counted against a second build
         ui.showBusy("generating");
-        service.send({ type: "generate", subparts: missing, view: view(), params, cache: cachingOn }, backendFor());
+        const backends = backendPolicy.backendsFor(params);
+        let jobs = 0;
+        for (const backend of ["manifold", "occt"]) {
+          const subparts = missing.filter((n) => (backends[n] ?? "manifold") === backend);
+          if (subparts.length === 0) continue;
+          service.send({ type: "generate", subparts, view: view(), params, cache: cachingOn }, backend);
+          jobs++;
+        }
+        return jobs;
       },
     });
     cleanup.defer(() => loop.dispose());
@@ -505,7 +521,10 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
               // delivered, which buildDone() true guarantees is at the live params.
               fastPath.recordDelivered(m.name);
             }
-            ui.hideBusy();
+            // A split dispatch answers in two meshes replies; the busy spinner
+            // stays up until the view has everything (the other worker's job may
+            // still be running — often OCCT, the slow one).
+            if (missingParts().length === 0) ui.hideBusy();
             refreshView();
             if (data.ms && missingParts().length === 0) {
               const tris = viewSubParts(part, view(), params).reduce((s, n) => s + viewer.subTriangles(n), 0);
@@ -513,11 +532,16 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
             }
             dbg?.update({ ms: data.ms, hits: data.cache?.hits ?? 0, misses: data.cache?.misses ?? 0, skipped: lastGen.skipped, rebuilt: lastGen.rebuilt, posed: lastGen.posed });
             onBuild?.({ status: "success", ms: data.ms });
-            if (!readySettled) { readySettled = true; resolveReady(); }
-            // First-show autoplay: latched separately from `ready`, which the
-            // error branch also settles — a part whose first build fails but
-            // whose retry succeeds still deserves its autoplay.
-            if (!autoplayKicked) { autoplayKicked = true; animCtl?.autoplayKick(); }
+            // ready/autoplay wait for the WHOLE view: a split dispatch delivers in
+            // two replies, and a host acting on `ready` (screenshotting, measuring)
+            // must never see half an assembly.
+            if (missingParts().length === 0) {
+              if (!readySettled) { readySettled = true; resolveReady(); }
+              // First-show autoplay: latched separately from `ready`, which the
+              // error branch also settles — a part whose first build fails but
+              // whose retry succeeds still deserves its autoplay.
+              if (!autoplayKicked) { autoplayKicked = true; animCtl?.autoplayKick(); }
+            }
           } else if (lastAnimApplyVersion === loop.version()) {
             // Stale ONLY because animation frames kept bumping the version:
             // show the delivered meshes anyway — that IS best-effort playback —
@@ -549,7 +573,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
           ui.setStatus(`${data.filename} downloaded`);
           break;
         case "needs-occt":
-          forcedBackend = "occt"; // probe missed; this part needs OCCT — stick to it
+          // Probe missed for the current params — rebuild the failed job's
+          // sub-parts on OCCT (an export reply has no subparts and latches the
+          // whole part). The latch is per params snapshot, so changing params
+          // re-consults the probe and sub-parts drop back to Manifold when the
+          // OCCT-only feature goes away.
+          backendPolicy.noteNeedsOcct(params, data.subparts);
           loop.buildDone();
           loop.kick();
           break;

package/src/framework/regen-loop.js

@@ -4,8 +4,10 @@
 //
 // Invariants (pinned by test/framework/regen-loop.test.js):
 // - nothing is sent until ready() (the worker announced its kernel);
-// - at most one build is in flight; kicks while generating are absorbed and the
-//   caller re-kicks after buildDone();
+// - at most one dispatch CYCLE is in flight; kicks while generating are absorbed
+//   and the caller re-kicks after the cycle's last buildDone(). `send` may fan a
+//   dispatch out to several workers (per-sub-part backend routing) and reports
+//   how many jobs it posted; each worker reply is one buildDone();
 // - markDirty() bumps the params version and debounces a kick, so dragging a
 //   slider queues one build per pause, not one per pixel;
 // - a build that a mid-flight edit outdated is reported stale by buildDone()
@@ -14,19 +16,19 @@
 //   fast-apply path kicks explicitly).
 export function createRegenLoop({ missingParts, send, debounceMs = 180 }) {
   let kernelReady = false;
-  let generating = false;
+  let pending = 0;       // worker replies still owed for the in-flight dispatch cycle
   let disposed = false;
   let paramsVersion = 0; // bumped on every settings edit
   let genVersion = -1;   // the params version the in-flight build is building
   let timer = null;
 
   function kick() {
-    if (disposed || !kernelReady || generating) return; // re-kicked when the current build finishes
+    if (disposed || !kernelReady || pending > 0) return; // re-kicked when the current cycle finishes
     const missing = missingParts();
     if (missing.length === 0) return;
-    generating = true;
     genVersion = paramsVersion;
-    send(missing);
+    // A send with no return value is the single-job case (one worker, one reply).
+    pending = send(missing) ?? 1;
   }
 
   return {
@@ -42,10 +44,12 @@ export function createRegenLoop({ missingParts, send, debounceMs = 180 }) {
       clearTimeout(timer);
       if (debounce) timer = setTimeout(kick, debounceMs);
     },
-    // The build finished (meshes / needs-occt / error). Returns whether its result
-    // is still current; the caller applies the meshes only on true, then kicks.
+    // One job of the cycle finished (meshes / needs-occt / error). Returns whether
+    // its result is still current; the caller applies the meshes only on true, then
+    // kicks (a no-op until the cycle's last reply). Guarded decrement: a reply
+    // outside any cycle (an export-triggered needs-occt) must not pre-close the next.
     buildDone() {
-      generating = false;
+      if (pending > 0) pending--;
       return genVersion === paramsVersion;
     },
     version: () => paramsVersion,

package/src/mixed-smoke-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/mixed-smoke.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/parts/mixed-smoke.js

@@ -0,0 +1,36 @@
+// CI fixture for per-sub-part backend routing (the mixed-backend twin of
+// text-smoke.js): one filleted sub-part that routes to OCCT next to a plain one
+// that stays on Manifold, so the smoke check exercises a split generate — two
+// workers answering one regen cycle — in a real browser. Dial "Edge fillet" to 0
+// and the whole part drops back to Manifold (zero magnitude is the identity).
+export default {
+  meta: { title: "Mixed smoke", units: "mm" },
+  parameters: [
+    {
+      id: "body",
+      title: "Body",
+      advanced: [
+        { key: "w", label: "Width", unit: "mm", min: 10, max: 60, step: 1 },
+        { key: "r", label: "Edge fillet", unit: "mm", min: 0, max: 5, step: 0.5 },
+      ],
+    },
+  ],
+  defaults: { w: 30, r: 2 },
+  parts: {
+    body: {
+      label: "Body",
+      views: ["assembly"],
+      export: { name: "body" },
+      // Unguarded on purpose: fillet(0) is the identity, so r drives the routing.
+      build: (k, p) => k.box({ min: [0, 0, 0], max: [p.w, p.w, 10] }).fillet({ r: p.r, edges: { dir: "Z" } }),
+    },
+    lid: {
+      label: "Lid",
+      views: ["assembly"],
+      export: { name: "lid" },
+      build: (k, p) => k.box({ min: [0, 0, 0], max: [p.w, p.w, 2] }),
+      place: (s) => s.at([0, 0, 12]),
+    },
+  },
+  views: { assembly: { label: "Assembly" } },
+};