partforge 0.1.0

package/src/framework/jobs.js

@@ -0,0 +1,73 @@
+import { meshTo3MF } from "./geometry/threemf.js";
+
+// Names of the sub-parts a view shows: declared in the view and enabled for these
+// params. Order follows Object.keys(part.parts) (definition order).
+export function viewSubParts(part, view, params) {
+  return Object.keys(part.parts).filter((name) => {
+    const sp = part.parts[name];
+    const inView = sp.views.includes(view);
+    const on = sp.enabled ? !!sp.enabled(params) : true;
+    return inView && on;
+  });
+}
+
+// Handle one geometry job, posting results/progress via `post`. 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 }
+// 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.
+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 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;
+  };
+
+  try {
+    if (msg.type === "generate") {
+      const t0 = Date.now();
+      const meshes = [];
+      for (const name of msg.subparts) {
+        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 });
+        kernel.cleanup?.();
+      }
+      post({ type: "meshes", meshes, ms: Date.now() - t0 });
+    } else if (msg.type === "export-stl") {
+      const out = [];
+      for (const name of viewSubParts(part, msg.view, p)) {
+        onProgress(`building ${label(name)}`);
+        out.push({ name: exportName(name), data: await buildPosed(name, "export", msg.view, onProgress).toSTL({ quality: "print" }) });
+      }
+      post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out });
+    } else if (msg.type === "export-step") {
+      const solids = viewSubParts(part, msg.view, p).map((name) => {
+        onProgress(`building ${label(name)}`);
+        return { name: exportName(name), solid: buildPosed(name, "export", msg.view, onProgress) };
+      });
+      onProgress("writing STEP file");
+      const data = await kernel.toSTEP(solids);
+      post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" });
+    } else if (msg.type === "export-3mf") {
+      const meshes = viewSubParts(part, msg.view, p).map((name) => {
+        onProgress(`building ${label(name)}`);
+        const { positions, indices } = buildPosed(name, "export", msg.view, 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" });
+    }
+  } catch (err) {
+    post({ type: "error", message: String(err?.message || err) });
+  } finally {
+    kernel.cleanup?.();
+  }
+}

package/src/framework/mount.js

@@ -0,0 +1,227 @@
+import "./app.css"; // shared chrome styles — every part-app gets them via mount
+import { zipSync } from "fflate";
+import { createViewer } from "./viewer.js";
+import { buildControls } from "./controls.js";
+import { createGeometryService } from "./geometry-service.js";
+import { viewSubParts } from "./jobs.js";
+
+// Mount a full parametric-part app from a PartDefinition: 3-D viewer + control
+// panel + the two geometry workers + the auto-regenerating view/cache loop +
+// STL/STEP export. The app supplies `createWorker(name)` so Vite can bundle the
+// worker (see geometry-service.js). DOM element ids match the host page:
+// #app (viewer), #controls, #status, #download, #download-step, #busy, #phase,
+// #part (the view-tab segmented control).
+export function mount(part, { createWorker, container = document.getElementById("app"),
+                              controls = document.getElementById("controls") } = {}) {
+  const names = Object.keys(part.parts);
+  const viewer = createViewer(container, part);
+
+  // ?backend=occt routes preview generate through the OCCT worker (dev toggle).
+  const occtPreview = new URLSearchParams(location.search).get("backend") === "occt";
+
+  const statusEl = document.getElementById("status");
+  const dlBtn = document.getElementById("download");
+  const dlStepBtn = document.getElementById("download-step");
+  const dl3mfBtn = document.getElementById("download-3mf");
+  const busyEl = document.getElementById("busy");
+  const phaseEl = document.getElementById("phase");
+  const partSeg = document.getElementById("part");
+  let kernelReady = false;
+
+  const exportBtns = [dlBtn, dlStepBtn, dl3mfBtn].filter(Boolean);
+  const setExportEnabled = (on) => exportBtns.forEach((b) => { b.disabled = !on; });
+
+  const setStatus = (msg, isErr = false) => { statusEl.textContent = msg; statusEl.classList.toggle("err", isErr); };
+  const showBusy = (phase) => { phaseEl.textContent = `${phase}…`; busyEl.classList.add("show"); };
+  const hideBusy = () => busyEl.classList.remove("show");
+
+  // --- per-sub-part mesh cache + auto-regenerating view composition ----------
+  // The host page owns the view-tab markup (#part buttons, data-part = view name);
+  // `part.views` documents the available views and their labels for that page.
+  // The initial view is whichever tab the page marks active (else the first tab).
+  const params = { ...part.defaults };
+  let view = partSeg.querySelector("button.on")?.dataset.part ?? partSeg.querySelector("button")?.dataset.part;
+  let framedView = null; // the view the camera was last framed to (null until first show)
+  let generating = false;
+  let paramsVersion = 0; // bumped on every settings edit
+  let genVersion = -1;   // the params version the in-flight generate is building
+  let genTimer = null;   // debounce timer for auto-regenerate
+  const cacheVersion = Object.fromEntries(names.map((n) => [n, -1])); // params version each was built at
+
+  // A cached sub-part is current only if it was built at the latest params version.
+  const isCurrent = (n) => viewer._subCache[n] && cacheVersion[n] === paramsVersion;
+  const missingParts = () => viewSubParts(part, view, params).filter((n) => !isCurrent(n));
+
+  // Reflect the active view. If every needed part is current, show it and enable
+  // export. If stale (a regenerate is in flight), keep the old mesh visible so the
+  // view doesn't flicker. If nothing's built yet, show nothing.
+  // Show the assembly, framing the camera only the first time we show a given view
+  // (initial load / tab switch) — never on a regenerate, so zoom/orbit are kept.
+  function showView(needed) {
+    const frame = view !== framedView;
+    viewer.showAssembly(needed, { frame });
+    if (frame) framedView = view;
+  }
+
+  function refreshView() {
+    const needed = viewSubParts(part, view, params);
+    if (needed.every(isCurrent)) {
+      showView(needed);
+      setExportEnabled(true);
+      const tris = needed.reduce((s, n) => s + viewer._subCache[n].userData.triangles, 0);
+      setStatus(`${tris.toLocaleString()} triangles`);
+    } else if (needed.every((n) => viewer._subCache[n])) {
+      showView(needed); // stale but present — keep it visible during regenerate
+      setExportEnabled(false);
+    } else {
+      viewer.hideAssembly();
+      setExportEnabled(false);
+    }
+  }
+
+  showBusy("booting kernel"); // visible from first paint until the kernel is ready
+
+  // --- download helpers ------------------------------------------------------
+  function triggerDownload(arrayBuffer, filename, mime) {
+    const url = URL.createObjectURL(new Blob([arrayBuffer], { type: mime }));
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+
+  function onDownloadParts({ parts, ext, mime }) {
+    if (parts.length === 1) return triggerDownload(parts[0].data, `${parts[0].name}.${ext}`, mime);
+    const entries = {};
+    for (const p of parts) entries[`${p.name}.${ext}`] = new Uint8Array(p.data);
+    triggerDownload(zipSync(entries, { level: 0 }), `${part.meta?.title ?? "parts"}.zip`.toLowerCase().replace(/\s+/g, "-"), "application/zip");
+  }
+
+  // --- shared message handler ------------------------------------------------
+  function onWorkerMessage({ data }) {
+    switch (data.type) {
+      case "ready":
+        kernelReady = true;
+        maybeGenerate(); // auto-build the default view (keeps the busy spinner up)
+        break;
+      case "progress":
+        showBusy(data.phase);
+        setStatus(`${data.phase}…`);
+        break;
+      case "meshes": {
+        generating = false;
+        if (genVersion !== paramsVersion) { maybeGenerate(); break; } // changed mid-build → redo
+        for (const m of data.meshes) {
+          if (viewer._subCache[m.name]) { viewer._subCache[m.name].userData.edges?.dispose(); viewer._subCache[m.name].dispose(); }
+          viewer.setSubGeometry(m.name, m);
+          cacheVersion[m.name] = genVersion;
+        }
+        hideBusy();
+        refreshView();
+        if (data.ms && missingParts().length === 0) {
+          setStatus(`${statusEl.textContent} · ${(data.ms / 1000).toFixed(1)} s`);
+        }
+        maybeGenerate(); // active view may still need parts (tab switched during build)
+        break;
+      }
+      case "download-parts":
+        hideBusy();
+        onDownloadParts(data);
+        setStatus(`${data.parts.length} part(s) downloaded`);
+        break;
+      case "download":
+        hideBusy();
+        triggerDownload(data.data, data.filename, data.mime);
+        setStatus(`${data.filename} downloaded`);
+        break;
+      case "error":
+        generating = false;
+        hideBusy();
+        setStatus(`failed: ${data.message}`, true);
+        refreshView();
+        break;
+    }
+  }
+
+  const service = createGeometryService({ createWorker, onMessage: onWorkerMessage, occtPreview });
+
+  buildControls(controls, part.parameters, params, onParamChange);
+
+  function onParamChange() {
+    paramsVersion++; // every edit invalidates the caches (by version)
+    refreshView();   // keep showing the now-stale mesh (no flicker); disable export
+    scheduleGenerate();
+  }
+
+  // Debounce auto-regeneration so dragging a slider doesn't queue a build per pixel.
+  function scheduleGenerate() {
+    clearTimeout(genTimer);
+    genTimer = setTimeout(maybeGenerate, 180);
+  }
+
+  // Build whatever the active view is missing — automatic, no Generate button.
+  function maybeGenerate() {
+    if (!kernelReady || generating) return; // retried when the current build finishes
+    const missing = missingParts();
+    if (missing.length === 0) return;
+    generating = true;
+    genVersion = paramsVersion;
+    showBusy("generating");
+    service.generate({ type: "generate", subparts: missing, view, params });
+  }
+
+  partSeg.addEventListener("click", (e) => {
+    const btn = e.target.closest("button[data-part]");
+    if (!btn) return;
+    view = btn.dataset.part;
+    for (const b of partSeg.children) b.classList.toggle("on", b === btn);
+    refreshView();  // instant if the view's parts are cached + current
+    maybeGenerate(); // else auto-build the missing pieces
+  });
+
+  dlBtn.addEventListener("click", () => {
+    showBusy("exporting STL");
+    service.exportStl({ type: "export-stl", view, params });
+  });
+
+  dlStepBtn.addEventListener("click", () => {
+    showBusy("exporting STEP");
+    service.exportStep({ type: "export-step", view, params });
+  });
+
+  dl3mfBtn?.addEventListener("click", () => {
+    showBusy("exporting 3MF");
+    service.export3mf({ type: "export-3mf", view, params });
+  });
+
+  // --- viewer controls (optional host-page buttons: #pause / #reframe / #theme) --
+  const pauseBtn = document.getElementById("pause");
+  const reframeBtn = document.getElementById("reframe");
+  const themeBtn = document.getElementById("theme");
+
+  // Theme: toggle the page chrome (CSS vars keyed off <html data-theme>) and the
+  // scene together; remember the choice across reloads.
+  let theme = localStorage.getItem("theme") || "dark";
+  function applyTheme(mode) {
+    theme = mode;
+    document.documentElement.dataset.theme = mode;
+    viewer.setTheme(mode);
+    themeBtn?.classList.toggle("on", mode === "light");
+    localStorage.setItem("theme", mode);
+  }
+  applyTheme(theme);
+  themeBtn?.addEventListener("click", () => applyTheme(theme === "light" ? "dark" : "light"));
+
+  // Pause/resume the idle auto-rotation.
+  let rotating = true;
+  pauseBtn?.addEventListener("click", () => {
+    rotating = !rotating;
+    viewer.setAutoRotate(rotating);
+    pauseBtn.textContent = rotating ? "⏸" : "▶";
+    pauseBtn.title = rotating ? "Pause rotation" : "Resume rotation";
+  });
+
+  // Re-fit the camera to the current view.
+  reframeBtn?.addEventListener("click", () => viewer.frame());
+}

package/src/framework/viewer.js

@@ -0,0 +1,204 @@
+import * as THREE from "three";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+
+export function createViewer(container, part) {
+  const names = Object.keys(part.parts);
+
+  // --- renderer / scene / camera --------------------------------------------
+  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+  container.appendChild(renderer.domElement);
+
+  const scene = new THREE.Scene();
+
+  // Light/dark scene palettes (the page chrome is themed separately, via CSS on the
+  // host page). A part can override the dark background through meta.background.
+  const THEME = {
+    dark:  { bg: part.meta?.background ?? 0x15181d, grid: [0x2c333d, 0x222831], line: 0x1c232d },
+    light: { bg: 0xe9edf2, grid: [0xc4ccd6, 0xd6dce4], line: 0x33414f },
+  };
+  scene.background = new THREE.Color(THEME.dark.bg);
+
+  const camera = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
+  camera.position.set(18, 12, 18);
+
+  const controls = new OrbitControls(camera, renderer.domElement);
+  controls.enableDamping = true;
+  controls.autoRotate = true;
+  controls.autoRotateSpeed = 1.6;
+
+  // --- lights + grid --------------------------------------------------------
+  scene.add(new THREE.HemisphereLight(0xbfd4ff, 0x202024, 1.1));
+  const key = new THREE.DirectionalLight(0xffffff, 1.4);
+  key.position.set(8, 14, 10);
+  scene.add(key);
+  // 1 cm grid (mm units): 200 mm wide, 20 divisions -> 10 mm squares.
+  let grid = new THREE.GridHelper(200, 20, THEME.dark.grid[0], THEME.dark.grid[1]);
+  scene.add(grid);
+
+  // --- material + part groups -----------------------------------------------
+  const material = new THREE.MeshStandardMaterial({
+    color: 0x9fb4cc,
+    metalness: 0.25,
+    roughness: 0.55,
+    flatShading: false,
+    polygonOffset: true, // push the surface back so edge lines sit cleanly on top
+    polygonOffsetFactor: 1,
+    polygonOffsetUnits: 1,
+  });
+
+  // Sub-parts are meshed independently in a shared frame and cached, so any view
+  // is composed from cached pieces. `pivot` stands the part's Z axis up (parts are
+  // modelled Z-up; this faces the camera); `partsGroup` is recentred per view so
+  // the visible assembly sits at the origin.
+  const pivot = new THREE.Group();
+  pivot.rotation.x = -Math.PI / 2; // model Z (CAD up) -> vertical
+  scene.add(pivot);
+  const partsGroup = new THREE.Group();
+  pivot.add(partsGroup);
+
+  const subMesh = Object.fromEntries(
+    names.map((n) => [n, new THREE.Mesh(new THREE.BufferGeometry(), material)])
+  );
+  for (const m of Object.values(subMesh)) {
+    m.visible = false;
+    partsGroup.add(m);
+  }
+
+  // CAD-style feature edge lines (anti-aliased "fat" lines), one per sub-part.
+  const EDGE_ANGLE = 35; // deg — OCCT fallback threshold (Manifold supplies seam-aware edges)
+  const lineMaterial = new LineMaterial({ color: 0x1c232d, linewidth: 1.0 }); // ~10% lighter, 1 px
+  lineMaterial.resolution.set(innerWidth, innerHeight);
+  const subLines = Object.fromEntries(
+    names.map((n) => [n, new LineSegments2(new LineSegmentsGeometry(), lineMaterial)])
+  );
+  for (const l of Object.values(subLines)) {
+    l.visible = false;
+    partsGroup.add(l);
+  }
+
+  // Smooth shading within CREASE_ANGLE of a shared edge, hard edge past it — so the
+  // round body and helical groove read smooth while bore rims, drum faces, and
+  // groove walls stay crisp. Lower = more hard edges; raise toward Math.PI/3 for
+  // softer. (Worker normals are ignored; we recompute per the crease threshold.)
+  const CREASE_ANGLE = Math.PI / 6; // 30°
+
+  // --- geometry builder -----------------------------------------------------
+  // BufferGeometry from a worker mesh payload — kept in its shared-frame coords
+  // (NOT recentred) so the pieces assemble in the right relative positions.
+  function buildGeometry({ positions, normals, indices, triangles, edges }) {
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    if (indices?.length) geo.setIndex(new THREE.BufferAttribute(indices, 1)); // Manifold is non-indexed
+    const triCount = triangles ?? (indices ? indices.length : positions.length / 3) / 3;
+    let out;
+    if (normals?.length) {
+      // kernel-computed normals (Manifold) — smooth within a surface, hard at cut seams
+      geo.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+      geo.computeBoundingBox();
+      out = geo;
+    } else {
+      // fallback (no kernel normals, e.g. OCCT): crease from the triangle soup
+      out = toCreasedNormals(geo, CREASE_ANGLE);
+      out.computeBoundingBox();
+    }
+    out.userData.triangles = triCount;
+    // feature edge lines: Manifold supplies seam-aware segments; else derive by angle
+    const lg = new LineSegmentsGeometry();
+    if (edges?.length) lg.setPositions(edges);
+    else lg.fromEdgesGeometry(new THREE.EdgesGeometry(out, EDGE_ANGLE));
+    out.userData.edges = lg;
+    return out;
+  }
+
+  // --- sub-part geometry cache ----------------------------------------------
+  const subCache = Object.fromEntries(names.map((n) => [n, null]));
+
+  function setSubGeometry(name, payload) {
+    subCache[name] = buildGeometry(payload);
+  }
+
+  // --- show / hide assembly -------------------------------------------------
+  const _box = new THREE.Box3();
+
+  // Recentre the assembly on the pivot and frame the camera to the named parts.
+  function frameTo(visibleNames) {
+    _box.makeEmpty();
+    for (const name of visibleNames) if (subCache[name]) _box.union(subCache[name].boundingBox);
+    if (_box.isEmpty()) return;
+    const center = _box.getCenter(new THREE.Vector3());
+    partsGroup.position.copy(center).multiplyScalar(-1); // centre assembly on the pivot
+    const size = _box.getSize(new THREE.Vector3());
+    const r = Math.max(size.x, size.y, size.z) || 12;
+    camera.position.setLength(r * 2.6 + 6);
+    controls.target.set(0, 0, 0);
+  }
+
+  // Show exactly the named sub-parts (from the cache). When `frame` is set, also
+  // frame the camera to them — done only on the initial show and on view (tab)
+  // changes, NOT on regeneration, so a user's zoom/orbit survives editing params.
+  function showAssembly(visibleNames, { frame = false } = {}) {
+    for (const [name, mesh] of Object.entries(subMesh)) {
+      const on = visibleNames.includes(name);
+      if (on) {
+        mesh.geometry = subCache[name]; // cached geometries reused, not disposed
+        subLines[name].geometry = subCache[name].userData.edges;
+      }
+      mesh.visible = on;
+      subLines[name].visible = on;
+    }
+    if (frame) frameTo(visibleNames);
+  }
+
+  // Re-frame whatever is currently visible (the reframe button).
+  function frame() {
+    frameTo(names.filter((n) => subMesh[n].visible && subCache[n]));
+  }
+
+  function setAutoRotate(on) { controls.autoRotate = on; }
+
+  // Swap the scene background, grid, and edge-line colors for the given theme.
+  function setTheme(mode) {
+    const t = THEME[mode] ?? THEME.dark;
+    scene.background = new THREE.Color(t.bg);
+    scene.remove(grid);
+    grid = new THREE.GridHelper(200, 20, t.grid[0], t.grid[1]);
+    scene.add(grid);
+    lineMaterial.color.set(t.line);
+  }
+
+  function hideAssembly() {
+    for (const m of Object.values(subMesh)) m.visible = false;
+    for (const l of Object.values(subLines)) l.visible = false;
+  }
+
+  // --- resize ---------------------------------------------------------------
+  function resize() {
+    const w = innerWidth, h = innerHeight;
+    renderer.setSize(w, h);
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+    lineMaterial.resolution.set(w, h); // fat lines need the viewport size for px width
+  }
+  addEventListener("resize", resize);
+  resize();
+
+  // --- render loop ----------------------------------------------------------
+  renderer.setAnimationLoop(() => {
+    controls.update();
+    renderer.render(scene, camera);
+  });
+
+  // --- dispose --------------------------------------------------------------
+  function dispose() {
+    renderer.setAnimationLoop(null);
+    renderer.dispose();
+    container.removeChild(renderer.domElement);
+  }
+
+  return { showAssembly, hideAssembly, setSubGeometry, resize, dispose, frame, setAutoRotate, setTheme, _subCache: subCache };
+}

package/src/framework/worker.js

@@ -0,0 +1,76 @@
+// Worker runtime shared by every part. The host spawns this entry twice, named
+// "manifold" (preview + STL) and "occt" (STEP), via the Worker `name` option.
+// Each instance lazily imports only its own backend, so OCCT's ~11 MB WASM loads
+// only in the worker that needs it, and only on first use.
+import { handle } from "./jobs.js";
+
+async function manifoldKernels() {
+  const [{ default: Module }, { createManifoldKernel }] = await Promise.all([
+    import("manifold-3d"),
+    import("./geometry/manifold-backend.js"),
+  ]);
+  const wasm = await Module();
+  wasm.setup();
+  return {
+    preview: createManifoldKernel(wasm, { quality: "preview" }), // fast interactive view
+    print: createManifoldKernel(wasm, { quality: "print" }),     // high-res STL export
+  };
+}
+
+async function occtKernel() {
+  const [{ default: opencascade }, wasmUrlMod, replicad, { createOcctKernel }] = await Promise.all([
+    import("replicad-opencascadejs/src/replicad_single.js"),
+    import("replicad-opencascadejs/src/replicad_single.wasm?url"),
+    import("replicad"),
+    import("./geometry/occt-backend.js"),
+  ]);
+  const OC = await opencascade({ locateFile: () => wasmUrlMod.default });
+  replicad.setOC(OC);
+  return createOcctKernel(replicad);
+}
+
+// Transfer the big binary buffers (zero-copy) instead of structured-cloning them.
+function transferOf(m) {
+  if (m.type === "meshes") {
+    const t = [];
+    for (const x of m.meshes) {
+      t.push(x.positions.buffer);
+      if (x.normals?.buffer) t.push(x.normals.buffer);
+      if (x.indices?.buffer) t.push(x.indices.buffer);
+      if (x.edges?.buffer) t.push(x.edges.buffer);
+    }
+    return t;
+  }
+  if (m.type === "download-parts") return m.parts.map((p) => (ArrayBuffer.isView(p.data) ? p.data.buffer : p.data));
+  if (m.type === "download") return [m.data];
+  return [];
+}
+
+export function runWorker(part) {
+  const backend = self.name === "occt" ? "occt" : "manifold";
+  let manifold = null; // { preview, print }
+  let occt = null;
+  let booting = null;
+
+  // Manifold is cheap to boot — bring it up eagerly and signal readiness.
+  if (backend === "manifold") {
+    booting = manifoldKernels().then((m) => { manifold = m; postMessage({ type: "ready" }); });
+  }
+
+  self.onmessage = async (e) => {
+    let kernel;
+    if (backend === "manifold") {
+      await booting;
+      const printJob = e.data.type === "export-stl" || e.data.type === "export-3mf"; // high-res mesh exports
+      kernel = printJob ? manifold.print : manifold.preview;
+    } else {
+      if (!occt) {
+        postMessage({ type: "progress", phase: "loading exact kernel" }); // feedback during cold boot
+        booting = booting ?? occtKernel().then((k) => (occt = k));
+        await booting;
+      }
+      kernel = occt;
+    }
+    await handle(kernel, part, e.data, (m) => postMessage(m, transferOf(m)));
+  };
+}

package/src/index.js

@@ -0,0 +1,6 @@
+// partforge — app entry (DOM). Apps call mount(); viewSubParts is handy for app-side
+// view logic. This entry pulls in the viewer/controls (which use `document`), so it
+// must NOT be imported from a part's build functions — those run in a Web Worker.
+// Part build functions import geometry helpers from "partforge/geometry" instead.
+export { mount } from "./framework/index.js";
+export { viewSubParts } from "./framework/jobs.js";

package/src/parts/demo.js

@@ -0,0 +1,40 @@
+// Example PartDefinition — a parametric spacer. Proof that a new part is just a new
+// script: the framework (viewer, controls, workers, STL/STEP export) is reused
+// unchanged. Mount it with its own app/worker entry exactly as the drum does.
+export default {
+  meta: { title: "Spacer", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "body",
+      title: "Body",
+      presets: { M3: { od: 8, bore: 3.4, h: 10 }, M5: { od: 12, bore: 5.4, h: 16 } },
+      advanced: [
+        { key: "od", label: "Outer diameter", unit: "mm", min: 4, max: 40, step: 0.5 },
+        { key: "bore", label: "Bore", unit: "mm", min: 1, max: 30, step: 0.1, control: "number" },
+        { key: "h", label: "Height", unit: "mm", min: 2, max: 60, step: 1 },
+      ],
+    },
+    {
+      id: "flange",
+      title: "Flange",
+      features: [
+        { label: "Base flange", key: "flange_d", on: 16,
+          sliders: [{ key: "flange_d", label: "Flange diameter", unit: "mm", min: 8, max: 50, step: 1 }] },
+      ],
+    },
+  ],
+  defaults: { od: 8, bore: 3.4, h: 10, flange_d: 0 },
+  parts: {
+    spacer: {
+      label: "Spacer",
+      views: ["spacer"],
+      export: { name: "spacer" },
+      build: (k, p) => {
+        let s = k.cylinder(p.od / 2, p.od / 2, p.h);
+        if (p.flange_d > 0) s = k.union([s, k.cylinder(p.flange_d / 2, p.flange_d / 2, 2)]);
+        return s.cut(k.cylinder(p.bore / 2, p.bore / 2, p.h + 4).translate([0, 0, -2]));
+      },
+    },
+  },
+  views: { spacer: { label: "Spacer" } },
+};

package/src/testing/mesh.js

@@ -0,0 +1,21 @@
+// test/helpers.js — shared test utilities (mesh volume + bbox from a flat mesh).
+// `indices` is optional: when omitted the positions are treated as a flat,
+// non-indexed triangle soup (3 vertices per triangle).
+export function meshVolume(positions, indices) {
+  const n = indices ? indices.length : positions.length / 3;
+  let V = 0;
+  for (let i = 0; i < n; i += 3) {
+    const a = (indices ? indices[i] : i) * 3, b = (indices ? indices[i + 1] : i + 1) * 3, c = (indices ? indices[i + 2] : i + 2) * 3;
+    V += (positions[a] * (positions[b + 1] * positions[c + 2] - positions[b + 2] * positions[c + 1])
+        - positions[a + 1] * (positions[b] * positions[c + 2] - positions[b + 2] * positions[c])
+        + positions[a + 2] * (positions[b] * positions[c + 1] - positions[b + 1] * positions[c])) / 6;
+  }
+  return Math.abs(V);
+}
+export function bboxSize(positions) {
+  const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < positions.length; i += 3) for (let a = 0; a < 3; a++) {
+    lo[a] = Math.min(lo[a], positions[i + a]); hi[a] = Math.max(hi[a], positions[i + a]);
+  }
+  return [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
+}

package/src/testing/occt.js

@@ -0,0 +1,18 @@
+// Boots OCCT/replicad in a Node test process and returns a ready OCCT GeometryKernel.
+// (Manifold must NOT be booted in the same process — they crash together.)
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
+import { createOcctKernel } from "../framework/geometry/occt-backend.js";
+
+export async function bootOcctKernel() {
+  const require = createRequire(import.meta.url);
+  globalThis.require = globalThis.require ?? require;
+  globalThis.__dirname = globalThis.__dirname ?? path.dirname(fileURLToPath(import.meta.url));
+  const { default: init } = await import("replicad-opencascadejs/src/replicad_single.js");
+  const OC = await init({ wasmBinary: fs.readFileSync(require.resolve("replicad-opencascadejs/src/replicad_single.wasm")) });
+  const replicad = await import("replicad");
+  replicad.setOC(OC);
+  return createOcctKernel(replicad);
+}