partforge 0.65.1 → 0.66.1

package/docs/AUTHORING-PARTS.md

@@ -2241,6 +2241,20 @@ melt away, holes narrower than `2r` seal shut. That makes it ideal for
 "soften this whole organic part" and wrong for parts where a specific edge
 must stay sharp (use `fillet` with a selector for that).
 
+**Cost note.** On a Z-aligned extrusion (constant cross-section — a plate, a
+text backing, any straight-sided prism) roundAll takes a fast path: the ball
+morphology is computed as a 2-D close-open of the cross-section plus rim
+fillets, so even a complex text-outline backing rounds in well under a second.
+Everything else pays the full morphology (three Minkowski passes), whose
+runtime grows steeply with triangle count — a rotated or lofted solid of a few
+thousand triangles can take tens of seconds. When only a specific edge needs
+rounding, `fillet` with a selector (e.g. `{ inPlane: "XY", at: h }` for a rim)
+says what you mean and is always the cheap, predictable choice; reach for
+roundAll when the design genuinely calls for every edge softened at once. At
+the fast path's corners the plan silhouette follows the rim fillet's corner
+rounding (radius ≈ 1.05–1.25·r rather than exactly r) — the same corner
+treatment fillet itself applies.
+
 Rules of thumb:
 
 - Keep `r` under half your thinnest wall unless you *want* melting.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.65.1",
+  "version": "0.66.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/creased-normals.js

@@ -72,7 +72,12 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
       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
+        // different cut surface → hard, EXCEPT two blend surfaces (boundaryLines on
+        // both): one band is many tool surfaces continuing each other tangentially,
+        // and hard normals at their handovers would put lighting seams along a band
+        // that used to shade as one re-originaled surface
+        if (triOID[t2] !== oid &&
+          !(polFor(triOID[t2]).boundaryLines && polFor(oid).boundaryLines)) continue;
         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];
       }
@@ -105,16 +110,32 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
       // are invisible but whose long boundary edges would otherwise draw at full
       // line weight. A triangle thinner than MIN_EDGE cannot be seen, so its
       // edges are noise by definition — same threshold the segment filter uses.
-      if (thin[prev] < MIN_EDGE || thin[t] < MIN_EDGE) continue;
+      const sameOID = triOID[prev] === triOID[t];
+      // Blend boundary: a cross-surface seam with a BLEND policy on EXACTLY one side
+      // is the start/end of a fillet band — draw it even when tangent (the band's
+      // extent must be readable). It also bypasses the thin-triangle gate below:
+      // simplify() cannot collapse the boolean's slivers ACROSS the blend/base run
+      // boundary, so half the seam's edges border a sliver, and gating them dashed
+      // the ring — those slivers ride within microns OF the seam curve, so their
+      // long edges redraw it rather than add noise (the MIN_EDGE segment-length
+      // filter still drops the short ones).
+      const boundary = !sameOID &&
+        !!polFor(triOID[prev]).boundaryLines !== !!polFor(triOID[t]).boundaryLines;
+      if (!boundary && (thin[prev] < MIN_EDGE || thin[t] < MIN_EDGE)) continue;
       const dot = fn[prev * 3] * fn[t * 3] + fn[prev * 3 + 1] * fn[t * 3 + 1] + fn[prev * 3 + 2] * fn[t * 3 + 2];
       // A multi-hole cap triangulation can contain an opposite-wound bridge:
       // its two normals disagree by 180 degrees even though both triangles lie
       // in the same plane. Gate on the unoriented supporting-plane angle first
       // so that triangulation seam never becomes a feature line.
       const bends = Math.abs(dot) < COPLANAR_COS;
-      const hard = bends && (triOID[prev] === triOID[t]
+      // Two blend surfaces (a handover along one band) line-draw like ONE surface:
+      // the 35° same-surface bar, not the 5° cut-seam bar — a band is many tool
+      // surfaces whose overshoot crossings bend a few degrees by construction.
+      const bothBlend = !sameOID &&
+        !!polFor(triOID[prev]).boundaryLines && !!polFor(triOID[t]).boundaryLines;
+      const hard = boundary || (bends && (sameOID || bothBlend
         ? polFor(triOID[t]).sameSurfaceLines && dot < cosFor(triOID[t])
-        : true);
+        : true));
       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];

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

@@ -13,9 +13,9 @@ import { offsetRegions } from "./contour-offset.js";
 import { finishKernel } from "./kernel-front.js";
 import { meshToStl } from "./mesh-stl.js";
 import { creasedNormals } from "./creased-normals.js";
-import { loftShadingPolicy, SMOOTH } from "./shading-policy.js";
+import { loftShadingPolicy, SMOOTH, BLEND } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
-import { meshRoundAll } from "./mesh-roundall.js";
+import { meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
 import { KernelCapabilityError } from "./errors.js";
 
 const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
@@ -123,12 +123,6 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // degenerate normals poison the crease pass into drawing phantom edge lines).
   // Unsupported edge classes (helical edges, varying dihedral, …) surface as
   // KernelCapabilityError so the framework reroutes that sub-part to OCCT.
-  // simplify() will not collapse triangles across run (originalID) boundaries,
-  // and the boolean's sliver triangles sit exactly on them — so the result is
-  // re-originaled first. That folds every surface into one fresh original,
-  // which is also the documented B-rep semantic: fillet/chamfer produce new
-  // surfaces, so feature-label attribution downstream of the op uses the
-  // fallback path (AUTHORING-PARTS.md), and the blend shades SMOOTH.
   const SIMPLIFY_EPS = 1e-4; // 0.1 µm — must exceed the boolean's sliver widths (~2e-5)
   // Debris sweep: where blend tools graze each other or a flank near-tangentially, the
   // boolean can strand a CLOSED femto-component (measured ~1e-8 mm³, 4 triangles) that
@@ -144,15 +138,96 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     for (const p of parts) { T(p); if (p.volume() >= DEBRIS_VOL) kept.push(p); }
     return kept.length === parts.length ? m : T(Manifold.compose(kept));
   };
-  const meshCadOp = (op, run) => {
+  // Blend surfaces KEEP their originalIDs, and every id the op introduced is
+  // registered with the BLEND policy — that is what lets creased-normals draw the
+  // band's start/end (a tangent blend↔base seam draws regardless of bend) while
+  // blend↔blend handovers along one band stay invisible. This replaced a blanket
+  // asOriginal(): folding the result into one fresh original made simplify able to
+  // collapse boundary slivers, but it also erased the one distinction the boundary
+  // lines need. The trade is stated honestly: simplify() cannot collapse across the
+  // surviving run boundaries, so seam-adjacent slivers persist as triangles — they
+  // are sub-MIN_EDGE thin, so the line pass gates them, and closed sliver DEBRIS is
+  // swept above; the visible cost is a modestly larger mesh, bounded by
+  // mesh-fillet-perf.test.js. Shading is unchanged (BLEND shades like SMOOTH), and
+  // label() on a blend result already handles a mixed-original mesh (the majority
+  // vote below).
+  const runOids = (mm) => { const g = mm.getMesh(); const s = new Set(g.runOriginalID); g.delete?.(); return s; };
+  const meshCadOp = (op, baseM, run) => {
     try {
-      return T(dropDebris(T(run()._m.asOriginal())).simplify(SIMPLIFY_EPS));
+      const raw = run()._m;
+      const baseOids = runOids(baseM);
+      for (const oid of runOids(raw)) if (!baseOids.has(oid)) oidPolicies.set(oid, BLEND);
+      // debris sweep AFTER simplify: the boolean's own femto-components are joined by
+      // ones simplify() itself pinches off while collapsing seam slivers (measured:
+      // 4-triangle atto-scale bubbles, one with negative volume, after a rim fillet
+      // over vertical-fillet bands) — sweeping first missed those
+      return dropDebris(T(raw.simplify(SIMPLIFY_EPS)));
     } catch (e) {
       if (e instanceof UnsupportedEdgeError) throw new KernelCapabilityError(`${op}: ${e.message}`);
       throw e;
     }
   };
 
+  // roundAll prism fast path. Ball close-then-open via native Minkowski is
+  // seconds-per-thousand-triangles (a text-outline backing measured 30+ s), but on
+  // a Z-prism the SAME morphology decomposes: the 2-D close-open of the
+  // cross-section (Clipper2 offsets +r, -2r, +r) supplies the wall melting and
+  // hole sealing, and a selector-free fillet of the re-extruded section at r
+  // supplies every rounded surface — vertical edges, both rims, and the corner
+  // treatments. Returns a raw (tracked) manifold, or null to
+  // keep the reference morphology — the fast path may only ever SUBSTITUTE for
+  // it: any doubt (not a prism, plate too thin, everything melted, a fillet
+  // refusal) falls back rather than widening or narrowing what roundAll accepts,
+  // and roundAll must never surface NEEDS_OCCT (it is its own reference
+  // implementation), which is why the whole attempt is fenced by a bare catch.
+  const prismRoundAllFast = (m, mHash, r) => {
+    let sect = null;
+    try {
+      sect = prismSection(wasm, m);
+      if (!sect) return null;
+      const { cs, z0, h: height } = sect;
+      // the erosion consumes the whole plate below 2r, and just above it the two
+      // rim bands graze each other — both belong to the reference morphology
+      if (!(height > 2 * r * 1.05)) return null;
+      // MITER joins on all three offsets, deliberately: the true morphology mints
+      // outline corners of radius exactly r, and a rim fillet of radius r over an
+      // r-radius corner pinches its top tangent contour to a point — the planar
+      // sweep refuses, structurally. Miter keeps every corner SHARP instead, and
+      // the selector-free fillet below performs ALL the rounding: convex vertical
+      // edges (cutters at r — the same solid the round join would have produced),
+      // concave verticals (fillers), both rims, and the corner treatments. Melt
+      // and seal thresholds stay exact on straight stretches; corner-local
+      // thresholds and silhouettes differ from the ball morphology by the rim
+      // fillet's own corner tolerance (~0.25·r) — the documented corner trade.
+      let cur = null;
+      try {
+        for (const delta of [r, -2 * r, r]) {
+          const next = (cur ?? cs).offset(delta, "Miter", 2);
+          const cleaned = next.simplify(1e-6);
+          next.delete?.();
+          cur?.delete?.();
+          cur = cleaned;
+        }
+        if (!(cur.area() > 0)) return null; // everything melted — reference path owns the empty result
+        let base = T(Manifold.extrude(cur, height));
+        if (z0 !== 0) base = T(base.translate([0, 0, z0]));
+        const wrapped = wrap(base, h("roundAllPrismBase", mHash, r, quality));
+        // selector-free: every sharp edge of the mitered prism gets its radius here
+        const filleted = wrapped.fillet(r);
+        // decouple from the fillet cache's pin: cached() will pin the object this
+        // returns under the roundAll hash, and one WASM object must never sit
+        // under two cache entries (double-dispose on eviction)
+        return T(filleted._m.asOriginal());
+      } finally {
+        cur?.delete?.();
+      }
+    } catch {
+      return null;
+    } finally {
+      sect?.cs?.delete?.();
+    }
+  };
+
   const wrap = (m, hash) => addSugar({
     _m: m,
     _hash: hash,
@@ -161,13 +236,13 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       if (typeof selector === "function") throw new KernelCapabilityError("fillet: function selectors need the OCCT backend");
       if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
       return cached(h("fillet", hash, r, selector ?? null, segs), () =>
-        meshCadOp("fillet", () => meshFillet(kernel, wrap(m, hash), { r, edges: selector, segs })));
+        meshCadOp("fillet", m, () => meshFillet(kernel, wrap(m, hash), { r, edges: selector, segs })));
     },
     chamfer: (d, selector) => {
       if (typeof selector === "function") throw new KernelCapabilityError("chamfer: function selectors need the OCCT backend");
       if (d === 0) return wrap(m, hash);
       return cached(h("chamfer", hash, d, selector ?? null, segs), () =>
-        meshCadOp("chamfer", () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs })));
+        meshCadOp("chamfer", m, () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs })));
     },
     roundAll: (r) => {
       if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
@@ -175,7 +250,8 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       // 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)));
+      return cached(h("roundAll", hash, r, quality), () =>
+        prismRoundAllFast(m, hash, r) ?? T(meshRoundAll(wasm, m, r, quality)));
     },
     // batch difference: first minus the union of the rest, evaluated as one boolean
     // tree — no materialized intermediate union (the unionRaw memory note applies)
@@ -192,6 +268,49 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     label: (name) => {
       const lh = h("label", hash, name);
       return cache.lookup(lh, () => {
+        // Blend-aware re-stamp. If this mesh carries blend surfaces (the boundaryLines
+        // policy), one asOriginal() would fold band and base into a single surface and
+        // erase the band-boundary overlay on exactly the solids parts label — every
+        // real part labels its top-level solids. Re-stamp as TWO reserved ids instead,
+        // base and blend: the label covers both (same string → one feature entry), the
+        // distinction survives labeling and every later boolean, and reserved ids are
+        // fresh so cached-solid reuse under another label cannot collide — the same
+        // guarantee asOriginal() gives the plain path below.
+        const g0 = m.getMesh();
+        const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
+        const oids0 = new Set(g0.runOriginalID);
+        if ([...oids0].some(isBlend)) {
+          const baseId = Manifold.reserveIDs(2), blendId = baseId + 1;
+          // base-group policy: the same triangle-weighted majority vote as the plain
+          // path, but over the NON-blend runs only — blend runs would elect BLEND for
+          // the base group and flag BOTH sides of every boundary seam, which is
+          // exactly the no-line state this path exists to avoid.
+          const ri = g0.runIndex, roid = g0.runOriginalID;
+          const weightByKey = new Map();
+          let bestWeight = -1, basePol;
+          for (let r = 0; r < roid.length; r++) {
+            if (isBlend(roid[r])) continue;
+            const pol = oidPolicies.get(roid[r]) ?? SMOOTH;
+            const key = `${pol.creaseAngle}/${pol.sameSurfaceLines}/${!!pol.boundaryLines}`;
+            const weight = (weightByKey.get(key) || 0) + (ri[r + 1] / 3 - ri[r] / 3);
+            weightByKey.set(key, weight);
+            const better = weight > bestWeight || (weight === bestWeight && !pol.sameSurfaceLines && basePol?.sameSurfaceLines);
+            if (better) { bestWeight = weight; basePol = pol; }
+          }
+          g0.runOriginalID = Uint32Array.from(roid, (o2) => (isBlend(o2) ? blendId : baseId));
+          const o = T(new Manifold(g0));
+          g0.delete?.();
+          featureLabels.set(baseId, name);
+          featureLabels.set(blendId, name);
+          oidPolicies.set(blendId, BLEND);
+          if (basePol !== undefined) oidPolicies.set(baseId, basePol);
+          return { value: wrap(o, lh), pin: o, dispose: () => {
+            featureLabels.delete(baseId); featureLabels.delete(blendId);
+            oidPolicies.delete(baseId); oidPolicies.delete(blendId);
+            o.delete?.();
+          } };
+        }
+        g0.delete?.();
         const prevId = typeof m.originalID === "function" ? m.originalID() : -1;
         const o = T(m.asOriginal());
         const id = o.originalID();
@@ -231,7 +350,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
           let bestWeight = -1, bestPol;
           for (let r = 0; r < roid.length; r++) {
             const pol = oidPolicies.get(roid[r]) ?? SMOOTH;
-            const key = `${pol.creaseAngle}/${pol.sameSurfaceLines}`;
+            const key = `${pol.creaseAngle}/${pol.sameSurfaceLines}/${!!pol.boundaryLines}`;
             const weight = (weightByKey.get(key) || 0) + (ri[r + 1] / 3 - ri[r] / 3);
             weightByKey.set(key, weight);
             const better = weight > bestWeight || (weight === bestWeight && !pol.sameSurfaceLines && bestPol?.sameSurfaceLines);

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

@@ -81,3 +81,46 @@ export function meshRoundAll(wasm, m, r, quality) {
     sph2R.delete?.();
   }
 }
+
+// ---------------------------------------------------------------------------
+// Prism detection for the fast path (manifold-backend.js). The Minkowski chain
+// above is seconds-per-thousand-triangles, but roundAll's expensive real-world
+// inputs are almost always Z-prisms (text backings, plates, extruded outlines) —
+// and on a prism the ball morphology decomposes exactly into the 2-D disk
+// morphology of the cross-section plus rim fillets, all of which are fast. This
+// function answers "is m a Z-prism, and what is its constant cross-section?"
+//
+// Detection is deliberately behavioral, not structural: three slices must have
+// equal area AND vanishing symmetric difference (a sheared prism has equal-area
+// TRANSLATED sections — the subtract catches it), and the solid's volume must
+// equal section × height (a bulge parked between the slice planes would pass the
+// slice checks alone). Any failure returns null and the caller keeps the
+// reference morphology — the fast path may only ever substitute, never widen.
+//
+// On success the returned CrossSection is the CALLER's to delete.
+export function prismSection(wasm, m, relTol = 1e-4) {
+  const bb = m.boundingBox();
+  const z0 = bb.min[2], h = bb.max[2] - z0;
+  if (!(h > 0)) return null;
+  const volume = m.volume();
+  if (!(volume > 0)) return null;
+  const slices = [0.25, 0.5, 0.75].map((t) => m.slice(z0 + t * h));
+  try {
+    const area = slices[1].area();
+    if (!(area > 0)) return null;
+    for (const s of slices) if (Math.abs(s.area() - area) > relTol * area) return null;
+    for (const s of [slices[0], slices[2]]) {
+      const d1 = slices[1].subtract(s), d2 = s.subtract(slices[1]);
+      const diff = d1.area() + d2.area();
+      d1.delete?.();
+      d2.delete?.();
+      if (diff > relTol * area) return null;
+    }
+    if (Math.abs(volume - area * h) > 10 * relTol * area * h) return null;
+    const cs = slices[1];
+    slices[1] = null; // ownership moves to the caller
+    return { cs, z0, h };
+  } finally {
+    for (const s of slices) s?.delete?.();
+  }
+}

package/src/framework/geometry/shading-policy.js

@@ -8,6 +8,14 @@
 
 export const SMOOTH = Object.freeze({ creaseAngle: 35, sameSurfaceLines: true });
 export const FACETED = Object.freeze({ creaseAngle: 10, sameSurfaceLines: false });
+// A blend surface (fillet/chamfer band). `boundaryLines` widens the CROSS-surface
+// rule for it: a seam between a blend and a NON-blend surface draws regardless of
+// bend — the band's start/end are tangent (~0°) and would otherwise be invisible,
+// leaving the fillet's extent unreadable in the overlay. A seam between TWO blend
+// surfaces keeps the ordinary bend rule (exactly-one-side semantics), so the
+// handover seams along one band — tool splits, corner arcs continuing a sweep —
+// stay invisible while real mitre crossings still draw.
+export const BLEND = Object.freeze({ creaseAngle: 35, sameSurfaceLines: true, boundaryLines: true });
 
 export const COPLANAR_ANGLE = 5;  // deg — cut seams bending less than this are coplanar: no line
 export const TANGENT_ANGLE = 5;   // deg — B-rep edges whose faces agree within this are tangent: no line