partforge 0.6.1 → 0.7.0

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

@@ -1,9 +1,16 @@
 // src/framework/geometry/solid-sugar.js
-// Self-describing build-step vocabulary, defined ONCE over both geometry backends.
-// Every Solid a backend's wrap() returns is passed through addSugar(), which attaches
-// readable transform/placement methods composed purely from the solid's existing
-// rotate()/translate() primitives — so the sugar is geometry-identical to the
-// hand-written primitive calls, on Manifold and OCCT alike.
+// The backend-shared Solid front, defined ONCE over both geometry backends. Every
+// Solid a backend's wrap() returns is passed through addSugar(), which:
+//   - attaches the readable transform/placement vocabulary (rotateX/along/at/…),
+//     composed purely from the solid's own rotate()/translate() primitives, so the
+//     sugar is geometry-identical on Manifold and OCCT alike;
+//   - validates arguments the backends would otherwise each check (scale factor);
+//   - derives boundingBox center/size from the backend's raw {min,max};
+//   - stubs any OCCT-only op the backend lacks with a KernelCapabilityError, so
+//     the needs-occt reroute works without hand-written per-backend stubs.
+import { KernelCapabilityError } from "./errors.js";
+import { OCCT_ONLY_OPS } from "./kernel.js";
+
 const ORIGIN = [0, 0, 0];
 const AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
 
@@ -31,5 +38,25 @@ const SUGAR = {
 };
 
 export function addSugar(s) {
+  const rawScale = s.scale;
+  s.scale = (factor, center = ORIGIN) => {
+    if (!(factor > 0)) throw new Error("scale: factor must be > 0");
+    return rawScale(factor, center);
+  };
+
+  const rawBoundingBox = s.boundingBox;
+  s.boundingBox = () => {
+    const { min, max } = rawBoundingBox();
+    return {
+      min, max,
+      center: [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2],
+      size: [max[0] - min[0], max[1] - min[1], max[2] - min[2]],
+    };
+  };
+
+  for (const op of OCCT_ONLY_OPS) {
+    s[op] ??= () => { throw new KernelCapabilityError(`${op} requires the OCCT backend`); };
+  }
+
   return Object.assign(s, SUGAR);
 }

package/src/framework/geometry-service.js

@@ -9,10 +9,8 @@ export function createGeometryService({ createWorker, onMessage }) {
   const workers = { manifold: createWorker("manifold"), occt: createWorker("occt") };
   workers.manifold.onmessage = onMessage;
   workers.occt.onmessage = onMessage;
-  return {
-    generate: (msg, backend = "manifold") => workers[backend].postMessage(msg),
-    exportStl: (msg, backend = "manifold") => workers[backend].postMessage(msg),
-    export3mf: (msg, backend = "manifold") => workers[backend].postMessage(msg),
-    exportStep: (msg) => workers.occt.postMessage(msg), // STEP is always OCCT
-  };
+  // Post a job to the chosen backend's worker. The message's own `type` says what to
+  // do (generate / export-stl / export-3mf / export-step); `backend` picks the worker
+  // — manifold for preview/STL/3MF, occt for STEP (the caller passes "occt" for that).
+  return { send: (msg, backend = "manifold") => workers[backend].postMessage(msg) };
 }

package/src/framework/jobs.js

@@ -19,25 +19,44 @@ export function exportSubParts(part, view, params) {
   return viewSubParts(part, view, params).filter((name) => part.parts[name].exportable !== false);
 }
 
-// Handle one geometry job, posting results/progress via `post`. Backend-agnostic
-// and part-agnostic: every part specific comes through `part`.
+// Resolve a part's effective params + derived values for a build: the user's params
+// layered over the part defaults, and derive() run once over the result.
+export function resolveParams(part, params) {
+  const p = { ...part.defaults, ...params };
+  const d = part.derive ? part.derive(p) : {};
+  return { p, d };
+}
+
+// Build one sub-part and apply its optional place() for the given purpose/view.
+// `p`/`d` come from resolveParams(). This is the SINGLE definition of "a posed
+// sub-part solid" — the worker, the collision check, and the test harness all call
+// it, so display/export poses can never drift between the app and its tests.
+export function buildPosed(kernel, part, name, { purpose, view, p, d, onProgress } = {}) {
+  const sp = part.parts[name];
+  const solid = sp.build(kernel, p, d, onProgress);
+  return sp.place ? sp.place(solid, { view, purpose, p, d }) : solid;
+}
+
+// Handle one geometry job, posting results/progress via `post(msg, transfer?)`.
+// Backend-agnostic and part-agnostic: every part specific comes through `part`.
 //   { 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 }
+// 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.
 // Progress is posted as { type:"progress", phase }. Export builds thread the
 // progress callback into build() so a part's own per-feature progress surfaces;
 // 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) {
   const onProgress = (phase) => post({ type: "progress", phase });
-  const p = { ...part.defaults, ...msg.params };
-  const d = part.derive ? part.derive(p) : {};
+  const { p, d } = resolveParams(part, msg.params);
   const label = (name) => part.parts[name].label ?? name;
   const exportName = (name) => part.parts[name].export?.name ?? name;
-  const buildPosed = (name, purpose, view, prog) => {
-    const sp = part.parts[name];
-    const solid = sp.build(kernel, p, d, prog);
-    return sp.place ? sp.place(solid, { view, purpose, p, d }) : solid;
-  };
+  // Local shorthand over the shared helper: kernel/part/view/p/d are fixed per job.
+  const posed = (name, purpose, prog) => buildPosed(kernel, part, name, { purpose, view: msg.view, p, d, onProgress: prog });
 
   try {
     if (msg.type === "generate") {
@@ -48,37 +67,40 @@ export async function handle(kernel, part, msg, post) {
       for (const name of msg.subparts) {
         if (useCache) kernel.beginSubPart?.(name); // open the per-sub-part cache round
         try {
-          const m = buildPosed(name, "display", msg.view).toMesh({ quality: "preview" });
-          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges });
+          const m = posed(name, "display").toMesh({ quality: "preview" });
+          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features });
         } finally {
           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)
         }
       }
-      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.() });
+      const transfer = meshes.flatMap((m) =>
+        [m.positions.buffer, m.normals?.buffer, m.indices?.buffer, m.edges?.buffer, m.featureIds?.buffer].filter(Boolean));
+      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.() }, transfer);
     } else if (msg.type === "export-stl") {
       const out = [];
       for (const name of exportSubParts(part, msg.view, p)) {
         onProgress(`building ${label(name)}`);
-        out.push({ name: exportName(name), data: await buildPosed(name, "export", msg.view, onProgress).toSTL({ quality: "print" }) });
+        out.push({ name: exportName(name), data: await posed(name, "export", onProgress).toSTL({ quality: "print" }) });
       }
-      post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out });
+      post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out }, out.map((p) => bufferOf(p.data)));
     } else if (msg.type === "export-step") {
       const solids = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
-        return { name: exportName(name), solid: buildPosed(name, "export", msg.view, onProgress) };
+        return { name: exportName(name), solid: posed(name, "export", onProgress) };
       });
       onProgress("writing STEP file");
       const data = await kernel.toSTEP(solids);
-      post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" });
+      post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" }, [bufferOf(data)]);
     } else if (msg.type === "export-3mf") {
       const meshes = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
-        const { positions, indices } = buildPosed(name, "export", msg.view, onProgress).toIndexedMesh();
+        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh();
         return { name: exportName(name), positions, indices };
       });
       onProgress("writing 3MF file");
-      post({ type: "download", data: meshTo3MF(meshes), filename: `${msg.view}.3mf`, mime: "model/3mf" });
+      const data = meshTo3MF(meshes);
+      post({ type: "download", data, filename: `${msg.view}.3mf`, mime: "model/3mf" }, [bufferOf(data)]);
     }
   } catch (err) {
     if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt" });

package/src/framework/mesh-cache.js

@@ -0,0 +1,41 @@
+import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "./param-deps.js";
+
+// Tracks whether each sub-part's cached display mesh is still valid for the current
+// params ("Layer 1" of the cache — skipping regeneration of sub-parts whose inputs
+// didn't change). A sub-part's mesh is stamped with a relevance hash over just the
+// params that sub-part reads; it's current while that hash is unchanged and the mesh
+// is still in the viewer.
+//
+// The view/paramsVersion/caching state lives in mount and changes over time, so it's
+// passed as getters. `params` is a stable object mutated in place, so it's passed by
+// reference.
+export function createMeshCache(part, viewer, { params, getView, getParamsVersion, isCaching }) {
+  const cacheHash = {}; // name -> relevance hash the cached mesh was built at
+
+  // Memoize the per-sub-part read-key map per (paramsVersion, view): subPartReadKeys
+  // runs probe builds, so we compute it once per change, not per sub-part.
+  let readsKey = null, readsMap = null;
+  const readsFor = () => {
+    const key = `${getParamsVersion()}|${getView()}`;
+    if (readsKey !== key) { readsKey = key; readsMap = subPartReadKeys(part, getView(), params); }
+    return readsMap;
+  };
+
+  // The relevance hash for one sub-part at the current params (RELEVANT_ALL → hash
+  // over ALL params, so any edit invalidates it — the safe fallback).
+  const hashFor = (name) => {
+    if (!isCaching()) return `v${getParamsVersion()}`; // caching off: any edit invalidates every sub-part
+    const reads = readsFor();
+    const keys = reads === RELEVANT_ALL ? Object.keys(params) : [...(reads.get(name) ?? Object.keys(params))];
+    return relevanceHash(keys, params);
+  };
+
+  return {
+    // A cached sub-part is current only if its relevance hash is unchanged.
+    isCurrent: (name) => viewer.hasSubMesh(name) && cacheHash[name] === hashFor(name),
+    // Stamp a freshly built mesh with the hash it was built at.
+    record: (name) => { cacheHash[name] = hashFor(name); },
+    // Drop a sub-part's stamp so it rebuilds next generate.
+    forget: (name) => { delete cacheHash[name]; },
+  };
+}