partforge 0.36.0 → 0.36.1

package/docs/KERNEL-CONTRACT.md

@@ -222,7 +222,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `genus()` / `isEmpty()` | Optional (`SOLID_OPTIONAL_OPS`): mesh-topology queries — through-hole count / no-geometry test. The mesh backend provides them; OCCT has no cheap equivalent. |
 | `toMesh({quality?})` | Render mesh: `{positions, normals, indices?, triangles, edges?, featureIds?, features?}`. `indices` optional (a backend may emit soup or indexed); `normals` may be empty (`length 0`) to delegate creasing to the viewer; `edges` (feature-line segments) and the feature fields are optional metadata. |
 | `toSTL({quality?})` | `Promise<ArrayBuffer>`, binary STL, outward CCW winding. Stored facet normals may be zero — slicers recompute them (the mesh backend happens to write them). |
-| `toIndexedMesh()` | `{positions, indices}` indexed mesh (3MF path). |
+| `toIndexedMesh({quality?})` | `{positions, indices}` indexed mesh (3MF path); defaults to `"print"` like `toSTL`. Coincident vertices need NOT be welded — the 3MF writer welds, because that format reads topology from the indices rather than re-stitching soup by position the way an STL consumer does. |
 | `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | B-rep class (core throws `KernelCapabilityError`). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` hollows inward, keeping outer dimensions; `open` (face selector) is required. |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.36.0",
+  "version": "0.36.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

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

@@ -34,7 +34,7 @@ const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.5 }, print: { tole
 
 export function createOcctKernel(replicad) {
   const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
-          makeCompound, loft, draw, exportSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
+          loft, draw, exportSTEP, 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.
@@ -127,8 +127,12 @@ export function createOcctKernel(replicad) {
         const key = h("cutAll", hash, tools.map((t) => t._hash));
         return cached(key, () => {
           const a = mat(), bs = tools.map((t) => t._mat());
+          if (bs.length === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          const fusedTools = bs
+            .slice(1)
+            .reduce((acc, b) => acc.fuse(b._s.clone()), bs[0]._s.clone());
           return wrap(
-            a._s.clone().cut(makeCompound(bs.map((b) => b._s.clone()))),
+            a._s.clone().cut(fusedTools),
             [...cloneLabels(a._labels), ...bs.flatMap((b) => cloneLabels(b._labels))],
             key,
           );
@@ -210,8 +214,10 @@ export function createOcctKernel(replicad) {
         });
       },
       volume: () => measureVolume(mat()._s),
-      toIndexedMesh: () => {
-        const base = baseMesh("preview");
+      // Same default as toSTL: an export is an export, so a .3mf must not ship a
+      // coarser tessellation than the .stl of the same solid would.
+      toIndexedMesh: ({ quality = "print" } = {}) => {
+        const base = baseMesh(quality);
         return { positions: posedPositions(base), indices: Uint32Array.from(base.indices) };
       },
     });

package/src/framework/geometry/threemf.js

@@ -19,6 +19,54 @@ const RELS =
 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
 
+// Weld coincident vertices and drop triangles that collapse to zero area.
+//
+// This is what keeps a .3mf manifold, and it has no STL equivalent: STL is vertex
+// soup, so a consumer re-stitches triangles by POSITION and never sees how the
+// mesh was indexed. 3MF reads topology from the indices instead, so two triangles
+// that meet along an edge must literally cite the same two vertex ids — otherwise
+// each counts the shared edge as its own boundary and slicers report the solid as
+// non-manifold. The OCCT backend triangulates every B-rep face independently and
+// concatenates the results, so it hands us one copy of each seam vertex PER
+// adjacent face; welding here is what closes that mesh. (Manifold's own output is
+// already welded, so for that backend this is a no-op beyond the copy.)
+//
+// Welding uses `r` — exactly the precision the file is written at — so any two
+// vertices that would print identical coordinates always collapse to one id. A
+// looser tolerance would move geometry; a tighter one would leave split vertices
+// sitting at coordinates the file cannot tell apart.
+function weld(positions, indices) {
+  const idOf = new Map(); // "x,y,z" → canonical vertex id
+  const coord = []; // canonical id → rounded x,y,z (flat)
+  const canon = new Uint32Array(positions.length / 3);
+  for (let i = 0, v = 0; i < positions.length; i += 3, v++) {
+    const x = r(positions[i]), y = r(positions[i + 1]), z = r(positions[i + 2]);
+    const key = `${x},${y},${z}`;
+    let id = idOf.get(key);
+    if (id === undefined) { id = coord.length / 3; idOf.set(key, id); coord.push(x, y, z); }
+    canon[v] = id;
+  }
+  // Emit vertices in order of first use by a surviving triangle, so a vertex left
+  // behind by a dropped degenerate never ships as an unreferenced <vertex>.
+  const emitted = new Map(); // canonical id → written vertex index
+  const verts = [], tris = [];
+  const emit = (id) => {
+    let at = emitted.get(id);
+    if (at === undefined) {
+      at = verts.length / 3;
+      emitted.set(id, at);
+      verts.push(coord[id * 3], coord[id * 3 + 1], coord[id * 3 + 2]);
+    }
+    return at;
+  };
+  for (let k = 0; k < indices.length; k += 3) {
+    const a = canon[indices[k]], b = canon[indices[k + 1]], c = canon[indices[k + 2]];
+    if (a === b || b === c || a === c) continue; // zero area at print precision — carries no surface
+    tris.push(emit(a), emit(b), emit(c));
+  }
+  return { verts, tris };
+}
+
 // 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) {
@@ -29,10 +77,9 @@ export function meshTo3MF(parts) {
   ];
   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])}"/>`);
+    const { verts: v, tris: t } = weld(p.positions, p.indices);
+    for (let k = 0; k < v.length; k += 3) out.push(`<vertex x="${v[k]}" y="${v[k + 1]}" z="${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>");
   });

package/src/framework/jobs.js

@@ -136,7 +136,7 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       if (names.length === 0) throw new Error("no exportable parts selected");
       const meshes = names.map((name) => {
         onProgress(`building ${label(name)}`);
-        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh();
+        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh({ quality: msg.quality ?? "print" });
         return { name: exportName(name), positions, indices };
       });
       onProgress("writing 3MF file");