partforge 0.60.2 → 0.62.0

package/src/framework/geometry/probe.js

@@ -1,7 +1,7 @@
 // Geometry-free build execution. Two consumers share one Proxy implementation:
 //
 //  • createProbeKernel() — records op NAMES so ../backend-select.js's
-//    detectBackend() can route a part to OCCT when it uses fillet/chamfer/shell.
+//    detectBackend() can route a part to OCCT when it uses Solid.shell.
 //  • createValidatingProbe() — additionally checks op names against the kernel
 //    contract's op lists and routes options-form calls through the same op-options
 //    normalizers the real backends use, so partforge/lint can catch a bad call in
@@ -15,17 +15,17 @@
 // 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, OCCT_ONLY_OPS,
+  SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS, ROUTED_CAD_OPS,
 } from "./kernel.js";
 import { KERNEL_OP_SPECS, SOLID_OP_SPECS, isPlainOptions } from "./op-options.js";
 
 // The probe hands out TWO chainable handles: k.shape2d()/k.text2d() yield a Shape2D
 // handle (whose extrude/revolve yield the Solid handle), everything else yields the
-// Solid handle. The split exists for one reason — backend routing: `Shape2D.fillet`
-// is the shared pure-JS implementation and must NOT route a part to OCCT, while
-// `Solid.fillet` must. Handle-level VALIDATION stays deliberately permissive (one
-// union allowlist for both handle kinds), so the split can never false-positive on
-// an error-severity rule.
+// Solid handle. The split lets lint and routing distinguish handle-specific ops:
+// `Shape2D.fillet` is shared pure JS, `Solid.fillet` starts mesh-native and may
+// request a runtime OCCT fallback, and `Solid.shell` probe-routes up front.
+// Handle-level VALIDATION stays deliberately permissive (one union allowlist for
+// both handle kinds), so the split can never false-positive on an error rule.
 const KERNEL_ALLOWED = new Set([...KERNEL_OPS, ...KERNEL_OPTIONAL_OPS]);
 const SOLID_ALLOWED = new Set([...SOLID_OPS, ...SOLID_OPTIONAL_OPS, ...SHAPE2D_OPS]);
 
@@ -92,14 +92,13 @@ function makeProbe(onCall) {
   return { kernel, proxy, shape2d };
 }
 
-const CAD_OPS = new Set(OCCT_ONLY_OPS);
+const CAD_OPS = new Set(ROUTED_CAD_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 cadCalls = [];          // Solid-handle fillet/chamfer/shell calls WITH args —
-                                // routing needs the magnitude (fillet(0) is identity, stays on Manifold)
+  const cadCalls = [];          // Probe-routed Solid ops WITH args (currently shell).
   const { kernel } = makeProbe((scope, key, args) => {
     used.add(key);
     if (scope !== "shape2d") {

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/lint/rules-build.js

@@ -2,10 +2,12 @@
 // the validating probe with no geometry kernel. Every error in this group already
 // throws at runtime; the value is reaching it in microseconds, before a WASM boot.
 import { err, warn } from "./finding.js";
-import { OCCT_ONLY_OPS } from "../geometry/kernel.js";
+import { ROUTED_CAD_OPS } from "../geometry/kernel.js";
 import { MAX_PROBE_OPS } from "../geometry/probe.js";
 
-const OCCT_ONLY = new Set(OCCT_ONLY_OPS);
+// fillet/chamfer are implemented on the mesh backend now (mesh-fillet.js), so a
+// pinned-Manifold part may use them; only the still-unimplemented ops error here.
+const OCCT_ONLY = new Set(ROUTED_CAD_OPS);
 const unique = (xs) => [...new Set(xs)];
 
 export const BUILD_RULES = [
@@ -52,9 +54,8 @@ export const BUILD_RULES = [
     id: "manifold-backend-uses-occt-op",
     run: ({ part, probe }) => {
       if (part?.meta?.backend !== "manifold") return [];
-      // solidUsed, not used: `Shape2D.fillet`/`.chamfer` are backend-identical pure
-      // JS and are fine under a pinned Manifold backend; only Solid-handle uses of
-      // these names are CAD-only.
+      // solidUsed, not used: a Shape2D method with the same name as a routed Solid
+      // op is still backend-identical pure JS and is fine under pinned Manifold.
       return [...probe().solidUsed].filter((op) => OCCT_ONLY.has(op))
         .map((op) => err("manifold-backend-uses-occt-op",
           `\`meta.backend\` pins Manifold, but the build calls \`${op}\`, which only OCCT implements`,

package/src/framework/mount.js

@@ -402,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 OCCT-routed ones wait. The return value is
+    // the job count — the loop holds the cycle open until every group has replied.
     const loop = createRegenLoop({
       missingParts,
       send: (missing) => {
@@ -410,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());
@@ -509,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);
@@ -517,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 —
@@ -553,10 +573,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
           ui.setStatus(`${data.filename} downloaded`);
           break;
         case "needs-occt":
-          // Probe missed for the current params — rebuild on OCCT. The latch is
-          // per params snapshot, so changing params re-consults the probe and the
-          // part can drop back to Manifold when the OCCT-only feature goes away.
-          backendPolicy.noteNeedsOcct(params);
+          // 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
+          // unsupported edge class or other runtime-only requirement 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/filleted-box.js

@@ -1,5 +1,6 @@
-// Example part exercising native CAD ops — it auto-routes to the OCCT backend
-// because it uses fillet (and chamfer when enabled). Vertical edges are rounded
+// Example part exercising the CAD dress-up ops. Since contract v3 fillet and
+// chamfer build natively on the fast Manifold backend (mesh-fillet.js); STEP
+// export still uses OCCT's exact B-rep blends. Vertical edges are rounded
 // and an optional bore drilled; the base chamfer is off by default (turn it up to
 // try chamfering, kept off in defaults so the gating build uses only the fillet).
 export default {

package/src/parts/mixed-smoke.js

@@ -0,0 +1,43 @@
+// CI fixture for per-sub-part backend routing (the mixed-backend twin of
+// text-smoke.js): one shelled 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 "Wall" to 0 and
+// the whole part drops back to Manifold (the build skips the shell branch).
+// Shell is the routing exemplar since contract v3 — fillet/chamfer build
+// natively on the mesh backend and no longer route.
+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: "t", label: "Wall", unit: "mm", min: 0, max: 5, step: 0.5 },
+      ],
+    },
+  ],
+  defaults: { w: 30, t: 2 },
+  parts: {
+    body: {
+      label: "Body",
+      views: ["assembly"],
+      export: { name: "body" },
+      // The t > 0 branch is what drives the routing: the probe re-runs with live
+      // params, so the shell call is only seen (and OCCT only engaged) when the
+      // wall is dialed on.
+      build: (k, p) => {
+        const box = k.box({ min: [0, 0, 0], max: [p.w, p.w, 10] });
+        return p.t > 0 ? box.shell({ t: p.t, open: { dir: "Z" } }) : box;
+      },
+    },
+    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" } },
+};

package/types/kernel.d.ts

@@ -128,7 +128,7 @@ export type CornerSelector =
 /** A mirror line for `Shape2D.mirror`. */
 export type MirrorAxis2 = "x" | "y" | { point: Point2; dir: Point2 };
 
-// --- edge / face selectors (OCCT-only ops) ---------------------------------
+// --- edge / face selectors --------------------------------------------------
 
 /**
  * Which edges a `fillet`/`chamfer` applies to. Omit for every edge. The object
@@ -254,12 +254,15 @@ export interface Solid {
   toSTL(opts?: { quality?: MeshQuality }): Promise<ArrayBuffer>;
   toIndexedMesh(): IndexedMesh;
   /**
-   * Round edges — OCCT only (Manifold throws `KernelCapabilityError`, and the
-   * probe routes a part that calls this to OCCT). Legacy `(r, selector)` is
-   * accepted until contract v2.
+   * Round edges. Manifold handles straight and circular chains natively and
+   * triggers an automatic OCCT fallback for unsupported edge classes. Legacy
+   * `(r, selector)` is accepted until contract v2.
    */
   fillet(r: number | { r: number; edges?: EdgeSelector }): Solid;
-  /** Bevel edges — OCCT only. Legacy `(d, selector)` accepted until contract v2. */
+  /**
+   * Bevel edges, with the same mesh-native coverage and OCCT fallback as
+   * `fillet`. Legacy `(d, selector)` is accepted until contract v2.
+   */
   chamfer(d: number | { d: number; edges?: EdgeSelector }): Solid;
   /**
    * Hollow inward, wall `t`, opening the faces `open` selects — OCCT only.
@@ -454,7 +457,7 @@ export interface GeometryKernel {
   /** Rim round-overs via one lathe revolve; curve-exact in STEP. */
   roundedCylinder(o: RoundedCylinderOptions): Solid;
   torus(o: TorusOptions): Solid;
-  /** Selective edge rounding. Stays on Manifold (unlike `Solid.fillet`). */
+  /** Selective edge rounding built directly as one Manifold mesh. */
   roundedBox(o: RoundedBoxOptions): Solid;
   /** N-ary boolean union. */
   union(solids: Solid[]): Solid;