partforge 0.137.0 → 0.138.0

package/README.md

@@ -43,7 +43,8 @@ Two geometry backends run in Web Workers, and partforge routes each part to whic
 needs:
 
 - **[Manifold](https://github.com/elalish/manifold)** — fast preview meshes and STL / 3MF,
-  including mesh-native fillet and chamfer for straight and circular edges.
+  including mesh-native fillet and chamfer for straight, circular, planar-rim and
+  curved-face edges.
 - **[Replicad](https://replicad.xyz)** (OpenCASCADE-in-WebAssembly) — exact B-rep for STEP,
   shell, and automatic fallback for blend geometry Manifold cannot handle.
 

package/docs/AUTHORING-PARTS.md

@@ -3583,7 +3583,7 @@ previously didn't; that's the fix working as intended, not a regression.
 `duplicate-preset-name`, `duplicate-node-id`, `select-options-missing`,
 `select-default-not-in-options`, `log-scale-needs-positive-min`,
 `when-key-not-in-defaults`, `when-unknown-operator`, `unknown-control-type`,
-`custom-control-widget-not-function`, `custom-default-not-json`,
+`legacy-shape-widget`, `custom-control-widget-not-function`, `custom-default-not-json`,
 `custom-keys-not-in-defaults` (errors);
 `slider-range-excludes-default`, `unknown-control-field`, `duplicate-control-key`,
 `default-not-exposed`, `readout-unknown-derived-key`, `slider-refinement-invalid`,
@@ -3627,6 +3627,13 @@ each comparison operator (`{ gt: 0 }`, `{ in: [...] }`, …) must be one
 condition is always false and the node never shows — which is why both are
 errors rather than warnings.
 
+`legacy-shape-widget` fires when an entry in the legacy shape (`advanced`, `toggles`,
+`features`) sets `type`, or sets `control` to anything but `slider`, `number`, `text` or
+`textarea`. The legacy shape never reads `type`, so a `{ type: "select", options }` there
+renders as a slider and writes numbers into a key the build compares against strings;
+put such a control in a `controls` section, where `type` picks the widget. A boolean in the
+legacy shape belongs in `toggles`.
+
 `unknown-control-type` fires when an authored control's `type` (e.g. a typo
 like `"sldier"`) isn't one of the recognised widget types — the renderer skips
 a node with an unrecognised type entirely, so the control silently vanishes
@@ -4156,9 +4163,11 @@ contract v3 that **includes fillet and chamfer**: the mesh backend blends straig
 edges, circular-arc edges (bore rims, cylinder rims, the arcs where fillets meet a
 face), and **planar contour edges at constant dihedral** — the top/bottom rims of any
 extruded profile, however curvy its outline: `text2d` lettering, `Shape2D.offset`
-outlines, spline profiles all round natively now. Only `shell` still routes a
+outlines, spline profiles all round natively now. Edges **between two curved faces** — a boss meeting a tube, a cross hole's rim, the
+ellipse where a plane cuts a cylinder — blend natively too (a per-vertex
+cross-section, since 0.138). Only `shell` still routes a
 sub-part to OCCT up front; a fillet/chamfer on an edge class the mesh backend can't
-blend (helical edges, varying dihedral) reroutes that sub-part to OCCT automatically
+blend (mixed convexity along one edge, a bend tighter than the fillet radius, knife edges) reroutes that sub-part to OCCT automatically
 at runtime — no declaration needed either way:
 
 | Op | Meaning |

package/docs/ERROR-PATTERNS.md

@@ -763,8 +763,8 @@ between the Manifold preview and the OCCT STEP export.
 
 ## mesh-fillet-unsupported-edge
 
-- **Symptom:** `fillet: ` or `chamfer: ` followed by an edge-class reason — e.g. `edge curve is not circular`, `flank angle varies along the arc`, `selector matched no sharp edges`, `~180° knife edge` — thrown as a `KernelCapabilityError`, or a preview sub-part silently rebuilding on the slow OCCT worker.
-- **Cause:** The mesh backend's native fillet/chamfer (`mesh-fillet.js`) covers straight and circular-arc sharp-edge chains; the selected edges fall outside that (helical edge, varying dihedral, non-circular curve, or nothing sharp matched), so the op signals `NEEDS_OCCT` and the framework reroutes that sub-part (the CLI re-execs once with `PARTFORGE_BACKEND=occt`).
+- **Symptom:** `fillet: ` or `chamfer: ` followed by an edge-class reason — e.g. `edge curve is not circular`, `flank angle varies along the arc`, `selector matched no sharp edges`, `~180° knife edge`, `general chain: bend too tight for fillet 2 (local radius 1.48 mm)`, `general chain: too complex for the mesh fillet (work 303831 > budget 195000)`, `general chain: too many sections for the mesh fillet (… stations > …)` — thrown as a `KernelCapabilityError`, or a preview sub-part silently rebuilding on the slow OCCT worker.
+- **Cause:** The mesh backend's native fillet/chamfer (`mesh-fillet.js`) covers straight, circular, planar-rim and curved-face sharp-edge chains; the selected edges fall outside that (an edge that flips between convex and concave, a bend tighter than the radius, a knife edge, or nothing sharp matched), so the op signals `NEEDS_OCCT` and the framework reroutes that sub-part (the CLI re-execs once with `PARTFORGE_BACKEND=occt`). The two `general chain: too …` reasons are complexity refusals, not edge classes: a selection containing a curved-face edge whose estimated blend work (every selected edge, weighted by kind, × √triangles) exceeds the budget — thread, knurl and texture geometry with thousands of sharp edges behind a few curved ones — or a single curved-face edge needing more cross-sections than the cap. Both are deterministic counts, never timings; because the work grows with √triangles, a sub-part near the budget can blend at preview and reroute at print (same reroute, OCCT result correct).
 - **Fix:** Usually nothing — the reroute is the designed degrade and the OCCT result is correct, just slower. To stay on Manifold, restructure so the blend lands on a supported edge class (design the rounding into the profile, or fillet before the boolean that curves the edge). See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Fillet, chamfer & shell".
 
 ## mesh-fillet-oversized-radius

package/docs/KERNEL-CONTRACT.md

@@ -48,12 +48,19 @@ list).
 implements `fillet` and `chamfer` natively** (`mesh-fillet.js` — tangent-tool CSG).
 Its coverage and tolerance band are part of the contract:
 
-- **Edge classes:** straight sharp edges with planar flanks, and circular-arc sharp
+- **Edge classes:** straight sharp edges with planar flanks; circular-arc sharp
   edges whose flanks are surfaces of revolution about the arc axis (bore rims,
-  cylinder rims, the arcs where blends meet a face) — full circles included. Convex
-  edges subtract a cutter; concave edges union a filler. Any other edge class
-  (helical edges, varying dihedral, non-circular curves, function selectors) throws
-  `KernelCapabilityError` so the host can reroute that build to a B-rep kernel.
+  cylinder rims, the arcs where blends meet a face) — full circles included;
+  planar-rim edges (an edge lying in a face plane at a constant wall angle — the
+  rims of any extruded outline); and, since 0.138, curved-face edges between two
+  curved faces (a boss meeting a tube, a cross hole's rim, the ellipse where a plane
+  cuts a cylinder), blended with a per-vertex cross-section. Convex edges subtract a
+  cutter; concave edges union a filler. A selection the mesh class cannot blend
+  throws `KernelCapabilityError` so the host can reroute that build to a B-rep
+  kernel: an edge that flips between convex and concave along its length, a bend
+  tighter than the radius, a knife edge (anti-parallel flanks), a curved-face
+  selection over the mesh fillet's complexity budget, or a function selector.
+  There is no partial blending — one such edge reroutes the whole sub-part.
 - **Tolerance band, not identity:** the blend surface is the exact rolling-ball
   (fillet) or setback-chord (chamfer) surface to within tessellation, plus
   micron-scale robustness allowances (tool overshoot past tangency and seam-grazing
@@ -370,7 +377,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `toMesh({quality?})` | Render mesh: `{positions, normals, indices?, triangles, edges?, featureIds?, features?}`. `indices` optional (a backend may emit soup or indexed); `normals` and `edges` are authoritative shading intent from both backends — see [Shading intent](#shading-intent-tomesh-normals-and-edges) below; `featureIds`/`features` 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({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})` | `fillet`/`chamfer`: implemented on BOTH in-repo classes since v3 — exactly on B-rep, tolerance-band on the mesh class for straight and circular-arc edge chains (see [Conformance classes](#conformance-classes)); an edge class the mesh kernel cannot blend throws `KernelCapabilityError` and reroutes. Zero magnitude — `fillet(0)` / `chamfer({d: 0})` — is the identity on every class (returns the solid unchanged, never throws; `shell` excluded, `t: 0` is degenerate). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` remains B-rep-only (core throws), hollows inward keeping outer dimensions; `open` (face selector) is required. |
+| `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | `fillet`/`chamfer`: implemented on BOTH in-repo classes since v3 — exactly on B-rep, tolerance-band on the mesh class for straight, circular-arc, planar-rim and curved-face edge chains (see [Conformance classes](#conformance-classes)); an edge class the mesh kernel cannot blend throws `KernelCapabilityError` and reroutes. Zero magnitude — `fillet(0)` / `chamfer({d: 0})` — is the identity on every class (returns the solid unchanged, never throws; `shell` excluded, `t: 0` is degenerate). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` remains B-rep-only (core throws), hollows inward keeping outer dimensions; `open` (face selector) is required. |
 | `roundAll(r)` · `roundAll({r})` | Morphological close-then-open with a ball of radius `r`: rounds EVERY edge (convex and concave) at radius ≈ `r`; faces stay in place (within the class's tolerance band — the B-rep offset chain can drift ~0.1 mm); features smaller than the ball are consumed (walls < 2r melt, holes < 2r seal). Implemented natively on BOTH classes — never routes, never throws `KernelCapabilityError`. Parity-tolerant only while `r` is below the smallest feature size; at consuming radii the mesh class performs true consumption and a B-rep class MAY skip the whole op unchanged with a `roundall-skipped` warning (skip is the only permitted degrade). `roundAll(0)` is the identity on every class. |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for
@@ -942,7 +949,9 @@ now implement it (no stub, unlike the `OCCT_ONLY_OPS` ops).
 
 **v2 → v3** (partforge 0.62): `Solid.fillet` and `Solid.chamfer` are implemented
 natively on the mesh (core reference) kernel for straight and circular-arc edge
-chains, and are **no longer probe-routed to OCCT** — `ROUTED_CAD_OPS` (`shell`) is
+chains (coverage has since grown inside v3 with no contract bump: planar-rim edges,
+then curved-face edges in 0.138 — see [Conformance classes](#conformance-classes)),
+and are **no longer probe-routed to OCCT** — `ROUTED_CAD_OPS` (`shell`) is
 the remaining probe-routing set, and unsupported edge classes reroute at runtime via
 `KernelCapabilityError`. Semantics change for existing parts: a part using fillet or
 chamfer now previews (and STL/3MF-exports) from the mesh kernel's tolerance-band

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.137.0",
+  "version": "0.138.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/blend-surfaces.js

@@ -19,6 +19,9 @@
 //                                   the swept path, f its face normal, dirs[i] the
 //                                   in-plane wall-side direction at vertex i, and the
 //                                   ball centre sits at kf·f + kd·dir off the edge
+//   { kind: "spine", pts, closed, r }
+//                                   general chain (mesh-fillet generalTool): the
+//                                   ball-centre polyline itself; r is the radius
 //
 // A path's polyline usually STANDS FOR a smooth curve (a circle's rim, an outline's
 // rounded corner): its per-segment cylinders would shade faceted around the curve,
@@ -97,6 +100,11 @@ export function mapSurface(desc, M) {
         dirs: desc.dirs.map((d) => norm(applyDir(M, d)) ?? d), f: norm(applyDir(M, desc.f)) ?? desc.f,
         kf: desc.kf * s, kd: desc.kd * s };
     }
+    case "spine": {
+      const s = Math.cbrt(Math.abs(
+        M[0] * (M[4] * M[8] - M[5] * M[7]) - M[3] * (M[1] * M[8] - M[2] * M[7]) + M[6] * (M[1] * M[5] - M[2] * M[4])));
+      return { kind: "spine", closed: desc.closed, pts: desc.pts.map((p) => applyPt(M, p)), r: desc.r * s };
+    }
     default: throw new Error(`blend surface: unknown kind ${desc.kind}`);
   }
 }
@@ -168,7 +176,7 @@ function segmentGrid(desc) {
   const { pts, closed } = desc, n = pts.length, nSeg = closed ? n : n - 1;
   let total = 0;
   for (let i = 0; i < nSeg; i++) { const p = pts[i], q = pts[(i + 1) % n]; total += Math.hypot(q[0] - p[0], q[1] - p[1], q[2] - p[2]); }
-  const h = Math.max(total / Math.max(1, nSeg), Math.abs(desc.kf) + Math.abs(desc.kd), 1e-6);
+  const h = Math.max(total / Math.max(1, nSeg), Math.abs(desc.kf ?? 0) + Math.abs(desc.kd ?? 0) + (desc.r ?? 0), 1e-6);
   const cells = new Map();
   // numeric hashed cell keys: a collision only adds candidates, each distance-checked
   const key = (a, b, c) => (Math.imul(a, 73856093) ^ Math.imul(b, 19349663) ^ Math.imul(c, 83492791)) | 0;
@@ -232,6 +240,13 @@ function nearestSegment(desc, x) {
 // Unit spine→point direction at x in the descriptor's frame, or null where undefined.
 export function surfaceNormal(desc, x) {
   if (desc.kind === "path") return pathNormal(desc, x);
+  if (desc.kind === "spine") {
+    const { bi, bt } = nearestSegment(desc, x);
+    if (bi < 0) return null;
+    const p = desc.pts[bi], q = desc.pts[(bi + 1) % desc.pts.length];
+    const c = [p[0] + (q[0] - p[0]) * bt, p[1] + (q[1] - p[1]) * bt, p[2] + (q[2] - p[2]) * bt];
+    return norm([x[0] - c[0], x[1] - c[1], x[2] - c[2]]);
+  }
   const s = spinePoint(desc, x);
   return s ? norm([x[0] - s[0], x[1] - s[1], x[2] - s[2]]) : null;
 }

package/src/framework/geometry/creased-normals.js

@@ -30,6 +30,8 @@ const ANALYTIC_COS = cosDeg(25);
 // nanometre seam splits (see the weld below).
 const SHADE_WELD = 5e-5;
 const SHADE_CELL = 1e-3; // its hash-grid cell
+// Vertex-normal sliver cutoff (mm of triangle height): see the smooth loop below.
+const SHADE_SLIVER = 1e-3;
 
 export function creasedNormals(g, { policies = null, featureLabels = null, surfaces = null } = {}) {
   const np = g.numProp, vp = g.vertProperties, tris = g.triVerts;
@@ -205,7 +207,25 @@ export function creasedNormals(g, { policies = null, featureLabels = null, surfa
         normals[o] = ln[0]; normals[o + 1] = ln[1]; normals[o + 2] = ln[2];
         continue;
       }
+      // Slivers vote last. The sum below is unweighted — every incident triangle that
+      // passes the surface and crease filters counts once, whatever its size — so a
+      // boolean's degenerate sliver (a wall strip split a hair from its own diagonal by
+      // a revolve cut; a loft seam's triangle with a collapsed edge) whose noisy facet
+      // normal lands inside the crease angle gets the same vote as the real faces
+      // around it. At a tall wall strip's end vertex one or two of them (18–31° off)
+      // tilted the whole strip's shading 5–10°: 12.5% of a plain cylinder's wall
+      // streaked under a top-rim fillet, 25% under a chamfer. Triangles under
+      // SHADE_SLIVER tall are left out of the sum and used only when nothing else
+      // contributes (a corner surrounded by slivers keeps today's normal), so shading
+      // changes only at vertices touching one. The cutoff sits in a measured gap: the
+      // streak slivers are ≤ ~2e-6 mm tall (and the loft seam's 5e-6), while the thin
+      // REAL facets of the reference parts (a coarse loft's, a screw's, a nameplate's)
+      // are 1e-3–4e-2 mm and keep their vote — MIN_FACE (0.04), the line pass's gate,
+      // took those out too and moved a lofted bottle's normals up to 5.6°.
+      // mesh-fillet's contact step leans to meet both neighbours at ≥ 45°, so it never
+      // passes the crease filter at all, whatever its height (see CONTACT_MU there).
       let nx = 0, ny = 0, nz = 0, ax = 0, ay = 0, az = 0, analytic = false;
+      let sx = 0, sy = 0, sz = 0, solid = false;
       for (const t2 of incident.get(weld[v])) {
         // different cut surface → hard, EXCEPT when a blend surface (boundaryLines)
         // is involved on either side. Blend↔blend: one band is many tool surfaces
@@ -220,12 +240,14 @@ export function creasedNormals(g, { policies = null, featureLabels = null, surfa
         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];
+        if (thin[t2] < SHADE_SLIVER) { sx += fn[t2 * 3]; sy += fn[t2 * 3 + 1]; sz += fn[t2 * 3 + 2]; }
+        else { nx += fn[t2 * 3]; ny += fn[t2 * 3 + 1]; nz += fn[t2 * 3 + 2]; solid = true; }
         if (runEval) {
           const an = analyticAt(t2, weld[v]);
           if (an) { ax += an[0]; ay += an[1]; az += an[2]; analytic = true; }
         }
       }
+      if (!solid) { nx = sx; ny = sy; nz = sz; }
       if (analytic && Math.hypot(ax, ay, az) > 1e-9) { nx = ax; ny = ay; nz = az; }
       const L = Math.hypot(nx, ny, nz) || 1;
       const o = (t * 3 + k) * 3, vv = v * np;

package/src/framework/geometry/kernel.js

@@ -106,8 +106,8 @@ export const ROUTED_CAD_OPS = ["shell"];
  *           `normals`/`edges` are authoritative shading intent from both backends — see docs/KERNEL-CONTRACT.md "Shading intent"; quality is advisory — the Manifold kernel bakes it at creation
  * @property {(opts?: {quality?: "preview"|"print"}) => Promise<ArrayBuffer>} toSTL
  * @property {() => {positions:Float32Array, indices:Uint32Array}} toIndexedMesh   indexed mesh, for 3MF
- * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges; mesh-native for straight/circular chains with automatic OCCT fallback; fillet(3) or fillet({r,edges}); legacy (r,selector) accepted for now (see file header)
- * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges; mesh-native for straight/circular chains with automatic OCCT fallback; chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted for now (see file header)
+ * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; fillet(3) or fillet({r,edges}); legacy (r,selector) accepted for now (see file header)
+ * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted for now (see file header)
  * @property {(o:{t:number,open:object}) => Solid} shell   hollow inward (OCCT only); legacy (thickness,openFaces) accepted for now (see file header)
  * @property {() => number} [genus]     through-hole count (Manifold only)
  * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)

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

@@ -6,7 +6,7 @@ import { roundedBoxRings, roundedBoxArcSamples } 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 { manifoldFromMesh, ringStackManifold } from "./mesh-build.js";
 import { createSolidCache } from "./solid-cache.js";
 import { hoistCommonSuffix } from "./transform-hoist.js";
 import { addSugar } from "./solid-sugar.js";
@@ -863,12 +863,10 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       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`).
+    // Side-channel for mesh-fillet's general-chain tools (underscore = off-contract):
+    // a solid from a stack of equal-size 3-D rings (mesh-build.js ringStackManifold).
+    _ringStackSolid: (rings, opts = {}) =>
+      cached(h("ringStack", rings, { closed: !!opts.closed }), () => T(ringStackManifold(wasm, rings, { closed: !!opts.closed }))),
     // Side-channel for mesh-fillet (underscore = off-contract): `surf` describes the
     // tool's blend wall in its current frame. Stored per surface id in the id's
     // ORIGINAL frame (inverse runTransform), so any later pose or boolean — which
@@ -886,6 +884,12 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       }
       return tool;
     },
+    // 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

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

@@ -41,6 +41,38 @@ export function reverseWinding(Tr) {
   for (let t = 0; t < Tr.length; t += 3) { const tmp = Tr[t + 1]; Tr[t + 1] = Tr[t + 2]; Tr[t + 2] = tmp; }
 }
 
+// A solid from a stack of equal-size 3-D rings (mesh-fillet's general-chain tools:
+// one cross-section per edge vertex, each in its own plane). Consecutive rings are
+// stitched by sideQuads; `closed` stitches the last ring back to the first (a loop,
+// no caps), otherwise each end ring is capped by a fan from ITS vertex 0 — valid for
+// rings star-shaped about vertex 0, which every fillet/chamfer section is (vertex 0
+// is the section's corner). Ring orientation is arbitrary: the winding is normalized
+// by the mesh's signed volume, because ofMesh throws or imports an inverted solid
+// when it is wrong (see this file's header).
+export function ringStackManifold(wasm, rings, { closed = false } = {}) {
+  const n = rings[0]?.length ?? 0;
+  if (n < 3 || !rings.every((r) => r.length === n)) throw new Error("ringStack: rings must have equal size (≥ 3 points)");
+  const V = [], Tr = [];
+  for (const ring of rings) for (const p of ring) V.push(p[0], p[1], p[2]);
+  sideQuads(Tr, rings.length, n, closed);
+  if (!closed) {
+    const last = (rings.length - 1) * n;
+    for (let j = 1; j + 1 < n; j++) {
+      Tr.push(0, j + 1, j);                  // first cap (flip, as fanCap's bottom)
+      Tr.push(last, last + j, last + j + 1); // last cap
+    }
+  }
+  let vol6 = 0;
+  for (let t = 0; t < Tr.length; t += 3) {
+    const a = Tr[t] * 3, b = Tr[t + 1] * 3, c = Tr[t + 2] * 3;
+    vol6 += V[a] * (V[b + 1] * V[c + 2] - V[b + 2] * V[c + 1])
+      - V[a + 1] * (V[b] * V[c + 2] - V[b + 2] * V[c])
+      + V[a + 2] * (V[b] * V[c + 1] - V[b + 1] * V[c]);
+  }
+  if (vol6 < 0) reverseWinding(Tr);
+  return manifoldFromMesh(wasm, V, Tr);
+}
+
 // Import a flat vertex array + triangle indices as a watertight Manifold. merge() welds
 // coincident vertices so ofMesh sees a closed manifold; ofMesh consumes the mesh handle,
 // so free it here and let the caller track the returned Manifold.