partforge 0.1.0

package/src/framework/controls.js

@@ -0,0 +1,180 @@
+// Builds the sectioned control panel from a part's `parameters` schema.
+//
+// Most sections show a preset picker (below the title) plus an expandable
+// "Advanced" block of sliders. The "features" section instead puts, under
+// Advanced, a checkbox per feature followed by its own controls — ticking one
+// enables it and reveals those controls right below it.
+// All controls mutate the shared `params` object and call onDirty() on change.
+
+// Short numeric string without float noise (4 dp max) for the value box.
+const numStr = (v) => String(Math.round(v * 1e4) / 1e4);
+
+// Parse a typed value → clamped to [min, max], or null if not a finite number.
+export function clampToRange(raw, min, max) {
+  const v = parseFloat(raw);
+  if (!Number.isFinite(v)) return null;
+  return Math.min(max, Math.max(min, v));
+}
+
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+// One parameter control bound to params[def.key]. `def.control`:
+//   "slider" (default) — range slider + an editable number box (drag OR type)
+//   "number"           — number box only (no slider)
+// The box accepts exact values (finer than `step`); typed values clamp to
+// [min, max] on commit (blur/Enter). Returns { wrap, sync }.
+function makeSlider(def, params, onChange) {
+  const numeric = def.control === "number";
+  const wrap = el("div", "slider");
+  const row = el("div", "row");
+  row.append(el("label", "", def.label));
+
+  // editable value box (+ optional unit suffix)
+  const val = el("div", "val");
+  const box = document.createElement("input");
+  box.type = "number";
+  box.className = "num";
+  box.min = def.min; box.max = def.max; box.step = def.step;
+  box.value = numStr(params[def.key]);
+  val.append(box);
+  if (def.unit) val.append(el("span", "unit", def.unit));
+  row.append(val);
+  wrap.append(row);
+
+  let slider = null;
+  if (!numeric) {
+    slider = document.createElement("input");
+    slider.type = "range";
+    slider.min = def.min; slider.max = def.max; slider.step = def.step;
+    slider.value = params[def.key];
+    slider.addEventListener("input", () => {
+      params[def.key] = +slider.value;
+      box.value = numStr(+slider.value);
+      onChange?.();
+    });
+    wrap.append(slider);
+  }
+
+  // live preview while typing (unclamped); clamp + reformat on commit (blur/Enter)
+  box.addEventListener("input", () => {
+    const v = parseFloat(box.value);
+    if (!Number.isFinite(v)) return;
+    params[def.key] = v;
+    if (slider) slider.value = v;
+    onChange?.();
+  });
+  box.addEventListener("change", () => {
+    const v = clampToRange(box.value, def.min, def.max);
+    if (v == null) { box.value = numStr(params[def.key]); return; } // revert invalid input
+    params[def.key] = v;
+    box.value = numStr(v);
+    if (slider) slider.value = v;
+    onChange?.();
+  });
+
+  const sync = () => {
+    box.value = numStr(params[def.key]);
+    if (slider) slider.value = params[def.key];
+  };
+  return { wrap, sync };
+}
+
+// A collapsible "Advanced ▾" block. Returns { adv, toggle }.
+function advancedBlock() {
+  const adv = el("div", "adv hidden");
+  const toggle = el("button", "adv-toggle", "Advanced ▾");
+  toggle.addEventListener("click", () => {
+    const hidden = adv.classList.toggle("hidden");
+    toggle.textContent = hidden ? "Advanced ▾" : "Advanced ▴";
+  });
+  return { adv, toggle };
+}
+
+export function buildControls(root, parameters, params, onDirty) {
+  for (const sec of parameters) {
+    const section = el("div", "section");
+    section.append(el("div", "sec-title", sec.title));
+    if (sec.features) buildFeatureSection(section, sec, params, onDirty);
+    else buildPresetSection(section, sec, params, onDirty);
+    root.append(section);
+  }
+}
+
+function buildPresetSection(section, sec, params, onDirty) {
+  // preset picker, below the title, full width
+  const preset = document.createElement("select");
+  preset.className = "preset";
+  const presetNames = Object.keys(sec.presets);
+  for (const name of [...presetNames, "Custom"]) {
+    const o = document.createElement("option");
+    o.value = name;
+    o.textContent = name;
+    preset.append(o);
+  }
+  preset.value = presetNames[0];
+  section.append(preset);
+
+  const { adv, toggle } = advancedBlock();
+  const syncs = {};
+  for (const def of sec.advanced) {
+    const s = makeSlider(def, params, () => {
+      preset.value = "Custom";
+      onDirty?.();
+    });
+    adv.append(s.wrap);
+    syncs[def.key] = s.sync;
+  }
+  section.append(toggle, adv);
+
+  // applying a preset overwrites its keys and refreshes this section's sliders
+  preset.addEventListener("change", () => {
+    const bundle = sec.presets[preset.value];
+    if (!bundle) return; // "Custom"
+    Object.assign(params, bundle);
+    for (const key in syncs) if (key in params) syncs[key]();
+    onDirty?.();
+  });
+}
+
+function buildFeatureSection(section, sec, params, onDirty) {
+  // Everything lives under Advanced: each feature is a checkbox followed by its
+  // own controls, which appear directly below it when the box is checked.
+  const { adv, toggle } = advancedBlock();
+  section.append(toggle, adv);
+
+  for (const feat of sec.features) {
+    const checkRow = el("label", "feat");
+    const box = document.createElement("input");
+    box.type = "checkbox";
+    box.checked = params[feat.key] > 0;
+    checkRow.append(box, el("span", "", feat.label));
+
+    const group = el("div", "feat-group");
+    const syncs = [];
+    for (const def of feat.sliders) {
+      const s = makeSlider(def, params, onDirty);
+      group.append(s.wrap);
+      syncs.push(s.sync);
+    }
+    group.classList.toggle("hidden", !box.checked);
+
+    box.addEventListener("change", () => {
+      if (box.checked) {
+        if (!(params[feat.key] > 0)) params[feat.key] = feat.on; // enable
+        syncs.forEach((s) => s());
+        group.classList.remove("hidden");
+      } else {
+        params[feat.key] = 0; // disable
+        group.classList.add("hidden");
+      }
+      onDirty?.();
+    });
+
+    adv.append(checkRow, group); // checkbox, then its controls right below
+  }
+}

package/src/framework/geometry/fuzzy-cut.js

@@ -0,0 +1,32 @@
+// Fuzzy boolean cut via the raw OpenCASCADE kernel.
+//
+// replicad's high-level Shape3D.cut() runs BRepAlgoAPI_Cut with the default
+// (zero) fuzzy tolerance, which returns an EMPTY result for large near-tangent
+// helical groove tools (fine up to a few turns, empty by ~10). OCCT's fuzzy
+// boolean snaps near-coincident geometry within a tolerance and makes the
+// operation robust — this is how the full multi-turn drum gets cut.
+//
+// Mirrors replicad's own cut() (BRepAlgoAPI_Cut_3 + Build + SimplifyResult +
+// cast) and just adds SetFuzzyValue before Build.
+
+import { getOC, cast } from "replicad";
+
+export function fuzzyCut(base, tool, { fuzz = 1e-3, simplify = false } = {}) {
+  const oc = getOC();
+  const progress = new oc.Message_ProgressRange_1();
+  const cutter = new oc.BRepAlgoAPI_Cut_3(base.wrapped, tool.wrapped, progress);
+  cutter.SetFuzzyValue(fuzz);
+  cutter.Build(progress);
+  if (cutter.HasErrors && cutter.HasErrors()) {
+    cutter.delete();
+    progress.delete();
+    throw new Error(`fuzzy cut failed (OCCT BOP error, fuzz=${fuzz})`);
+  }
+  // SimplifyResult merges coplanar faces but is very slow on helical results —
+  // off by default; the mesh/STEP are fine without it.
+  if (simplify) cutter.SimplifyResult(true, true, 1e-3);
+  const result = cast(cutter.Shape());
+  cutter.delete();
+  progress.delete();
+  return result;
+}

package/src/framework/geometry/helix-tube.js

@@ -0,0 +1,50 @@
+// Builds a watertight triangle mesh of a circular profile swept along a helix in
+// its frenet frame, then imports it as a Manifold solid. The profile stays
+// perpendicular to the helix tangent (unlike twist-extrude), so it matches an
+// exact frenet sweep. Winding is consistent-outward; getting it wrong makes
+// Manifold.ofMesh throw or import an inverted solid.
+const norm = (v) => { const m = Math.hypot(...v); return [v[0] / m, v[1] / m, v[2] / m]; };
+const cross = (a, b) => [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]];
+
+export function helixTube(wasm, opts) {
+  const { pathR, profileR, pitch, turns, z0 = 0, lefthand = false,
+          stationsPerTurn = 24, ringSegs = 16 } = opts;
+  const sign = lefthand ? -1 : 1;
+  const c = pitch / (2 * Math.PI);          // z-rise per radian
+  const phiMax = 2 * Math.PI * turns;
+  const n = Math.max(2, Math.ceil(turns * stationsPerTurn)) + 1;
+  const V = [], Tr = [];
+
+  for (let i = 0; i < n; i++) {
+    const phi = (phiMax * i) / (n - 1);
+    const ctr = [pathR * Math.cos(sign * phi), pathR * Math.sin(sign * phi), z0 + c * phi];
+    const T = norm([-sign * pathR * Math.sin(sign * phi), sign * pathR * Math.cos(sign * phi), c]);
+    const N = [Math.cos(sign * phi), Math.sin(sign * phi), 0]; // radial, ⟂ T
+    const B = norm(cross(T, N));
+    for (let j = 0; j < ringSegs; j++) {
+      const a = (2 * Math.PI * j) / ringSegs;
+      V.push(ctr[0] + profileR * (Math.cos(a) * N[0] + Math.sin(a) * B[0]),
+             ctr[1] + profileR * (Math.cos(a) * N[1] + Math.sin(a) * B[1]),
+             ctr[2] + profileR * (Math.cos(a) * N[2] + Math.sin(a) * B[2]));
+    }
+  }
+  // side faces (outward winding)
+  for (let i = 0; i < n - 1; i++) for (let j = 0; j < ringSegs; j++) {
+    const a = i*ringSegs + j, b = i*ringSegs + (j+1)%ringSegs;
+    const cc = (i+1)*ringSegs + j, dd = (i+1)*ringSegs + (j+1)%ringSegs;
+    Tr.push(a, dd, cc, a, b, dd);
+  }
+  // end caps
+  const c0 = V.length / 3;
+  V.push(pathR * Math.cos(0), pathR * Math.sin(0), z0);
+  for (let j = 0; j < ringSegs; j++) Tr.push(c0, (j+1)%ringSegs, j);
+  const base = (n - 1) * ringSegs, cz = V.length / 3;
+  V.push(pathR * Math.cos(sign * phiMax), pathR * Math.sin(sign * phiMax), z0 + c * phiMax);
+  for (let j = 0; j < ringSegs; j++) Tr.push(cz, base + j, base + (j+1)%ringSegs);
+
+  const mesh = new wasm.Mesh({ numProp: 3, vertProperties: Float32Array.from(V), triVerts: Uint32Array.from(Tr) });
+  mesh.merge();
+  const out = wasm.Manifold.ofMesh(mesh);
+  mesh.delete?.(); // input mesh is consumed by ofMesh; free it (caller tracks `out`)
+  return out;
+}

package/src/framework/geometry/kernel.js

@@ -0,0 +1,25 @@
+// The GeometryKernel contract (documentation). Backends implement the @typedef
+// below. (2-D polygon helpers live in ./polygon.js.)
+
+/**
+ * @typedef {Object} Solid  An opaque handle to a backend solid.
+ * @property {(tool: Solid) => Solid} cut
+ * @property {(tools: Solid[]) => Solid} cutAll      batch subtract (backend-optimized)
+ * @property {(other: Solid) => Solid} intersect     boolean intersection (Manifold)
+ * @property {(v: number[]) => Solid} translate
+ * @property {(deg: number, center: number[], axis: number[]) => Solid} rotate
+ * @property {(plane: "XY"|"XZ"|"YZ") => Solid} mirror
+ * @property {() => number} volume                   solid volume in mm³ (Manifold; used by collision tests)
+ * @property {(opts?: {quality?: "preview"|"print"}) => {positions:Float32Array, normals:Float32Array, indices:Uint32Array, triangles:number}} toMesh
+ * @property {(opts?: {quality?: "preview"|"print"}) => Promise<ArrayBuffer>} toSTL
+ * @property {() => {positions:Float32Array, indices:Uint32Array}} toIndexedMesh   indexed mesh, for 3MF (Manifold)
+ *
+ * @typedef {Object} GeometryKernel
+ * @property {(rBottom:number, rTop:number, h:number, opts?:{center?:boolean}) => Solid} cylinder
+ * @property {(min:number[], max:number[]) => Solid} box
+ * @property {(points2D:number[][], h:number) => Solid} prism   extrude polygon from z=0
+ * @property {(o:{pathR:number,profileR:number,pitch:number,turns:number,z0:number,lefthand:boolean}) => Solid} helixSweptTube
+ * @property {(solids:Solid[]) => Solid} union
+ * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only
+ * @property {() => void} [cleanup]   free per-job WASM objects (Manifold backend); call after each job
+ */

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

@@ -0,0 +1,194 @@
+import { helixTube } from "./helix-tube.js";
+
+const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
+// 'preview' = interactive view (fast); 'print' = STL export (high-res, used only
+// by the export path — Manifold meshing is cheap, so we tessellate generously).
+const SEGS = { preview: 116, print: 480 };       // circular segments
+const TUBE = { preview: { stationsPerTurn: 38, ringSegs: 24 }, print: { stationsPerTurn: 160, ringSegs: 40 } };
+const SHARP_ANGLE = 35; // deg — same-surface edges sharper than this shade hard (cut seams are always hard)
+const COPLANAR_COS = Math.cos((5 * Math.PI) / 180); // edge lines: skip cut seams that bend less than 5° (coplanar)
+const MIN_EDGE2 = 0.01 * 0.01; // edge lines: drop sub-0.01mm segments (degenerate boolean slivers, not real features)
+
+export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
+  const { Manifold, CrossSection } = wasm;
+  const segs = SEGS[quality], tube = TUBE[quality];
+
+  // Manifold/CrossSection are WASM objects with no garbage collection — every
+  // primitive and boolean op allocates a new one. Track them all and free them
+  // per job via cleanup(); otherwise repeated generates exhaust the WASM heap
+  // (manifests as "Out of bounds memory access").
+  const tracked = [];
+  const T = (obj) => { tracked.push(obj); return obj; };
+  const unionRaw = (ms) => ms.reduce((a, b) => T(a.add(b))); // track each reduce step
+
+  // Copy the mesh out into JS-owned arrays (so it survives cleanup) and free the
+  // transient mesh handle.
+  function meshOut(m, asStl) {
+    const g = m.getMesh();
+    const r = asStl ? stlFromMesh(g) : creasedNormals(g, Math.cos((SHARP_ANGLE * Math.PI) / 180));
+    g.delete?.();
+    return r;
+  }
+
+  // Raw indexed mesh (positions x,y,z per vertex + triangle indices) for 3MF.
+  function indexedMeshOut(m) {
+    const g = m.getMesh();
+    const np = g.numProp, vp = g.vertProperties;
+    const nVert = (vp.length / np) | 0;
+    let positions;
+    if (np === 3) {
+      positions = Float32Array.from(vp);
+    } else {
+      positions = new Float32Array(nVert * 3);
+      for (let i = 0; i < nVert; i++) { positions[i * 3] = vp[i * np]; positions[i * 3 + 1] = vp[i * np + 1]; positions[i * 3 + 2] = vp[i * np + 2]; }
+    }
+    const indices = Uint32Array.from(g.triVerts);
+    g.delete?.();
+    return { positions, indices };
+  }
+
+  const wrap = (m) => ({
+    _m: m,
+    cut: (t) => wrap(T(m.subtract(t._m))),
+    cutAll: (tools) => wrap(T(m.subtract(unionRaw(tools.map((t) => t._m))))),
+    intersect: (t) => wrap(T(m.intersect(t._m))),
+    volume: () => m.volume(),
+    translate: (v) => wrap(T(m.translate(v))),
+    rotate: (deg, center, axis) => {
+      const euler = [axis[0] * deg, axis[1] * deg, axis[2] * deg];
+      const a = T(m.translate([-center[0], -center[1], -center[2]]));
+      const b = T(a.rotate(euler));
+      return wrap(T(b.translate(center)));
+    },
+    mirror: (plane) => wrap(T(m.mirror(PLANE_NORMAL[plane]))),
+    toMesh: () => meshOut(m, false),
+    toSTL: () => Promise.resolve(meshOut(m, true)),
+    toIndexedMesh: () => indexedMeshOut(m),
+  });
+
+  return {
+    cylinder: (rb, rt, h, { center = false } = {}) => wrap(T(Manifold.cylinder(h, rb, rt, segs, center))),
+    box: (min, max) => {
+      const cube = T(Manifold.cube([max[0] - min[0], max[1] - min[1], max[2] - min[2]]));
+      return wrap(T(cube.translate(min)));
+    },
+    prism: (pts, h) => {
+      const cs = T(CrossSection.ofPolygons([pts]));
+      return wrap(T(cs.extrude(h)));
+    },
+    helixSweptTube: (o) => wrap(T(helixTube(wasm, { ...o, ...tube }))),
+    union: (solids) => wrap(unionRaw(solids.map((s) => s._m))), // unionRaw already tracks its result
+    toSTEP: () => { throw new Error("STEP export not supported by the Manifold backend"); },
+    // Free every WASM object created since the last cleanup. Call after each job
+    // once its meshes/buffers have been copied out (meshOut already did).
+    cleanup: () => { for (const o of tracked) o.delete?.(); tracked.length = 0; },
+  };
+}
+
+// Build a non-indexed mesh with normals that are smooth within a single original
+// surface but HARD across boolean-cut seams. Manifold's runOriginalID tells us
+// which input solid each triangle came from; we average a corner's face normals
+// only over incident triangles of the SAME original surface that also meet within
+// `sharpCos` — so cut seams stay crisp at any angle (even near-tangent), and a
+// surface's own sharp edges (e.g. a face meeting a side) stay crisp too.
+function creasedNormals(g, sharpCos) {
+  const np = g.numProp, vp = g.vertProperties, tris = g.triVerts;
+  const nTri = (tris.length / 3) | 0, nVert = (vp.length / np) | 0;
+
+  // unify any coincident vertices Manifold kept separate, for adjacency
+  const remap = new Uint32Array(nVert);
+  for (let i = 0; i < nVert; i++) remap[i] = i;
+  const mf = g.mergeFromVert, mt = g.mergeToVert;
+  if (mf && mt) for (let i = 0; i < mf.length; i++) remap[mf[i]] = mt[i];
+
+  // per-triangle original-surface id, from the run table
+  const triOID = new Uint32Array(nTri);
+  const ri = g.runIndex, roid = g.runOriginalID;
+  for (let r = 0; r < roid.length; r++)
+    for (let t = ri[r] / 3; t < ri[r + 1] / 3; t++) triOID[t] = roid[r];
+
+  // per-triangle face normals
+  const fn = new Float32Array(nTri * 3);
+  for (let t = 0; t < nTri; t++) {
+    const a = tris[t * 3] * np, b = tris[t * 3 + 1] * np, c = tris[t * 3 + 2] * np;
+    const ux = vp[b] - vp[a], uy = vp[b + 1] - vp[a + 1], uz = vp[b + 2] - vp[a + 2];
+    const vx = vp[c] - vp[a], vy = vp[c + 1] - vp[a + 1], vz = vp[c + 2] - vp[a + 2];
+    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const L = Math.hypot(nx, ny, nz) || 1;
+    fn[t * 3] = nx / L; fn[t * 3 + 1] = ny / L; fn[t * 3 + 2] = nz / L;
+  }
+
+  // canonical vertex → incident triangles
+  const incident = new Map();
+  for (let t = 0; t < nTri; t++)
+    for (let k = 0; k < 3; k++) {
+      const cv = remap[tris[t * 3 + k]];
+      const arr = incident.get(cv);
+      if (arr) arr.push(t); else incident.set(cv, [t]);
+    }
+
+  const positions = new Float32Array(nTri * 9);
+  const normals = new Float32Array(nTri * 9);
+  for (let t = 0; t < nTri; t++) {
+    const fx = fn[t * 3], fy = fn[t * 3 + 1], fz = fn[t * 3 + 2], oid = triOID[t];
+    for (let k = 0; k < 3; k++) {
+      const v = tris[t * 3 + k];
+      let nx = 0, ny = 0, nz = 0;
+      for (const t2 of incident.get(remap[v])) {
+        if (triOID[t2] !== oid) continue; // different cut surface → hard
+        if (fn[t2 * 3] * fx + fn[t2 * 3 + 1] * fy + fn[t2 * 3 + 2] * fz < sharpCos) continue; // sharp same-surface edge → hard
+        nx += fn[t2 * 3]; ny += fn[t2 * 3 + 1]; nz += fn[t2 * 3 + 2];
+      }
+      const L = Math.hypot(nx, ny, nz) || 1;
+      const o = (t * 3 + k) * 3, vv = v * np;
+      positions[o] = vp[vv]; positions[o + 1] = vp[vv + 1]; positions[o + 2] = vp[vv + 2];
+      normals[o] = nx / L; normals[o + 1] = ny / L; normals[o + 2] = nz / L;
+    }
+  }
+
+  // Feature edge segments for CAD-style edge lines: draw a line where the surface
+  // actually BENDS — a sharp same-surface edge (dihedral past sharpCos), or a cut
+  // seam (different original surface) that bends more than COPLANAR_COS. Coplanar
+  // faces — even across a cut seam — get no line, and curved-surface facets are skipped.
+  const edges = [];
+  const seenEdge = new Map(); // edge key → first incident triangle
+  for (let t = 0; t < nTri; t++)
+    for (let e = 0; e < 3; e++) {
+      const i = remap[tris[t * 3 + e]], j = remap[tris[t * 3 + ((e + 1) % 3)]];
+      if (i === j) continue;
+      const key = i < j ? i * nVert + j : j * nVert + i;
+      const prev = seenEdge.get(key);
+      if (prev === undefined) { seenEdge.set(key, t); continue; }
+      seenEdge.delete(key);
+      const dot = fn[prev * 3] * fn[t * 3] + fn[prev * 3 + 1] * fn[t * 3 + 1] + fn[prev * 3 + 2] * fn[t * 3 + 2];
+      const hard = dot < sharpCos || (triOID[prev] !== triOID[t] && dot < COPLANAR_COS);
+      if (hard) {
+        const ai = i * np, bj = j * np;
+        const dx = vp[ai] - vp[bj], dy = vp[ai + 1] - vp[bj + 1], dz = vp[ai + 2] - vp[bj + 2];
+        if (dx * dx + dy * dy + dz * dz >= MIN_EDGE2) // skip degenerate sliver segments (noise)
+          edges.push(vp[ai], vp[ai + 1], vp[ai + 2], vp[bj], vp[bj + 1], vp[bj + 2]);
+      }
+    }
+
+  return { positions, normals, triangles: nTri, edges: Float32Array.from(edges) }; // mesh non-indexed
+}
+
+function stlFromMesh(g) {
+  const tris = g.triVerts, vp = g.vertProperties, np = g.numProp, n = tris.length / 3;
+  const ab = new ArrayBuffer(84 + n * 50); const dv = new DataView(ab); dv.setUint32(80, n, true);
+  let o = 84; const P = (i) => [vp[i*np], vp[i*np+1], vp[i*np+2]];
+  for (let i = 0; i < n; i++) {
+    const a = P(tris[i*3]), b = P(tris[i*3+1]), c = P(tris[i*3+2]);
+    // Per-facet flat normal from the winding (Manifold is CCW → outward). Slicers
+    // recompute this, but viewers that light from the stored normal (macOS
+    // Preview/Quick Look) render the mesh unlit if it's left as zero.
+    const ux = b[0]-a[0], uy = b[1]-a[1], uz = b[2]-a[2];
+    const vx = c[0]-a[0], vy = c[1]-a[1], vz = c[2]-a[2];
+    const nx = uy*vz - uz*vy, ny = uz*vx - ux*vz, nz = ux*vy - uy*vx;
+    const L = Math.hypot(nx, ny, nz) || 1;
+    dv.setFloat32(o, nx/L, true); dv.setFloat32(o+4, ny/L, true); dv.setFloat32(o+8, nz/L, true); o += 12;
+    for (const p of [a, b, c]) for (const x of p) { dv.setFloat32(o, x, true); o += 4; }
+    dv.setUint16(o, 0, true); o += 2;
+  }
+  return ab;
+}

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

@@ -0,0 +1,59 @@
+// OCCT backend via replicad. Same GeometryKernel shape as the Manifold backend,
+// and the only backend with toSTEP(). This is where today's drum.js kernel calls
+// (makeCylinder, makeHelix+genericSweep, draw/extrude, cut/fuse) now live.
+const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.5 }, print: { tolerance: 0.01, angularTolerance: 0.1 } };
+
+export function createOcctKernel(replicad) {
+  const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
+          makeCompound, loft, draw, exportSTEP } = replicad;
+
+  const wrap = (shape) => ({
+    _s: shape,
+    cut: (t) => wrap(shape.cut(t._s)),
+    cutAll: (tools) => wrap(shape.cut(makeCompound(tools.map((t) => t._s)))),
+    translate: (v) => wrap(shape.translate(v)),
+    rotate: (deg, center, axis) => wrap(shape.rotate(deg, center, axis)),
+    mirror: (plane) => wrap(shape.mirror(plane)),
+    toMesh: ({ quality = "preview" } = {}) => {
+      const m = shape.mesh(MESH[quality]);
+      return {
+        positions: Float32Array.from(m.vertices),
+        normals: new Float32Array(0), // let the main thread crease (matches prior look)
+        indices: Uint32Array.from(m.triangles),
+        triangles: m.triangles.length / 3,
+      };
+    },
+    toSTL: ({ quality = "print" } = {}) => shape.blobSTL(MESH[quality]).arrayBuffer(),
+  });
+
+  // cylinder OR frustum (loft of two circles) when rb !== rt
+  const cylinder = (rb, rt, h, { center = false } = {}) => {
+    const z0 = center ? -h / 2 : 0;
+    if (Math.abs(rb - rt) < 1e-9) return wrap(makeCylinder(rb, h, [0, 0, z0]));
+    const w1 = assembleWire([makeCircle(rb, [0, 0, z0])]);
+    const w2 = assembleWire([makeCircle(rt, [0, 0, z0 + h])]);
+    return wrap(loft([w1, w2]));
+  };
+
+  // extrude a 2-D polygon from z=0
+  const prism = (pts, h) => {
+    let pen = draw(pts[0]);
+    for (let i = 1; i < pts.length; i++) pen = pen.lineTo(pts[i]);
+    return wrap(pen.close().sketchOnPlane("XY").extrude(h));
+  };
+
+  // circle profile swept along a helix (frenet)
+  const helixSweptTube = ({ pathR, profileR, pitch, turns, z0, lefthand }) => {
+    const spine = makeHelix(pitch, pitch * turns, pathR, [0, 0, z0], [0, 0, 1], lefthand);
+    const dir = lefthand ? -1 : 1;
+    const tangent = [0, dir * pathR, pitch / (2 * Math.PI)];
+    const profile = assembleWire([makeCircle(profileR, [pathR, 0, z0], tangent)]);
+    return wrap(genericSweep(profile, spine, { frenet: true }));
+  };
+
+  return {
+    cylinder, box: (min, max) => wrap(makeBox(min, max)), prism, helixSweptTube,
+    union: (solids) => wrap(solids.map((s) => s._s).reduce((a, b) => a.fuse(b))),
+    toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._s }))).arrayBuffer(),
+  };
+}

package/src/framework/geometry/polygon.js

@@ -0,0 +1,23 @@
+// 2-D polygon helpers shared by parts that call kernel.prism().
+
+// CCW polygon points for a circular-sector "pie" from the origin, radius tipR.
+export function piePolygon(tipR, arcDeg, segs = 32) {
+  const a = (arcDeg * Math.PI) / 180;
+  const pts = [[0, 0]];
+  const steps = Math.max(2, Math.ceil((segs * arcDeg) / 360));
+  for (let i = 0; i <= steps; i++) {
+    const t = (a * i) / steps;
+    pts.push([tipR * Math.cos(t), tipR * Math.sin(t)]);
+  }
+  return pts;
+}
+
+// Vertex-up regular hexagon, circumradius r (flats facing ±X).
+export function hexPolygon(r) {
+  const pts = [];
+  for (let i = 0; i < 6; i++) {
+    const a = Math.PI / 2 + (i * Math.PI) / 3;
+    pts.push([r * Math.cos(a), r * Math.sin(a)]);
+  }
+  return pts;
+}

package/src/framework/geometry/threemf.js

@@ -0,0 +1,52 @@
+// Minimal 3MF writer. 3MF is an OPC package (a zip) holding an XML model; it's a
+// mesh format like STL but supports units and multiple named objects in one file,
+// so a multi-part view exports as a single .3mf. Built from indexed meshes.
+import { zipSync, strToU8 } from "fflate";
+
+const CONTENT_TYPES =
+  '<?xml version="1.0" encoding="UTF-8"?>\n' +
+  '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">' +
+  '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>' +
+  '<Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/>' +
+  "</Types>";
+
+const RELS =
+  '<?xml version="1.0" encoding="UTF-8"?>\n' +
+  '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+  '<Relationship Target="/3D/3dmodel.model" Id="rel0" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/>' +
+  "</Relationships>";
+
+const xmlEsc = (s) => String(s).replace(/[<>&"]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;" }[c]));
+const r = (x) => +x.toFixed(4); // 0.1 µm precision — finer than any printer, much smaller XML
+
+// parts: [{ name, positions: Float32Array (x,y,z per vertex), indices: Uint32Array (3 per triangle) }]
+// → ArrayBuffer of the .3mf zip (millimetre units; one <object> + <build> item per part).
+export function meshTo3MF(parts) {
+  const out = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">',
+    "<resources>",
+  ];
+  parts.forEach((p, i) => {
+    out.push(`<object id="${i + 1}" type="model" name="${xmlEsc(p.name)}"><mesh><vertices>`);
+    const v = p.positions;
+    for (let k = 0; k < v.length; k += 3) out.push(`<vertex x="${r(v[k])}" y="${r(v[k + 1])}" z="${r(v[k + 2])}"/>`);
+    out.push("</vertices><triangles>");
+    const t = p.indices;
+    for (let k = 0; k < t.length; k += 3) out.push(`<triangle v1="${t[k]}" v2="${t[k + 1]}" v3="${t[k + 2]}"/>`);
+    out.push("</triangles></mesh></object>");
+  });
+  out.push("</resources><build>");
+  parts.forEach((p, i) => out.push(`<item objectid="${i + 1}"/>`));
+  out.push("</build></model>");
+
+  const zip = zipSync(
+    {
+      "[Content_Types].xml": strToU8(CONTENT_TYPES),
+      "_rels/.rels": strToU8(RELS),
+      "3D/3dmodel.model": strToU8(out.join("")),
+    },
+    { level: 6 } // 3MF XML is highly repetitive — compresses ~10×
+  );
+  return zip.buffer;
+}

package/src/framework/geometry-service.js

@@ -0,0 +1,20 @@
+// Main-thread side of the two geometry workers. Spawns both (manifold/occt),
+// funnels their messages to one handler, and routes outbound jobs to the right one.
+//
+// `createWorker(name)` must be supplied by the app and build the worker with the
+// `new Worker(new URL("./part-worker.js", import.meta.url), { type:"module", name })`
+// pattern INLINE — Vite only bundles a worker (and its backend chunks) when it sees
+// that literal call, so the framework can't construct it from a passed-in URL.
+export function createGeometryService({ createWorker, onMessage, occtPreview = false }) {
+  const preview = createWorker("manifold"); // preview meshes + STL
+  const exporter = createWorker("occt");    // STEP (and preview when occtPreview)
+  preview.onmessage = onMessage;
+  exporter.onmessage = onMessage;
+  const genWorker = occtPreview ? exporter : preview;
+  return {
+    generate: (msg) => genWorker.postMessage(msg),
+    exportStl: (msg) => preview.postMessage(msg),
+    export3mf: (msg) => preview.postMessage(msg), // mesh export → Manifold worker
+    exportStep: (msg) => exporter.postMessage(msg),
+  };
+}

package/src/framework/index.js

@@ -0,0 +1 @@
+export { mount } from "./mount.js";