partforge 0.66.0 → 0.66.1

package/docs/AUTHORING-PARTS.md

@@ -2241,15 +2241,19 @@ 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 warning: roundAll is morphological (three Minkowski passes) and its
-runtime grows steeply with the solid's triangle count.** On a simple bracket it
-is interactive; on a complex outline it is not — measured 30+ seconds on a
-text-outline extrusion whose `fillet({ r, edges: { inPlane: "XY", at: h } })`
-takes well under a second. **Never use roundAll just to round the top or bottom
-rim of an extrusion** — that is exactly what the `inPlane` fillet selector is
-for, at a tiny fraction of the cost. Reach for roundAll only when the design
-genuinely needs every edge softened at once and the solid is geometrically
-simple.
+**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:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.66.0",
+  "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/manifold-backend.js

@@ -15,7 +15,7 @@ import { meshToStl } from "./mesh-stl.js";
 import { creasedNormals } from "./creased-normals.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] };
@@ -168,6 +168,66 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     }
   };
 
+  // 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,
@@ -190,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)

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?.();
+  }
+}