partforge 0.66.0 → 0.67.0

package/docs/AUTHORING-PARTS.md

@@ -2195,8 +2195,10 @@ STEP export always builds on OCCT, so a filleted part gets exact B-rep blends in
 STEP even though it previews (and STL/3MF-exports) from the mesh blend — the two agree
 to within tessellation on the supported edge classes, with one visible exception:
 orthogonal box-style corners where three filleted edges meet get a true sphere-octant
-cap, but other blend junctions are mitred on the mesh where OCCT builds a vertex
-blend.
+cap, and a planar rim's own corners blend by turn direction (salient corners steer
+the band around a small arc; reflex/inside corners round into an arc of the blend
+radius about the vertex — the rolling-ball pivot), but other blend junctions are
+mitred on the mesh where OCCT builds a vertex blend.
 
 If the mesh backend hits an edge class it can't blend, it signals `NEEDS_OCCT` and the
 framework reroutes **just that sub-part** to OCCT for those exact parameters —
@@ -2241,15 +2243,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/docs/KERNEL-CONTRACT.md

@@ -60,10 +60,15 @@ Its coverage and tolerance band are part of the contract:
   guards, all ≤ ~1e-3 mm). Volumes agree with the B-rep result to ~0.1% on covered
   edge classes. **Corners:** where exactly three selected straight convex chains meet
   at a mutually orthogonal vertex (a box corner), the fillet caps it with the
-  rolling-ball sphere octant; every other junction of blended chains is a **mitre**
-  (the blend surfaces intersect), where the B-rep class builds a kernel-specific
-  vertex blend instead — parity at such corners is approximate, like `roundedBox`'s
-  documented corner carve-out.
+  rolling-ball sphere octant. A two-chain corner in a common face plane (a rim
+  corner) blends by turn direction: SALIENT corners steer the band around a small
+  arc (the silhouette rounds by about the blend radius inside the band), and REFLEX
+  corners get the rolling-ball pivot — the face's blend boundary rounds into an arc
+  of the blend radius about the vertex, exactly what a ball rolling into an inside
+  corner leaves. Every other junction of blended chains is a **mitre** (the blend
+  surfaces intersect), where the B-rep class builds a kernel-specific vertex blend
+  instead — parity at such corners is approximate, like `roundedBox`'s documented
+  corner carve-out.
 - **New surfaces:** like the B-rep op, a mesh blend produces new surfaces — feature
   labels upstream of the call do not survive through it (attribution uses the
   fallback path), and the result shades with the default SMOOTH policy.

package/package.json

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

@@ -21,10 +21,14 @@
 // block shaves the sharp corner down to band depth, and the band sweeps around with
 // no crease (see roundSalientCorners). The silhouette inside the band rounds by about
 // the blend radius at such corners; the flat shelf the horn leaves at the band's base
-// is the deliberate residue. Corners keep their mitre — today's and OCCT's behavior,
-// a real crease the feature-line overlay honestly draws — when they are REFLEX (the
-// ball cannot reach in), or too tight to host the setback (glyph-scale features
-// smaller than ~3× the magnitude), or when three or more chains meet (the spherical
+// is the deliberate residue. A REFLEX corner in a common face plane gets the
+// rolling-ball PIVOT (reflexPivotAt/reflexPivotTool): the ball swings about the
+// corner's face-normal axis, touching the face and the vertical corner edge, and the
+// face's blend boundary rounds into an arc of radius r about the vertex — without it
+// the flush-ended neighbor tools leave a wedge of the original rim uncut and the face
+// keeps a point AT the corner (the label-part "artifacts" bug). Corners keep their
+// mitre only when too tight to host the salient setback (glyph-scale features smaller
+// than ~3× the magnitude), or when three or more chains meet (the spherical
 // cornerPatches below own the orthogonal three-chain case).
 //
 // Known limits (documented, not bugs): radius feasibility is the caller's job (clamp
@@ -758,7 +762,9 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // viewer's line threshold and draw across the band. A salient split corner with room
   // for the setback gets a corner ARC (cornerArcAt — the same rounded-corner treatment
   // apply() gives two-chain junctions), the adjoining stretches trimmed to its tangent
-  // points; reflex or too-tight splits keep the overshoot mitre.
+  // points; a reflex split gets the rolling-ball PIVOT (reflexPivotTool — without it
+  // the flush stretch ends leave the corner wedge uncut and the face keeps its point);
+  // too-tight salient splits keep the overshoot mitre.
   const reach = magnitude * 1.5;
   const breaks = [];
   for (let i = closed ? 0 : 1; i < (closed ? m : m - 1); i++) {
@@ -773,6 +779,7 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // polyline to the ADJACENT break (or chain end) — a single tessellation segment says
   // nothing about the room a whole smooth stretch offers.
   const cornerArcs = new Map();   // break vertex index → { arc, t }
+  const pivots = [];              // reflex break vertices → rolling-ball pivots
   if (convex && breaks.length) {
     const segSum = (from, to) => {
       let sum = 0;
@@ -789,7 +796,9 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
         : (j + 1 < breaks.length ? breaks[j + 1] : m - 1);
       const got = cornerArcAt(at(i), faceN, scl(segDir[iIn], -1), segDir[i],
         wallNs[iIn], wallNs[i], segSum(prevB, i), segSum(i, nextB), magnitude);
-      if (got) cornerArcs.set(i, got);
+      if (got) { cornerArcs.set(i, got); continue; }
+      const piv = reflexPivotAt(at(i), faceN, scl(segDir[iIn], -1), segDir[i], wallNs[iIn], wallNs[i]);
+      if (piv) pivots.push(piv);
     }
   }
 
@@ -860,6 +869,7 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
       if (len(sub(got.vertex, got.arc.O)) - got.arc.R > 0.02 * magnitude)
         tools.push(cornerHornTool(k, got, magnitude, segs));
     }
+    for (const piv of pivots) tools.push(reflexPivotTool(k, piv, magnitude, mode, segs, pSegs));
     return tools;
   } catch (e) {
     throw new UnsupportedEdgeError(`planar sweep: ${e.message}`);
@@ -883,10 +893,11 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
 // sharper than CORNER_ROUND_MIN_TURN; gentler corners keep their exact silhouette (a
 // mitre under the viewer\'s 35° line threshold draws nothing).
 //
-// REFLEX corners keep the mitre: the ball genuinely cannot reach into the corner, the
-// crease there is real geometry, and rounding the path would ADD material. A corner
-// whose neighbors are too short to host the setback (tight glyph features) falls back
-// to the mitre too — the fallback is today\'s behavior, never a failure.
+// REFLEX corners take the rolling-ball PIVOT instead (reflexPivotAt below): steering
+// the band path around a reflex corner would ADD material, but the ball itself swings
+// about the corner touching the face and the vertical corner edge — see the reflex
+// pivot section. A salient corner whose neighbors are too short to host the setback
+// (tight glyph features) falls back to the mitre — that fallback is never a failure.
 // Corners gentler than this keep their mitre: the two blends there differ by less than
 // the mitre turn everywhere, far under the viewer's 35° line threshold, and the shallow
 // overlap sliver stays too flat for simplify() to fold into visible creases. Measured:
@@ -989,6 +1000,95 @@ function cornerHornTool(k, { vertex, f, arc }, magnitude, segs) {
   return tool.translate(O);
 }
 
+// ---------------------------------------------------------------------------
+// Reflex pivots. At a REFLEX corner the neighboring blend tools end flush against the
+// planes through the vertex (their only overshoot is the 0.05·r anti-graze allowance),
+// so the wedge of rim material between those end planes — azimuthal extent = the turn
+// angle — survives both cutters and the face keeps a point essentially AT the vertex.
+// The rolling ball does not stop there: it pivots about the corner, touching the face
+// and the vertical corner edge, its center swinging on an arc of radius r about the
+// face-normal axis through the vertex. The envelope is a horn-torus patch — the
+// revolve, about that axis, of the blend cross-section running from the axis point
+// r below the face to the face tangency at radius r — and the face's blend boundary
+// becomes an arc of radius r about the vertex (the "rounded inside curve"). The pivot
+// cross-section at each span end coincides exactly with the neighbor tool's own
+// cross-section at the vertex (same circle, same plane), so the handover is G1; the
+// small angular overshoot below only re-cuts band the neighbors already cut.
+
+// Pivot descriptor at one vertex, or null (salient — cornerArcAt's case — or a turn
+// too gentle to matter). Same argument convention as cornerArcAt: tin1/tin2 point
+// from the vertex INTO each side, wall1/wall2 are the sides' outward wall normals.
+function reflexPivotAt(vertex, f, tin1, tin2, wall1, wall2) {
+  const tIn = scl(tin1, -1), tOut = tin2;
+  const turn = Math.acos(clamp1(dot(tIn, tOut)));
+  if (turn < CORNER_ROUND_MIN_TURN) return null;  // wedge sagitta sub-micron: keep today's behavior
+  const turnS = dot(cross(tIn, tOut), f);
+  const matLeft = dot(wall1, cross(tIn, f)) > 0;
+  if ((turnS > 0) === matLeft) return null;       // salient: roundSalientCorners' territory
+  // inward in-plane wall normals bound the uncut wedge; the pivot sweeps between them
+  const proj = (wl) => { const p = sub(scl(wl, -1), scl(f, -dot(wl, f))); const l = len(p) || 1; return scl(p, 1 / l); };
+  let u0 = proj(wall1), uE = proj(wall2);
+  const span = Math.acos(clamp1(dot(u0, uE)));
+  if (!(span > 1e-4)) return null;
+  if (dot(cross(u0, uE), f) < 0) [u0, uE] = [uE, u0]; // azimuth increases u0 → uE about +f
+  return { vertex, f, u0, span };
+}
+
+// The pivot cutter: revolve of the blend cross-section about the face-normal axis
+// through the vertex. Cross-section in (ρ, z) with z along f (face at z = 0): the
+// fillet arc runs from the axis point (0, −r) to the face tangency (r, 0) on the
+// circle centered (r, −r) — extended past the tangency by revolveTool's arc-tail
+// recipe, because the blend meets the face tangentially there and a tessellated
+// tangency grazes — then closes above the face so the corner column goes with it.
+// A chamfer takes the chord instead (a cone), which meets face and edge transversally
+// and needs no tail. Interior arc vertices use profile2D's area-exact radius.
+function reflexPivotTool(k, { vertex, f, u0, span }, magnitude, mode, segs, pSegs) {
+  const r = magnitude;
+  const delta = 0.02 * r;
+  let poly;
+  if (mode === "chamfer") {
+    poly = [[0, -r], [r, 0], [r + delta, delta], [0, delta]];
+  } else {
+    const sag = Math.min(2e-4, 0.02 * r);
+    const ext = Math.min(0.4, Math.max(0.01, Math.acos(Math.max(-1, 1 - sag / r))));
+    const arcSpan = Math.PI / 2 + ext;
+    const nArc = Math.max(2, Math.ceil((arcSpan / (2 * Math.PI)) * pSegs));
+    const th = arcSpan / nArc;
+    const rEq = r * Math.sqrt(th / Math.sin(th));
+    poly = [];
+    for (let i = 0; i <= nArc; i++) {
+      const a = Math.PI - arcSpan * (i / nArc);       // 180° (axis) → past the face tangency
+      const ri = i === 0 || i === nArc ? r : rEq;
+      poly.push([r + ri * Math.cos(a), -r + ri * Math.sin(a)]);
+    }
+    poly.push([poly[poly.length - 1][0], delta], [0, delta]);
+  }
+  let area = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const [x1, y1] = poly[i], [x2, y2] = poly[(i + 1) % poly.length];
+    area += x1 * y2 - x2 * y1;
+  }
+  if (area < 0) poly = poly.slice().reverse();
+  // angular overshoot past both span ends: crosses the walls (tangent contacts at the
+  // ends) decisively, re-cutting only band the flush-ended neighbors already cut
+  const ovAng = 0.05;
+  const degrees = ((span + 2 * ovAng) * 180) / Math.PI;
+  let tool = k.revolve(poly, { degrees, segs: cornerArcSegs(segs, 0, magnitude) });
+  // pose: Z → f, then twist the revolve's start azimuth (+X) onto u0 backed off by ovAng
+  const v0 = cross(f, u0);
+  const startDir = add(scl(u0, Math.cos(-ovAng)), scl(v0, Math.sin(-ovAng)));
+  const axisRaw = cross([0, 0, 1], f);
+  const s = len(axisRaw);
+  let axis = null, theta = 0;
+  if (s > 1e-9) { axis = scl(axisRaw, 1 / s); theta = Math.atan2(s, f[2]); }
+  else if (f[2] < 0) { axis = [1, 0, 0]; theta = Math.PI; }
+  if (axis) tool = tool.rotateAbout({ axis, deg: (theta * 180) / Math.PI });
+  const xImage = axis ? rotVec([1, 0, 0], axis, theta) : [1, 0, 0];
+  const twist = Math.atan2(dot(f, cross(xImage, startDir)), dot(xImage, startDir));
+  if (Math.abs(twist) > 1e-9) tool = tool.rotateAbout({ axis: f, deg: (twist * 180) / Math.PI });
+  return tool.translate(vertex);
+}
+
 function chainEndInfo(ch, end) {
   if (ch.kind === "line") {
     return end === "start"
@@ -1003,9 +1103,10 @@ function chainEndInfo(ch, end) {
     : { v: pts[m - 1], tin: norm(sub(pts[m - 2], pts[m - 1])), flanks: [ch.faceN, ch.wallNs[ch.wallNs.length - 1]], len: plen };
 }
 
-// Corner arc for two chain ends meeting at one vertex, or null (no common face plane,
-// gentle turn, reflex corner, or no room for the setback).
-function cornerArcBetween(E1, E2, magnitude) {
+// Corner treatment for two chain ends meeting at one vertex: {arc} for a salient
+// corner with room for the setback, {pivot} for a reflex corner, or null (no common
+// face plane, gentle turn, or a too-tight salient corner keeping its mitre).
+function cornerBlendBetween(E1, E2, magnitude) {
   let f = null, wall1 = null, wall2 = null;
   for (const c1 of E1.flanks) {
     for (const c2 of E2.flanks) {
@@ -1018,7 +1119,10 @@ function cornerArcBetween(E1, E2, magnitude) {
     }
   }
   if (!f) return null;
-  return cornerArcAt(E1.v, f, E1.tin, E2.tin, wall1, wall2, E1.len, E2.len, magnitude);
+  const corner = cornerArcAt(E1.v, f, E1.tin, E2.tin, wall1, wall2, E1.len, E2.len, magnitude);
+  if (corner) return { corner };
+  const pivot = reflexPivotAt(E1.v, f, E1.tin, E2.tin, wall1, wall2);
+  return pivot ? { pivot } : null;
 }
 
 // Convert a FACE-PLANE arc chain to the equivalent planar chain, or return null when
@@ -1082,8 +1186,9 @@ function trimChain(ch, tStart, tEnd) {
   return { ...ch, points: pts, wallNs: walls, closed: false };
 }
 
-// Round the salient two-chain corners of a selection: returns the effective chain list
-// (trimmed neighbors substituted in place) plus the synthetic corner-arc chains.
+// Blend the two-chain corners of a selection: salient corners round (trimmed neighbors
+// substituted in place, plus the synthetic corner-arc chains and their horns); reflex
+// corners get rolling-ball pivots (neighbors stay flush — the pivot owns the wedge).
 function roundSalientCorners(selected, magnitude) {
   const keyOf = (p) => `${Math.round(p[0] * WELD)},${Math.round(p[1] * WELD)},${Math.round(p[2] * WELD)}`;
   const ends = new Map();
@@ -1096,7 +1201,7 @@ function roundSalientCorners(selected, magnitude) {
       (ends.get(kk) ?? ends.set(kk, []).get(kk)).push({ ch, end, info });
     }
   }
-  const arcs = [], horns = [], trims = new Map();
+  const arcs = [], horns = [], pivots = [], trims = new Map();
   const addTrim = (ch, end, t) => {
     const cur = trims.get(ch) ?? { start: 0, end: 0 };
     cur[end] = t;
@@ -1104,8 +1209,10 @@ function roundSalientCorners(selected, magnitude) {
   };
   for (const list of ends.values()) {
     if (list.length !== 2 || (list[0].ch === list[1].ch && list[0].end === list[1].end)) continue;
-    const got = cornerArcBetween(list[0].info, list[1].info, magnitude);
-    if (!got) continue;
+    const blend = cornerBlendBetween(list[0].info, list[1].info, magnitude);
+    if (!blend) continue;
+    if (blend.pivot) { pivots.push(blend.pivot); continue; }
+    const got = blend.corner;
     arcs.push(got.arc);
     // a gentle corner's horn is a sliver — depth ρ·(1/cos(turn/2) − 1), microns at
     // small turns — not worth a cutter (and thin cutters are their own noise source)
@@ -1114,14 +1221,14 @@ function roundSalientCorners(selected, magnitude) {
     addTrim(list[0].ch, list[0].end, got.t);
     addTrim(list[1].ch, list[1].end, got.t);
   }
-  if (!arcs.length) return { chains: selected, arcs, horns };
+  if (!arcs.length) return { chains: selected, arcs, horns, pivots };
   const chains = [];
   for (const ch of selected) {
     const tr = trims.get(ch);
     const eff = tr ? trimChain(ch, tr.start, tr.end) : ch;
     if (eff) chains.push(eff);
   }
-  return { chains, arcs, horns };
+  return { chains, arcs, horns, pivots };
 }
 
 // ---------------------------------------------------------------------------
@@ -1199,7 +1306,7 @@ function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg
   // converted arc joins its planar neighbors — chainEdges' own stitch pass ran before
   // these chains were planar, so their junctions are still open here.
   const planarized = stitchPlanarChains(selected.map((ch) => planarizeArc(ch) ?? ch));
-  const { chains: effective, arcs, horns } = roundSalientCorners(planarized, magnitude);
+  const { chains: effective, arcs, horns, pivots } = roundSalientCorners(planarized, magnitude);
   const pSegs = blendSegs(segs, magnitude);
   const toolsFor = (ch) =>
     ch.kind === "planar"
@@ -1207,6 +1314,7 @@ function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg
       : [(ch.kind === "arc" ? revolveTool : prismTool)(k, ch, magnitude, mode, segs, pSegs)];
   const cutters = [...effective, ...arcs].filter((ch) => ch.convex).flatMap(toolsFor);
   cutters.push(...horns.map((h) => cornerHornTool(k, h, magnitude, segs)));
+  cutters.push(...pivots.map((p) => reflexPivotTool(k, p, magnitude, mode, segs, pSegs)));
   const fillers = effective.filter((ch) => !ch.convex).flatMap(toolsFor);
   if (mode === "fillet") cutters.push(...cornerPatches(k, effective, magnitude, segs));
   let out = solid;

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