partforge 0.62.1 → 0.64.0

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

@@ -4,6 +4,8 @@ import { sweepMesh } from "./sweep.js";
 import { roundedBoxRings } from "./rounded-solids.js";
 import { tessellateContour, tessellateProfile } from "./profile.js";
 import { h } from "./solid-hash.js";
+import { ensureOutward, openEdgeCount } from "./mesh-repair.js";
+import { manifoldFromMesh } from "./mesh-build.js";
 import { createSolidCache } from "./solid-cache.js";
 import { addSugar } from "./solid-sugar.js";
 import { makeShape2dFactory } from "./shape2d.js";
@@ -13,6 +15,7 @@ import { meshToStl } from "./mesh-stl.js";
 import { creasedNormals } from "./creased-normals.js";
 import { loftShadingPolicy, SMOOTH } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
+import { meshRoundAll } from "./mesh-roundall.js";
 import { KernelCapabilityError } from "./errors.js";
 
 const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
@@ -48,6 +51,10 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   const cache = createSolidCache();
   const featureLabels = new Map(); // originalID -> label string (grows per label(); tiny)
   const oidPolicies = new Map();   // originalID -> shading policy (grows per faceted/hinted loft; tiny)
+  // name -> { m, digest, hash } | { error, digest } — imported geometry the framework
+  // registers pre-build (ensureImports, Task 8). Kernel-lifetime, NOT tracked/T()'d:
+  // these masters must survive cleanup() and be read again on every subsequent build.
+  const imports = new Map();
   // Boundary ops route through cache.lookup; on a miss `make` runs the WASM op,
   // tracks the result, and returns the triple the cache needs to pin/dispose it.
   const cached = (hash, computeM) => cache.lookup(hash, () => {
@@ -143,6 +150,14 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       return cached(h("chamfer", hash, d, selector ?? null, segs), () =>
         meshCadOp("chamfer", () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs })));
     },
+    roundAll: (r) => {
+      if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
+      // `quality` in the key is redundant but harmless — the cache lives on a
+      // per-quality kernel, so it can never collide across tiers (the OCCT twin
+      // key omits it for the same reason); it just spells out that the ball
+      // tessellation, and so the result, is tier-dependent.
+      return cached(h("roundAll", hash, r, quality), () => T(meshRoundAll(wasm, m, r, quality)));
+    },
     cutAll: (tools) => cached(h("cutAll", hash, tools.map((t) => t._hash)),
       () => T(m.subtract(unionRaw(tools.map((t) => t._m))))),
     intersect: (t) => cached(h("intersect", hash, t._hash), () => T(m.intersect(t._m))),
@@ -321,6 +336,41 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     union: (solids) => solids.length === 1
       ? solids[0]
       : cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
+    // Imported geometry, registered pre-build by the framework via `_registerImport`
+    // (ensureImports, Task 8). The master Manifold is kernel-lifetime (untracked —
+    // see `imports` above); wrap() is free, so every call is cheap.
+    import: (name) => {
+      const e = imports.get(name);
+      if (!e) throw new Error(`import: unknown import "${name}" — declare it in the part's \`imports\` field`);
+      if (e.error) throw e.error; // lazy: unusable-format entries fail at use, not at registration
+      return wrap(e.m, e.hash);
+    },
+    // Side-channel (underscore = off-contract, probe-invisible). Registration is
+    // TOTAL — it never throws for an unusable format; an `{error}` entry is stored
+    // verbatim and thrown by `import(name)` above at call time (spec: "Registration
+    // is total; errors are lazy"). Re-registering the same name+digest is a no-op
+    // EXCEPT an error entry is always upgradable (the post-crossover retry depends
+    // on this — see `_importDigest`).
+    _registerImport: ({ name, digest, positions, indices, error }) => {
+      const prev = imports.get(name);
+      if (!prev?.error && prev?.digest === digest) return; // error entries are always upgradable
+      if (error) { imports.set(name, { error, digest }); return; }
+      ensureOutward(positions, indices);
+      let m;
+      try {
+        m = manifoldFromMesh(wasm, positions, indices);
+        if (m.isEmpty()) throw new Error("empty result");
+      } catch (err) {
+        const open = openEdgeCount(positions, indices);
+        throw new Error(`import "${name}": mesh is not a solid after repair (${open} open edges) — repair it in a mesh tool or re-export watertight (${err?.message || err})`);
+      }
+      prev?.m?.delete?.(); // prev may be an error entry with no manifold
+      imports.set(name, { m, digest, hash: h("import", name, digest) });
+    },
+    // Registration memo: undefined for an error entry, so a later registration with
+    // the same digest can upgrade it rather than being treated as a no-op repeat.
+    _importDigest: (name) => { const e = imports.get(name); return e?.error ? undefined : e?.digest; },
+    _acceptsMesh: true,
     shape2d,
     // Backend-internal region adapter: the shared native engine (contour-offset.js)
     // that Shape2D.offset itself runs on — published here for callers that want the

package/src/framework/geometry/mesh-repair.js

@@ -0,0 +1,87 @@
+// Repair + diagnostics for imported meshes (STL/3MF soup, or already-indexed). Files in the
+// wild are inconsistently wound and sometimes non-manifold, so the import path runs these
+// before handing a mesh to Manifold.ofMesh: orient it outward, then measure how far it is
+// from watertight so the caller can decide whether to warn or refuse the import.
+
+import { reverseWinding } from "./mesh-build.js";
+
+// Read triangle `t`'s three vertex indices, working for both an indexed mesh (`indices` is
+// the triangle-index array) and an unindexed soup (`indices` is null/undefined, so the
+// triangle's own position offsets double as its "indices": 3t, 3t+1, 3t+2).
+function triIndices(indices, t) {
+  if (indices) return [indices[t * 3], indices[t * 3 + 1], indices[t * 3 + 2]];
+  return [t * 3, t * 3 + 1, t * 3 + 2];
+}
+
+function triCount(positions, indices) {
+  return indices ? indices.length / 3 : positions.length / 9;
+}
+
+function vertex(positions, i) {
+  return [positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]];
+}
+
+// Signed volume (mm^3) of a closed mesh: Sigma det(a,b,c)/6 over triangles, the standard
+// divergence-theorem formula. Positive when triangles wind CCW-outward, negative when the
+// whole mesh is inside-out. Works on soup (indices omitted) and indexed meshes alike, and
+// doesn't require the mesh to actually be closed - an open mesh just gives a meaningless
+// number, which is exactly the signal ensureOutward needs (sign, not validity).
+export function signedVolume(positions, indices) {
+  const n = triCount(positions, indices);
+  let vol = 0;
+  for (let t = 0; t < n; t++) {
+    const [i0, i1, i2] = triIndices(indices, t);
+    const [ax, ay, az] = vertex(positions, i0);
+    const [bx, by, bz] = vertex(positions, i1);
+    const [cx, cy, cz] = vertex(positions, i2);
+    vol += ax * (by * cz - bz * cy) - ay * (bx * cz - bz * cx) + az * (bx * cy - by * cx);
+  }
+  return vol / 6;
+}
+
+// Flip the whole mesh outward-facing if it's currently inside-out (negative signed volume),
+// by reversing every triangle's winding in place. A no-op when already outward (or when the
+// sign is ambiguous because the mesh isn't closed - nothing sensible to do there anyway).
+export function ensureOutward(positions, indices) {
+  if (signedVolume(positions, indices) < 0) reverseWinding(indices);
+}
+
+// Count boundary ("open") half-edges after welding vertices by exact position. A watertight
+// mesh has every directed edge matched by an opposite-direction edge on the neighboring
+// triangle; an edge whose reverse is missing borders a hole (or a non-manifold seam) and is
+// the diagnostic for "this import isn't a solid". The weld key is built from the raw
+// (Float32-precision) coordinate values - exact match is correct here because soup vertices
+// straight out of one STL/3MF file that are meant to coincide already have identical float32
+// bit patterns; no epsilon merge needed.
+export function openEdgeCount(positions, indices) {
+  const n = triCount(positions, indices);
+
+  // Weld: coordinate key -> canonical vertex id.
+  const weld = new Map();
+  function weldedId(i) {
+    const [x, y, z] = vertex(positions, i);
+    const key = `${x},${y},${z}`;
+    let id = weld.get(key);
+    if (id === undefined) { id = weld.size; weld.set(key, id); }
+    return id;
+  }
+
+  // Tally every directed edge (a -> b) across all triangles.
+  const edges = new Map();
+  for (let t = 0; t < n; t++) {
+    const [i0, i1, i2] = triIndices(indices, t);
+    const a = weldedId(i0), b = weldedId(i1), c = weldedId(i2);
+    for (const [u, v] of [[a, b], [b, c], [c, a]]) {
+      const key = `${u},${v}`;
+      edges.set(key, (edges.get(key) || 0) + 1);
+    }
+  }
+
+  // An edge is open when its reverse direction never appears.
+  let open = 0;
+  for (const key of edges.keys()) {
+    const [u, v] = key.split(",");
+    if (!edges.has(`${v},${u}`)) open++;
+  }
+  return open;
+}

package/src/framework/geometry/mesh-roundall.js

@@ -0,0 +1,83 @@
+// Morphological whole-solid rounding on the mesh backend: close-then-open with
+// a ball — dilate(+r), erode(2r), dilate(+r) via Manifold's native Minkowski
+// sum/difference. Rounds EVERY edge (convex and concave) at radius ≈ r and
+// consumes features smaller than the ball (walls < 2r melt, holes < 2r seal) —
+// that is the op's contract, not a defect (docs/roundall-design.md).
+//
+// simplify() between steps is mandatory, not an optimization: the naive
+// Minkowski (hull-of-triangle-pairs) emits sliver-degenerate meshes whose
+// complexity compounds through the chain — the design spike measured 106s and
+// 761k broken-topology triangles without it vs 2.4s and 340 clean triangles
+// with it, on the same torture case. asOriginal() first, because simplify()
+// will not collapse triangles across run (originalID) boundaries and the
+// Minkowski output is stitched from many.
+//
+// This op must NEVER throw KernelCapabilityError / NEEDS_OCCT: the mesh
+// backend is roundAll's reference implementation — rerouting to OCCT would
+// trade a correct result for a skip (occt-roundall.js can only skip where
+// morphology exceeds what B-rep offsets support).
+//
+// INVARIANT — both balls share ONE segment count. Minkowski support functions
+// add, so the chain displaces a face with normal n by 2·h_r(n) − h_2r(n), where
+// h is the ball's support. Manifold spheres built with equal `segs` are similar
+// (the 2r ball is the r ball scaled by two), so h_2r = 2·h_r and the term is
+// exactly zero in EVERY direction — the input's planar faces return to their
+// original planes. Give the two balls different segment counts and the term is
+// only zero where a vertex happens to line up: axis-aligned boxes still look
+// right while off-axis faces drift (measured 0.07mm at preview, r=2). The count
+// is sized from the erosion ball (2r), the larger of the two, so the coarser of
+// the two facetings still meets the tier's sagitta tolerance.
+
+// Sphere tessellation from the facet sagitta r·(1 − cos(π/segs)): pick the
+// fewest segments that keep it under the quality tier's tolerance.
+const SAGITTA_TOL = { preview: 0.05, print: 0.01 }; // mm
+export function roundAllSegs(r, quality) {
+  const tol = SAGITTA_TOL[quality] ?? SAGITTA_TOL.preview;
+  if (!(r > tol)) return 12;
+  return Math.min(64, Math.max(12, Math.ceil(Math.PI / Math.acos(1 - tol / r))));
+}
+
+export function meshRoundAll(wasm, m, r, quality) {
+  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
+  const segs = roundAllSegs(2 * r, quality); // ONE count for BOTH balls — see the invariant above
+  // Simplify tolerance: max(r/100, 0.01) mm, but never enough to collapse the
+  // rim ring of a rounded edge into the next ring up. That ring sits
+  // r·(1 − cos(2π/segs)) above the face plane, and it is what holds a planar
+  // face at its exact position; collapsing it shaves the face inward (print
+  // tier, r = 2: segs 45 puts the ring 0.0195 mm up, and a flat 0.02 tolerance
+  // pulled every face of a box in by 0.034 mm). Half that spacing keeps margin.
+  const tol = Math.min(Math.max(r / 100, 0.01), 0.5 * r * (1 - Math.cos((2 * Math.PI) / segs)));
+  const step = (input, sphere, op) => {
+    const raw = op === "sum" ? input.minkowskiSum(sphere) : input.minkowskiDifference(sphere);
+    let orig;
+    try {
+      orig = raw.asOriginal();
+    } finally {
+      raw.delete?.();
+    }
+    try {
+      return orig.simplify(tol);
+    } finally {
+      orig.delete?.();
+    }
+  };
+  const sphR = wasm.Manifold.sphere(r, segs);
+  const sph2R = wasm.Manifold.sphere(2 * r, segs);
+  try {
+    const a = step(m, sphR, "sum");          // dilate: rounds convex, seals holes < 2r
+    let b;
+    try {
+      b = step(a, sph2R, "diff");        // erode 2r: melts walls < 2r
+    } finally {
+      a.delete?.();
+    }
+    try {
+      return step(b, sphR, "sum");          // dilate back: final radius ≈ r everywhere
+    } finally {
+      b.delete?.();
+    }
+  } finally {
+    sphR.delete?.();
+    sph2R.delete?.();
+  }
+}

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

@@ -21,6 +21,7 @@ import { addSugar } from "./solid-sugar.js";
 import { makeShape2dFactory } from "./shape2d.js";
 import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
+import { occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
 import { resolveRings } from "./loft.js";
 import { resolveSweepStations } from "./sweep.js";
@@ -36,12 +37,17 @@ const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.25 }, print: { tol
 
 export function createOcctKernel(replicad) {
   const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
-          loft, draw, exportSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
+          loft, draw, exportSTEP, importSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
 
   // Fillet/chamfer/shell failure recovery (skip-on-failure, chamfer binary search) —
   // see occt-repair.js for the policies and why they differ per op.
   const { validChamfer, safeOp } = createOcctRepair(measureVolume);
 
+  // name -> { shape, digest } | { error, digest } — imported geometry the framework
+  // registers pre-build via `_registerImport` (kernel-lifetime, untracked by the
+  // solid cache: imports are the framework's own memo, keyed by name+digest).
+  const imports = new Map();
+
   const cache = createSolidCache();
   // Boundary ops route through cache.lookup. pin is unused here (no cleanup() —
   // GC frees WASM via replicad's FinalizationRegistry) and dispose is a no-op:
@@ -223,6 +229,14 @@ export function createOcctKernel(replicad) {
           return wrap(validChamfer(a._s, toEdgeFinder(selector), distance), cloneLabels(a._labels), key);
         });
       },
+      roundAll: (r) => {
+        const key = h("roundAll", hash, r);
+        return cached(key, () => {
+          const a = mat();
+          if (r === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          return wrap(occtRoundAll(replicad, a._s, r), cloneLabels(a._labels), key);
+        });
+      },
       shell: (thickness, openFaces) => {
         if (openFaces == null) throw new Error("shell: openFaces is required (a fully closed hollow is not supported)");
         const key = h("shell", hash, thickness, selKey(openFaces));
@@ -478,6 +492,33 @@ export function createOcctKernel(replicad) {
     // surface.
     _offsetRegions: offsetRegions,
     toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._mat()._s }))).arrayBuffer(),
+    // Imported geometry, registered pre-build by the framework via `_registerImport`
+    // (ensureImports, Task 8). Every call clones the master shape — replicad ops
+    // consume their operands, and the master must never be handed out directly, or
+    // a second `import(name)` call would see the first caller's transform.
+    import: (name) => {
+      const e = imports.get(name);
+      if (!e) throw new Error(`import: unknown import "${name}" — declare it in the part's \`imports\` field`);
+      if (e.error) throw e.error; // lazy: unusable-format entries fail at use, not at registration
+      return wrap(e.shape.clone(), [], h("import", name, e.digest));
+    },
+    // Side-channel (underscore = off-contract, probe-invisible). Registration is
+    // TOTAL — it never throws for an unusable format (e.g. an STL/3MF import on
+    // this backend); an `{error}` entry is stored verbatim and thrown by
+    // `import(name)` above at call time (spec: "Registration is total; errors are
+    // lazy"). Re-registering the same name+digest is a no-op EXCEPT an error entry
+    // is always upgradable (the post-crossover retry depends on this — see
+    // `_importDigest`).
+    _registerImport: async ({ name, digest, step, error }) => {
+      const prev = imports.get(name);
+      if (!prev?.error && prev?.digest === digest) return; // error entries are always upgradable
+      if (error) { imports.set(name, { error, digest }); return; }
+      imports.set(name, { shape: await importSTEP(new Blob([step])), digest });
+    },
+    // Registration memo: undefined for an error entry, so a later registration with
+    // the same digest can upgrade it rather than being treated as a no-op repeat.
+    _importDigest: (name) => { const e = imports.get(name); return e?.error ? undefined : e?.digest; },
+    _acceptsStep: true,
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     sweepCache: () => cache.sweep(),

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

@@ -0,0 +1,94 @@
+// B-rep side of roundAll: dilate(+r), erode(-2r), dilate(+r) via raw OCCT
+// BRepOffsetAPI_MakeOffsetShape (replicad has no solid-offset wrapper). Each
+// step runs a variant cascade — the design spike showed no single parameter
+// combo survives all shapes: plain solids dilate with Arc/Intersection=false,
+// the chained erosion only succeeds with Arc/Intersection=true, and concave
+// post-boolean solids only dilate with the Intersection join (morphologically
+// fine: the FINAL Arc dilation supplies the convex rounding).
+//
+// A candidate is accepted only if IsDone, non-null, closed (mesh check),
+// finite positive volume, AND volume-monotonic (dilation must not shrink,
+// erosion must not grow). The monotonic gate is load-bearing: OCCT offsets
+// return BRepCheck-valid garbage — the spike saw an erosion "succeed" at 0.4%
+// of the input volume, and a sealed hole come back as an 11% crater. A gated
+// failure skips the WHOLE op (warn + clone), mirroring safeOp's fillet policy
+// and for the same reason: OCCT offset failures are not monotonic in r, so
+// searching for a "largest working radius" would converge on garbage.
+// Feature-consuming radii (r at/above the smallest feature) are the expected
+// skip trigger — true consumption is mesh-class-only (docs/roundall-design.md).
+//
+// Every WASM object made here is freed, same convention as occt-repair.js, so
+// OCCT's heap doesn't grow across regenerates: up to twelve offset builders and
+// progress ranges, every rejected candidate, and each superseded intermediate.
+// The one thing never freed is the caller's `shape` — it belongs to the caller,
+// and the skip path hands back a clone of it.
+import { isClosedSolid } from "./occt-repair.js";
+
+const VARIANTS = [
+  { join: "arc", inter: false },
+  { join: "arc", inter: true },
+  { join: "int", inter: false },
+  { join: "int", inter: true },
+];
+
+export function occtRoundAll(replicad, shape, r) {
+  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
+  const oc = replicad.getOC();
+  const tryOffset = (topo, offset, v) => {
+    const progress = new oc.Message_ProgressRange_1();
+    const mk = new oc.BRepOffsetAPI_MakeOffsetShape();
+    try {
+      mk.PerformByJoin(topo, offset, 1e-6,
+        oc.BRepOffset_Mode.BRepOffset_Skin, v.inter, false,
+        v.join === "arc" ? oc.GeomAbs_JoinType.GeomAbs_Arc : oc.GeomAbs_JoinType.GeomAbs_Intersection,
+        false, progress);
+      if (!mk.IsDone()) return null;
+      const s = mk.Shape();
+      // Wrap BEFORE the finally frees the builder — replicad's own idiom for this
+      // very algorithm (its `offset()` does `cast(offsetBuilder.Shape()); offsetBuilder.delete()`).
+      // The wrapper carries its own TopoDS_Shape handle, so the result outlives `mk`.
+      return s.IsNull() ? null : new replicad.Solid(s);
+    } catch {
+      return null;
+    } finally {
+      mk.delete?.();
+      progress.delete?.();
+    }
+  };
+  let vol;
+  try {
+    vol = replicad.measureVolume(shape);
+  } catch (e) {
+    // Can't gate what can't be measured — skip rather than run the cascade blind.
+    console.warn(`partforge: roundall-skipped: the input solid's volume could not be measured (${e?.message || e}); returning the un-rounded solid`);
+    return shape.clone(); // if the clone throws too, the caller's shape is unusable — let it propagate
+  }
+  let cur = shape;
+  for (const off of [r, -2 * r, r]) {
+    let next = null;
+    for (const v of VARIANTS) {
+      const cand = tryOffset(cur.wrapped, off, v);
+      if (!cand) continue;
+      let cvol;
+      try { cvol = replicad.measureVolume(cand); } catch { cand.delete?.(); continue; }
+      if (!Number.isFinite(cvol) || cvol <= 0) { cand.delete?.(); continue; }
+      if (off > 0 && cvol < vol * 0.999) { cand.delete?.(); continue; } // dilation shrank: garbage
+      if (off < 0 && cvol > vol * 1.001) { cand.delete?.(); continue; } // erosion grew: garbage
+      // isClosedSolid meshes the candidate, and meshing OCCT offset garbage can
+      // throw — that is just another rejected candidate, not an escape hatch out
+      // of "roundAll never throws for geometry".
+      try { if (!isClosedSolid(cand)) { cand.delete?.(); continue; } }
+      catch { cand.delete?.(); continue; }
+      next = cand;
+      vol = cvol;
+      break;
+    }
+    if (cur !== shape) cur.delete?.(); // superseded intermediate; never the caller's shape
+    if (!next) {
+      console.warn(`partforge: roundall-skipped: offset step ${off} produced no valid solid — r=${r} is likely at/above the smallest feature size; returning the un-rounded solid`);
+      return shape.clone();
+    }
+    cur = next;
+  }
+  return cur;
+}

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

@@ -289,6 +289,8 @@ export const SOLID_OP_SPECS = {
     return [req("chamfer", o, "d"), ...(o.edges !== undefined ? [o.edges] : [])]; } },
   shell:   { toArgs: (o) => { checkKeys("shell", o, ["t", "open"]);
     return [req("shell", o, "t"), req("shell", o, "open")]; } },
+  roundAll: { toArgs: (o) => { checkKeys("roundAll", o, ["r"]);
+    return [req("roundAll", o, "r")]; } },
 };
 
 // A zero-magnitude fillet/chamfer is the identity on every conformance class

package/src/framework/geometry/stl-parse.js

@@ -0,0 +1,45 @@
+// Pure-JS STL reader (ascii + binary), the read twin of mesh-stl.js's writer.
+// Returns triangle soup: positions x,y,z per vertex, indices 0..3n-1. Vertex
+// welding is deliberately NOT done here — Manifold's Mesh.merge() welds at
+// import (mesh-build.js), and the soup keeps this parser trivial and exact.
+const u8of = (b) => (b instanceof ArrayBuffer ? new Uint8Array(b) : b);
+
+function isAscii(u8) {
+  // "solid" prefix is not enough (binary files sometimes start with it);
+  // require an ascii "facet" token in the first 1 KB too.
+  const head = String.fromCharCode(...u8.slice(0, 1024));
+  return head.trimStart().startsWith("solid") && head.includes("facet");
+}
+
+export function parseStl(bytes) {
+  const u8 = u8of(bytes);
+  return isAscii(u8) ? parseAscii(u8) : parseBinary(u8);
+}
+
+function parseAscii(u8) {
+  const text = new TextDecoder().decode(u8);
+  const V = [];
+  const re = /vertex\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)/g;
+  for (let m; (m = re.exec(text)); ) V.push(Number(m[1]), Number(m[2]), Number(m[3]));
+  if (V.length === 0 || V.length % 9 !== 0)
+    throw new Error(`ascii STL parse failed: ${V.length / 3} vertices (not a multiple of 3)`);
+  return soup(Float32Array.from(V));
+}
+
+function parseBinary(u8) {
+  if (u8.length < 84) throw new Error("binary STL truncated: shorter than the 84-byte header");
+  const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+  const n = dv.getUint32(80, true);
+  if (u8.length < 84 + n * 50) throw new Error(`binary STL truncated: header says ${n} triangles, file has ${Math.floor((u8.length - 84) / 50)}`);
+  const positions = new Float32Array(n * 9);
+  for (let i = 0; i < n; i++) {
+    const o = 84 + i * 50 + 12; // skip the facet normal
+    for (let j = 0; j < 9; j++) positions[i * 9 + j] = dv.getFloat32(o + j * 4, true);
+  }
+  return soup(positions);
+}
+
+const soup = (positions) => ({
+  positions,
+  indices: Uint32Array.from({ length: positions.length / 3 }, (_, i) => i),
+});

package/src/framework/geometry/threemf-parse.js

@@ -0,0 +1,87 @@
+// Minimal 3MF reader, the read twin of threemf.js's writer. 3MF is an OPC
+// package (a zip) holding an XML model; unzip (fflate), find the model part,
+// extract vertices/triangles/per-item transforms and the model unit, and
+// merge every build item into one soup-free indexed mesh in millimetres.
+//
+// Regex-based extraction, NOT a DOM parse — workers have no DOMParser and the
+// worker graph must stay DOM-free (test/worker-layering.test.js enforces
+// this transitively). Scope: geometry only — materials, colors and beam
+// lattices are ignored, and only top-level <object><mesh> content is read
+// (no <components> nesting).
+import { unzipSync } from "fflate";
+
+const UNIT_MM = { micron: 0.001, millimeter: 1, centimeter: 10, inch: 25.4, foot: 304.8, meter: 1000 };
+
+export function parse3MF(bytes) {
+  const u8 = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
+  let files;
+  try {
+    files = unzipSync(u8);
+  } catch (e) {
+    throw new Error(`3mf import: not a readable zip archive (${e?.message || e})`);
+  }
+  const modelPath = Object.keys(files).find((f) => f.toLowerCase().endsWith(".model"));
+  if (!modelPath) throw new Error("3mf import: archive has no 3D model part (*.model)");
+  const xml = new TextDecoder().decode(files[modelPath]);
+
+  const unit = xml.match(/<model\b[^>]*\bunit="([^"]+)"/)?.[1] ?? "millimeter";
+  const scale = UNIT_MM[unit];
+  if (!scale) throw new Error(`3mf import: unknown unit "${unit}"`);
+
+  // objects: id -> { P: number[] (already scaled to mm), I: number[] }
+  const objects = new Map();
+  const objRe = /<object\b[^>]*\bid="(\d+)"[^>]*>([\s\S]*?)<\/object>/g;
+  for (let m; (m = objRe.exec(xml)); ) {
+    const [, id, body] = m;
+    const P = [], I = [];
+    const vRe = /<vertex\b[^>]*\bx="([^"]+)"[^>]*\by="([^"]+)"[^>]*\bz="([^"]+)"/g;
+    for (let v; (v = vRe.exec(body)); ) P.push(+v[1] * scale, +v[2] * scale, +v[3] * scale);
+    const tRe = /<triangle\b[^>]*\bv1="(\d+)"[^>]*\bv2="(\d+)"[^>]*\bv3="(\d+)"/g;
+    for (let t; (t = tRe.exec(body)); ) I.push(+t[1], +t[2], +t[3]);
+    if (I.length) objects.set(id, { P, I });
+  }
+  if (objects.size === 0) throw new Error("3mf import: model contains no mesh geometry");
+
+  // Build items: <item objectid="N" transform="m00 m01 m02 m10 m11 m12 m20 m21
+  // m22 m30 m31 m32"/> — row-major 4x3, translation in the last row, per the
+  // 3MF core spec (the transform is applied to a row vector: v' = v*M, i.e.
+  // x' = x*m00 + y*m10 + z*m20 + m30, and so on). No <build>, or an object
+  // with no matching item, falls back to identity placement.
+  //
+  // Attributes are pulled independently from each <item> tag (rather than in
+  // one fixed-order regex) because `objectid` and `transform` can appear in
+  // either order and a single ordered pattern with an optional middle group
+  // can match the tag while silently leaving `transform` uncaptured.
+  const items = [];
+  const itemTagRe = /<item\b[^>]*\/>/g;
+  for (let m; (m = itemTagRe.exec(xml)); ) {
+    const tag = m[0];
+    const id = tag.match(/\bobjectid="(\d+)"/)?.[1];
+    if (!id) continue;
+    const t = tag.match(/\btransform="([^"]+)"/)?.[1];
+    items.push({ id, t: t ? t.trim().split(/\s+/).map(Number) : null });
+  }
+  const chosen = items.length ? items : [...objects.keys()].map((id) => ({ id, t: null }));
+
+  const V = [], Tr = [];
+  for (const { id, t } of chosen) {
+    const o = objects.get(id);
+    if (!o) continue;
+    const base = V.length / 3;
+    for (let i = 0; i < o.P.length; i += 3) {
+      let x = o.P[i], y = o.P[i + 1], z = o.P[i + 2];
+      if (t) {
+        // Translation components (m30 m31 m32) are expressed in model units
+        // per the 3MF spec, same as vertex coordinates — scale them to mm too
+        // so they combine correctly with the already-scaled x/y/z above.
+        const x2 = t[0] * x + t[3] * y + t[6] * z + t[9] * scale;
+        const y2 = t[1] * x + t[4] * y + t[7] * z + t[10] * scale;
+        const z2 = t[2] * x + t[5] * y + t[8] * z + t[11] * scale;
+        x = x2; y = y2; z = z2;
+      }
+      V.push(x, y, z);
+    }
+    for (const idx of o.I) Tr.push(base + idx);
+  }
+  return { positions: Float32Array.from(V), indices: Uint32Array.from(Tr) };
+}

package/src/framework/geometry-service.js

@@ -31,8 +31,10 @@ export function createGeometryService({ createWorker, onMessage }) {
   // 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).
+  // `transfer` carries transferable buffers (e.g. priming a mesh's positions/indices
+  // into `prime-imports` without a structured-clone copy).
   return {
-    send: (msg, backend = "manifold") => workers[backend].postMessage(msg),
+    send: (msg, backend = "manifold", transfer = []) => workers[backend].postMessage(msg, transfer),
     terminate: () => terminateWorkers([workers.manifold, workers.occt]),
   };
 }