partforge 0.84.0 → 0.85.0

package/docs/AUTHORING-PARTS.md

@@ -324,7 +324,7 @@ and the detection rule.
 | `k.revolve({ profile, degrees? })` | revolve a lathe profile `[[r,z],…]` (r ≥ 0) around the Z axis (full or partial) |
 | `k.helixSweptTube({ pathR, profileR, pitch, turns, z0, lefthand })` | circle swept along a helix (e.g. a rope groove). **Not for threads** — the profile is always circular and rides a frenet frame that rolls with the helix, tilting a tooth off-axis. For threads use `k.screwSweep` |
 | `k.screwSweep({ profile, pitch, turns, lefthand? })` | screw-motion sweep of an **axial** lathe profile `[[r, z], …]` (same convention as `k.revolve`) — threads, worms, helical ridges. `h = pitch · turns`. The profile's axial extent must not exceed `pitch`; a profile spanning exactly `pitch` must be **periodic** (first radius == last radius) and yields a complete threaded body with no boolean (both backends) |
-| `k.loftSmooth({ sections, stations?, samples?, shading? })` | smooth organic loft: ≥2 sparse control sections (same ring spec as `k.loft`; vertex counts may differ, **point rings only**) interpolated with splines on both backends — the "here are 5 airfoil sections, make it smooth" op. The surface passes through every section exactly. Corners round at the `samples` LOD (sharp tags are future work); see the propeller reference part |
+| `k.loftSmooth({ sections, stations?, samples?, shading?, closed? })` | smooth organic loft: ≥2 sparse control sections — point rings, `sides`+`radius`, curve contours, or `Shape2D`, vertex/corner counts may differ per section — interpolated with splines on both backends — the "here are 5 airfoil sections, make it smooth" op. The surface passes through every section exactly. A point section may tag `sharp: [indices]` to keep those vertices true corners instead of letting the spline round them off; a curve/`Shape2D` section gets its corners implicitly from its own non-smooth joints. All sections need the same corner count. `closed: true` closes the loft into a loop (Manifold-only, like `k.loft`). See the propeller reference part (`sharpTE` toggle) |
 | `k.union(solids[])` | boolean union |
 
 **`loft` rings** — each ring is `{ polygon:[[x,y],…] | sides+radius | {start,segments} | Shape2D, z, rotate?, scale? }`
@@ -365,8 +365,36 @@ const blade = k.loftSmooth({ sections });
 ```
 
 Raise `samples` if the cross-section shows facets, `stations` if banding runs
-along the spine. Sections must be point rings — vertex order and the vertex-0
-seam are how corresponding points line up across sections.
+along the spine. Vertex order and the vertex-0 seam are how corresponding
+points line up across sections (or corner 0, when sections are tagged —
+below).
+
+Tag a true corner (e.g. an airfoil trailing edge that shouldn't be smeared
+into a smooth curve) with `sharp`, an index list into that section's points —
+every other section needs the same *count* of corners, tagged or implicit:
+
+```js
+// src/parts/propeller.js's sharpTE toggle: vertex 0 of each airfoil section
+// is the trailing edge (upper and lower surfaces meet there); tagging it
+// keeps that meeting point a crease instead of letting the spline round it.
+const sections = airfoilSections.map((s) => ({ ...s, sharp: [0] }));
+```
+
+A section can also be a curve contour instead of a point ring — its corners
+come for free from wherever the contour itself isn't smooth (a line/arc
+joint, say), so it needs no `sharp` of its own (and rejects one if given):
+
+```js
+// a half-round "D" profile: one line segment + one arc — 2 implicit corners
+// (the line/arc joints), so it can loft alongside a point section tagged
+// with exactly 2 sharp indices.
+const D = { start: [0, -8], segments: [{ to: [0, 8] }, { to: [0, -8], via: [8, 0] }] };
+k.loftSmooth({ sections: [{ polygon: D, z: 0 }, { polygon: D, z: 10 }] });
+```
+
+Pass `closed: true` to close the loft into a loop instead of capping both
+ends (Manifold-only, same restriction as `k.loft`'s `closed`; a part that
+needs STEP export can't use it).
 
 **`sweep`** takes the same CCW `polygon.js` outline as its `profile` and a plain `[[x,y,z],…]` point list as its
 `path`; the profile stays perpendicular to the path (a rotation-minimizing frame), with sharp mitered corners by

package/docs/ERROR-PATTERNS.md

@@ -497,20 +497,30 @@ Variant literal for a curve-adjacent corner: `filletProfile: corner <i> at (<x>,
 - **Cause:** the ring Shape2D has an inner contour (a `.cut()` inside the outline). Lofting hole tunnels needs its own correspondence and is not supported.
 - **Fix:** loft the outer outline, then `.cut()` a second loft (or an extrusion) of the hole profile from the solid. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Geometry: the kernel / `Solid` API" (`loft` rings).
 
-## loftsmooth-sections-point-arrays
+## loftsmooth-corner-count-mismatch
 
-- **Symptom:** `loftSmooth: section 0 is an arc profile — control sections must be point arrays (for now)` — a `loftSmooth` section was a curve contour (`roundedProfile`, `pathProfile`).
-- **Cause:** v1 interpolates through *points*; accepting a curve section would silently replace the authored curve with a nearby spline, so it is rejected (spec: `docs/superpowers/specs/2026-08-24-loft-smooth-design.md`, "The op").
-- **Fix:** pass the section as a plain `[[x,y],…]` point ring (sample the curve yourself at the density you mean), or use `k.loft` with curve rings if you want the exact curve swept without spline interpolation. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md)'s `k.loftSmooth` row.
+- **Symptom:** `loftSmooth: every section must have the same corner count — section 1 has 0, section 0 has 2`
+- **Cause:** one section carries a `sharp` list (or is a curve contour with corner joints) and another doesn't — every control section must resolve to the same corner count `m` (tagged or implicit), so correspondence across sections is unambiguous.
+- **Fix:** tag the same corners on every section (or none) — a curve section's corners come from its own line/arc joints, so match that count with `sharp` on the point sections it lofts alongside. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md)'s `k.loftSmooth` row.
 
-A `Shape2D` section is not a curve contour, so it doesn't hit this message — it instead fails validation as a non-point-array with `loftSmooth: section ${i} needs polygon:[[x,y],…] (≥3 points) or sides+radius shorthand`, which greps to this same entry.
+## loftsmooth-closed-needs-manifold
+
+- **Symptom:** `loftSmooth: closed:true loops are only supported on the Manifold backend`
+- **Cause:** the part routed to OCCT — STEP export, or an explicit `meta.backend: "occt"` — and `closed: true` loft loops aren't supported there, same restriction as `k.loft`'s `closed`.
+- **Fix:** drop `closed` for a part (or sub-part) that needs STEP export, or keep it mesh-only (no STEP, no `meta.backend: "occt"`). See the `loftSmooth` row in [KERNEL-CONTRACT.md](KERNEL-CONTRACT.md).
 
 ## loftsmooth-looks-faceted
 
 - **Symptom:** a `loftSmooth` solid shows flat facets around the cross-section, in preview or in STEP, even though nothing errored.
-- **Cause:** `samples` is the around-ring LOD on **both** backends — the B-rep skin is smooth *across stations* only, so STEP is faceted around the ring at the `samples` count.
+- **Cause:** `samples` governs curve-*fit* resolution — how many cubic-Bézier spans the emitted ring is cut into — not a facet count, on **either** backend. A B-rep kernel lofts each span as one exact curve edge, so STEP is curve-exact around every ring regardless of `samples`; too few spans just means the fit follows the control sections less faithfully (a visible corner or fast bend flattens). A mesh kernel doesn't facet one triangle per span either — `k.loft`'s curve mode adaptively subdivides each span by curvature at the shared `LOFT_SEGS = 64` budget (`loft-rings.js`'s `segNaturalCount`/`sampleBezier`), so around-ring facet density comes from that curve LOD, and rises with `samples` only because more spans means more things to subdivide, not proportionally.
 - **Fix:** raise `samples` (default `max(64, largest section)`, clamp ≤ 2048). If the banding runs along the spine instead, raise `stations`. See the `loftSmooth` row in [KERNEL-CONTRACT.md](KERNEL-CONTRACT.md).
 
+## loftsmooth-zero-perimeter-arc
+
+- **Symptom:** `loftSmooth: a control section has zero perimeter`
+- **Cause:** two sharp-tagged vertices (or two contour corners) in the same section are numerically coincident, so the arc between them has zero length — e.g. tagging *both* ends of a closed NACA trailing edge, whose closure coefficient already brings them to the same point (or the same point after a per-section `rotate`). This also fires for the v1 meaning of the message: a genuinely degenerate section.
+- **Fix:** tag only one of the coincident vertices as the corner (see `src/parts/propeller.js`'s `sharpTE` comment for why a second tag there would create exactly this zero-length arc). See [AUTHORING-PARTS.md](AUTHORING-PARTS.md)'s `k.loftSmooth` row.
+
 ## duplicate-preset-name-throws
 
 - **Symptom:** `duplicate preset name across sections:` thrown from verify/measure, naming the repeated preset (e.g. `duplicate preset name across sections: "Compact"`).

package/docs/KERNEL-CONTRACT.md

@@ -288,7 +288,7 @@ above. All ops return a `Solid`.
 | `sweep({profile, path, closed?, cornerRadius?, ruled?, smooth?})` | Sweep a fixed CCW profile along a polyline with a rotation-minimizing frame; sharp mitered corners, or `cornerRadius` fillets; capped ends. |
 | `helixSweptTube({pathR, profileR, pitch, turns, z0, lefthand})` | Circle of radius `profileR` swept along a helix (e.g. a rope groove). Circular profile on a frenet frame that rolls with the helix — **not for threads**; use `screwSweep`. |
 | `screwSweep({profile, pitch, turns, lefthand})` | Screw-motion sweep of an axial lathe profile `[[r, z], …]` (r ≥ 0) — threads. The profile travels to `(r·cosθ, r·sinθ, z + pitch·θ/2π)`; `h = pitch · turns`. Axial extent must not exceed `pitch` or consecutive turns interpenetrate (throws). A profile spanning exactly `pitch` is **periodic**: first and last radius must agree, and it yields a complete threaded body needing no boolean. Compound: the polar-remapped, densified section extruded with `twist = 360 · turns`, exactly as composed in `kernel-front.js`; a backend may override only for caching, never for different geometry. Options-only. Parity: **within tolerance, not by construction** — both backends receive the identical densified polygon, but the mesh backend facets the twist at its own resolution while the B-rep backend builds an exact spline (`hull`'s parity class). |
-| `loftSmooth({sections, stations?, samples?, shading?})` | Spline-interpolated loft of ≥2 sparse control sections (loft-style ring specs `{polygon\|sides+radius, z, rotate?, scale?}`; vertex counts **may differ** — point rings only; curve/`Shape2D` sections throw). Compound (`kernel-front.js` + `loft-smooth.js`): a shared centripetal Catmull-Rom reconciles every section to `samples` vertices (arc-length resample **from vertex 0** — authored correspondence: vertex `j` is the same material line on every section, so authored `rotate` twist sweeps instead of being re-seamed away). A mesh kernel lofts `stations` densified rings (every control knot emitted as a real ring; poly-exact path, smooth-shaded by default); a B-rep kernel lofts the sparse control wires with its native smooth skin (`ruled: false`) — the densified-wire alternative measured 23 s / WASM-abort territory. Options-only. Defaults `stations = (n−1)·8+1` (raised to the section count when lower), `samples = max(64, largest section)`; clamps 2…1024 / 8…2048. The surface interpolates every control section exactly. Parity: **within tolerance** (`screwSweep`'s class — the backends interpolate across stations differently; ~0.4% measured on the propeller reference part, test-gated at 2%). STEP is smooth across stations and faceted around rings at the `samples` LOD (the `extrude` `bevel` trade). |
+| `loftSmooth({sections, stations?, samples?, shading?, closed?})` | Spline-interpolated loft of ≥2 sparse control sections — loft-style ring specs `{polygon\|sides+radius\|curve contour\|Shape2D, z, rotate?, scale?, sharp?}`; vertex counts **may differ**. A point section may tag `sharp: [indices]` as true corners (integers in `0…points.length-1`, sorted/deduped silently); a curve/`Shape2D` section takes corners implicitly from its non-smooth joints (single-region, hole-free, `loftSmooth:`-prefixed `k.loft` validation) and rejects an explicit `sharp`. Every section must resolve to the **same corner count `m`** (frozen error otherwise); with `m ≥ 1` corner 0 anchors the seam (replacing vertex 0), with `m = 0` v1's vertex-0 anchor holds verbatim. Compound (`kernel-front.js` + `loft-smooth.js`): each section's outline is a closed centripetal Catmull-Rom split into `m` clamped open arcs at its corners (or one closed periodic CR when `m = 0`); the `samples` budget is apportioned across arcs by mean arc-length fraction (largest-remainder, min 1 span/arc) and each arc resampled by arc length — total ring vertex count is `samples`, identical across sections, exactly v1's invariant now corner-anchored. The cross-station direction is v1 verbatim (shared centroid-spine knots, per-vertex CR, reflection phantoms at the ends, or periodic knots when `closed: true`). What's new is emission: every station — the dense list and the sparse `stations:"controls"` list alike — is fitted back to an **all-cubic Bézier contour**, arc-by-arc, via exact 4-point CR→Bézier inversion, so **both backends receive identical curve rings**. A B-rep kernel lofts the sparse control wires with its native smooth skin (`ruled: false`) — curve-exact around each ring in STEP (the densified-*point*-wire alternative measured 23 s / WASM-abort territory, which curve wires don't hit). A mesh kernel densifies `stations` rings and lofts them through `k.loft`'s curve-mode per-segment sampling, creasing sharp/corner columns via loft's geometric corner policy. `closed: true` (default false; needs ≥3 control sections, frozen error otherwise) makes the cross-station CR periodic (no reflection phantoms, ring 0 not repeated) and is **Manifold-only**, same restriction as `loft` `closed: true`: a B-rep kernel throws `loftSmooth: closed:true loops are only supported on the Manifold backend` in the composition, before building any rings; combining `closed: true` with `stations:"controls"` is rejected as a defensive invariant (reachable only by explicitly passing the internal `stations:"controls"` value; the composition never produces the combination itself). Options-only. Defaults `stations = (n−1)·8+1` open / `n·8` closed (raised to the section count `n` when lower), `samples = max(64, largest section)` (raised to the corner count `m` when lower); clamps 2…1024 / 8…2048. The surface interpolates every control section exactly. Parity: **within tolerance** (`screwSweep`'s class, unchanged from v1 — ~0.4% measured on the propeller reference part, test-gated at 2%). STEP is now curve-exact around each ring (previously faceted at the `samples` LOD); the cross-station skin remains ThruSections' native fit, not the shared CR — exact cross-station B-splines are a v3 candidate. Additive: `sharp`, curve/`Shape2D` sections, and `closed` are new options on top of v1's `{sections, stations?, samples?, shading?}`; `CONTRACT_VERSION` stays 4 — the same non-bump precedent as `import` above, a refinement inside the op's already-stated tolerance class rather than a new one. |
 | `union(solids[])` | Boolean union of one or more solids. |
 | `text2d(string, {size, font?, align?, valign?, lineHeight?, tracking?, kerning?})` | Outline-font text → `Shape2D`. `size` = cap height (mm). `font` = declared name / inline bytes / default. Build-time; curve-exact on OCCT, faceted on Manifold. |
 | `hull(inputs[])` | Convex hull of all inputs (each a `Shape2D`, a curve contour, or an `[[x,y],…]` point list) → a convex `Shape2D`. Backend-agnostic: a pure-JS monotone-chain hull over the inputs' sampled points (curved inputs tessellated at a fixed LOD), lifted via `shape2d` (see the parity note below). Throws on an empty input array or a degenerate (collinear/point-count < 3) hull. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.84.0",
+  "version": "0.85.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/kernel-front.js

@@ -56,21 +56,34 @@ export function finishKernel(k) {
       twist: (lefthand ? -360 : 360) * turns,
     });
 
-  // Compound default: spline-smoothed loft. On a mesh
-  // kernel the shared Catmull-Rom densifier expands the sparse control sections in
-  // both directions and plain loft stitches them. On a B-rep kernel that strategy
-  // is both slow and fragile (native loft through dozens of dense wires aborted at
-  // 48×128 in the spike), so it gets only the around-ring reconciliation and its
-  // OWN smooth skin across stations (`ruled: false` — exact B-spline surfaces, and
-  // ~10× faster). Parity is therefore screwSweep's tolerance class, not sweep's
-  // by-construction class: measured ~0.4% volume divergence on the propeller reference part.
+  // Compound default: spline-smoothed loft. The shared Catmull-Rom densifier
+  // (loft-smooth.js) now emits all-cubic curve rings on BOTH paths — every ring
+  // is contour IR ({start, segments:[{to,c1,c2}…]}), fitted exactly from the CR
+  // spline (a CR span IS a cubic; 4-point inversion has no approximation error).
+  // On a mesh kernel it expands the sparse control sections in both directions
+  // and plain loft stitches the curve rings (matched per-segment samples). On a
+  // B-rep kernel, dense *point* wires broke OCCT (v1 spike: 23 s at 32×96, WASM
+  // abort at 48×128) — that fragility is exactly why `stations:"controls"`
+  // exists, skipping cross-station interpolation and handing the backend only
+  // the around-ring reconciliation. Curve wires don't share that fragility:
+  // OCCT's ThruSections handles many-span cubic-Bézier wires in milliseconds
+  // (`ruled: false` — exact B-spline surfaces), probed at 74–261 ms for
+  // 24–128 spans on the propeller reference part. Parity is therefore
+  // screwSweep's tolerance class, not sweep's by-construction class: measured
+  // ~0.4% volume divergence there.
   // B-rep detection: `toSTEP` exists here only on a B-rep backend — the stub for
   // mesh kernels is assigned later in this function.
+  // The guarded shading spread keeps an undefined key out of loft's option
+  // validation; a caller-supplied hint still passes through, and otherwise
+  // loft's own curve-ring shading policy decides (corners crease, curves stay
+  // smooth) rather than this composition forcing "smooth".
   const brepLoft = typeof k.toSTEP === "function";
-  k.loftSmooth ??= ({ sections, stations, samples, shading = "smooth" }) =>
-    brepLoft
+  k.loftSmooth ??= ({ sections, stations, samples, shading, closed = false }) => {
+    if (brepLoft && closed) throw new Error("loftSmooth: closed:true loops are only supported on the Manifold backend");
+    return brepLoft
       ? k.loft({ rings: smoothLoftRings(sections, { stations: "controls", samples }), ruled: false })
-      : k.loft({ rings: smoothLoftRings(sections, { stations, samples }), shading });
+      : k.loft({ rings: smoothLoftRings(sections, { stations, samples, closed }), ...(shading ? { shading } : {}), closed });
+  };
 
   for (const [op, { toArgs, check }] of Object.entries(KERNEL_OP_SPECS)) {
     const raw = k[op];

package/src/framework/geometry/kernel.js

@@ -149,7 +149,7 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(o:{profile:number[][],degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted for now (see file header)
  * @property {(o:{pathR:number,profileR:number,pitch:number,turns:number,z0:number,lefthand:boolean}) => Solid} helixSweptTube
  * @property {(o:{profile:number[][],pitch:number,turns:number,lefthand?:boolean}) => Solid} screwSweep   screw-motion sweep of an axial [[r,z]] profile — threads; options-only
- * @property {(o:{sections:object[],stations?:number,samples?:number,shading?:string}) => Solid} loftSmooth   Catmull-Rom-densified loft of sparse control sections; options-only
+ * @property {(o:{sections:object[],stations?:number,samples?:number,shading?:string,closed?:boolean}) => Solid} loftSmooth   Catmull-Rom-densified loft of sparse control sections; options-only
  * @property {(solids:Solid[]) => Solid} union
  * @property {(profile: number[][]|{outer:number[][],holes?:number[][][]}|{start:number[],segments:object[]}|Shape2D) => Shape2D} shape2d   2-D boolean value; one shared contour-storage implementation on both backends
  * @property {(inputs: (Shape2D|number[][]|{start:number[],segments:object[]})[]) => Shape2D} hull   convex hull of all inputs → a convex Shape2D (faceted; pure-JS monotone chain)

package/src/framework/geometry/loft-smooth.js

@@ -16,11 +16,40 @@
 //     planar — which the k.loft ring format requires.
 // End stations are clamped with reflection phantoms, so the surface interpolates
 // the first and last control sections exactly.
-import { isArcContour } from "./profile.js";
+//
+// Output rings are now all-cubic contour IR ({start, segments:[{to,c1,c2}…]}),
+// not point arrays: each ring's smooth CR outline is fitted back to one exact
+// cubic Bézier span per vertex (fitBezierRing — a CR span IS a cubic, so the
+// 4-point inversion has no approximation error), explicitly closed. k.loft's
+// curve mode then lofts them as exact wires on OCCT and matched per-segment
+// samples on Manifold.
+import { isArcContour, sampleArc, sampleBezier, closeContourGap } from "./profile.js";
+import { profileCorners } from "./contour-ops.js";
+import { LOFT_SEGS } from "./loft-rings.js";
+
+// Tessellate a path contour tracking each segment joint's output index
+// (vertex i = start of segment i; jointIdx[i] is its position in pts).
+function tessellateWithJoints(contour, segs) {
+  const pts = [[contour.start[0], contour.start[1]]];
+  const jointIdx = [0];
+  let prev = contour.start;
+  for (const seg of contour.segments) {
+    if (seg.c1) for (const p of sampleBezier(prev, seg.c1, seg.c2, seg.to, segs)) pts.push(p);
+    else if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) pts.push(p);
+    else pts.push([seg.to[0], seg.to[1]]);
+    jointIdx.push(pts.length - 1);
+    prev = seg.to;
+  }
+  pts.pop();      // explicit closure lands on start — drop the duplicate for a closed ring
+  jointIdx.pop(); // and the wrap entry with it
+  return { pts, jointIdx };
+}
 
 // Mirror of loft's ring spec resolution (loft.js resolveRings), minus the
 // equal-vertex-count rule — the whole point here is that control sections may
-// disagree; the resampler reconciles them.
+// disagree; the resampler reconciles them. Point sections may carry sharp
+// corner tags; curve contours/Shape2D sections carry corners implicitly
+// (their line/curve joints).
 function resolveSections(sections) {
   if (!Array.isArray(sections) || sections.length < 2)
     throw new Error("loftSmooth: sections must be an array of at least 2 control sections");
@@ -28,25 +57,53 @@ function resolveSections(sections) {
     if (!s || typeof s !== "object") throw new Error(`loftSmooth: section ${i} must be an object { polygon|sides+radius, z }`);
     if (!Number.isFinite(s.z)) throw new Error(`loftSmooth: section ${i} needs a finite z`);
     let pts = s.polygon;
-    if (isArcContour(pts))
-      throw new Error(`loftSmooth: section ${i} is an arc profile — control sections must be point arrays (for now)`);
-    if (!pts && Number.isFinite(s.sides) && Number.isFinite(s.radius)) {
-      pts = [];
-      for (let j = 0; j < s.sides; j++) {
-        const a = (j / s.sides) * 2 * Math.PI;
-        pts.push([Math.cos(a) * s.radius, Math.sin(a) * s.radius]);
+    let corners;
+    if (pts && pts._shape2d) {
+      const regions = pts._regions;
+      if (regions.length === 0) throw new Error(`loftSmooth: section ${i} is an empty Shape2D — nothing to loft`);
+      if (regions.length > 1) throw new Error(
+        `loftSmooth: section ${i} is a Shape2D with ${regions.length} regions — a loft section must be a single closed outline (union the regions into one, or loft each separately)`);
+      if (regions[0].holes.length > 0) throw new Error(
+        `loftSmooth: section ${i} has holes — loft sections must be hole-free outlines (cut the holes from the lofted solid instead)`);
+      pts = JSON.parse(JSON.stringify(regions[0].outer));
+    }
+    if (isArcContour(pts)) {
+      if (s.sharp != null)
+        throw new Error(`loftSmooth: section ${i} is a curve contour — its corners are implicit; sharp is only for point sections`);
+      const contour = closeContourGap(pts);
+      const t = tessellateWithJoints(contour, LOFT_SEGS);
+      corners = profileCorners(contour).map((c) => t.jointIdx[c.index]).sort((a, b) => a - b);
+      pts = t.pts;
+    } else {
+      if (!pts && Number.isFinite(s.sides) && Number.isFinite(s.radius)) {
+        pts = [];
+        for (let j = 0; j < s.sides; j++) {
+          const a = (j / s.sides) * 2 * Math.PI;
+          pts.push([Math.cos(a) * s.radius, Math.sin(a) * s.radius]);
+        }
       }
+      if (!Array.isArray(pts) || pts.length < 3)
+        throw new Error(`loftSmooth: section ${i} needs polygon:[[x,y],…] (≥3 points), a curve contour, a Shape2D, or sides+radius shorthand`);
+      if (s.sharp != null) {
+        if (!Array.isArray(s.sharp) || s.sharp.some((x) => !Number.isInteger(x) || x < 0 || x >= pts.length))
+          throw new Error(`loftSmooth: section ${i} sharp indices must be integers in 0…${pts.length - 1}`);
+        corners = [...new Set(s.sharp)].sort((a, b) => a - b);
+      } else corners = [];
     }
-    if (!Array.isArray(pts) || pts.length < 3)
-      throw new Error(`loftSmooth: section ${i} needs polygon:[[x,y],…] (≥3 points) or sides+radius shorthand`);
     const sc = s.scale ?? 1;
     const [sx, sy] = Array.isArray(sc) ? sc : [sc, sc];
     const rot = ((s.rotate ?? 0) * Math.PI) / 180, cos = Math.cos(rot), sin = Math.sin(rot);
-    const pts2d = pts.map(([x, y]) => {
+    let pts2d = pts.map(([x, y]) => {
       const X = x * sx, Y = y * sy;
       return [X * cos - Y * sin, X * sin + Y * cos];
     });
-    return { pts2d, z: s.z };
+    // Corner 0 anchors the seam (spec §2): rotate the ring so it leads at vertex 0.
+    if (corners.length && corners[0] !== 0) {
+      const shift = corners[0];
+      pts2d = [...pts2d.slice(shift), ...pts2d.slice(0, shift)];
+      corners = corners.map((c) => c - shift);
+    }
+    return { pts2d, corners, z: s.z };
   });
 }
 
@@ -99,60 +156,222 @@ export function resampleClosedSpline(pts, n) {
   return out;
 }
 
+const reflectPt = (p, q) => [2 * p[0] - q[0], 2 * p[1] - q[1]];
+
+// Dense polyline of the clamped open centripetal CR through `pts` (reflection
+// phantoms at both ends), endpoints exact. Shared by resampleOpenArc and the
+// arc-length weights in reconcile().
+function openArcDense(pts) {
+  const A = pts.length;
+  const ctrl = [reflectPt(pts[0], pts[1]), ...pts, reflectPt(pts[A - 1], pts[A - 2])];
+  const dense = [];
+  for (let i = 1; i < A; i++) {
+    const p0 = ctrl[i - 1], p1 = ctrl[i], p2 = ctrl[i + 1], p3 = ctrl[i + 2];
+    const t0 = 0;
+    const t1 = t0 + Math.max(Math.sqrt(dist(p0, p1)), 1e-6);
+    const t2 = t1 + Math.max(Math.sqrt(dist(p1, p2)), 1e-6);
+    const t3 = t2 + Math.max(Math.sqrt(dist(p2, p3)), 1e-6);
+    for (let s = 0; s < SUB; s++)
+      dense.push(crPoint(p0, p1, p2, p3, t0, t1, t2, t3, t1 + ((t2 - t1) * s) / SUB));
+  }
+  dense.push([pts[A - 1][0], pts[A - 1][1]]);
+  return dense;
+}
+
+const polyLen = (poly) => {
+  let L = 0;
+  for (let i = 1; i < poly.length; i++) L += dist(poly[i - 1], poly[i]);
+  return L;
+};
+
+// Clamped open CR through `pts`, resampled uniformly by arc length to spans+1
+// points; both endpoints are interpolated exactly.
+export function resampleOpenArc(pts, spans) {
+  const dense = openArcDense(pts);
+  const M = dense.length - 1;
+  const cum = [0];
+  for (let i = 1; i <= M; i++) cum.push(cum[i - 1] + dist(dense[i - 1], dense[i]));
+  const total = cum[M];
+  if (!(total > 0)) throw new Error("loftSmooth: a control section has zero perimeter");
+  const out = [];
+  let seg = 0;
+  for (let j = 0; j <= spans; j++) {
+    const target = (j / spans) * total;
+    while (seg < M - 1 && cum[seg + 1] < target) seg++;
+    const a = dense[seg], b = dense[seg + 1];
+    const w = (target - cum[seg]) / (cum[seg + 1] - cum[seg] || 1);
+    out.push([a[0] + (b[0] - a[0]) * w, a[1] + (b[1] - a[1]) * w]);
+  }
+  out[0] = [pts[0][0], pts[0][1]];
+  out[spans] = [pts[pts.length - 1][0], pts[pts.length - 1][1]];
+  return out;
+}
+
+// Exact 4-point inversion: a CR span is a cubic, so sampling it at u = 0, 1/3,
+// 2/3, 1 and inverting the Bernstein matrix reproduces it with no approximation
+// (spec §3). Endpoints are written from the actual ring vertices so the contour
+// interpolates them bit-exactly.
+function invertSpan(S0, S1, S2, S3) {
+  return {
+    to: [S3[0], S3[1]],
+    c1: [(-5 * S0[0] + 18 * S1[0] - 9 * S2[0] + 2 * S3[0]) / 6, (-5 * S0[1] + 18 * S1[1] - 9 * S2[1] + 2 * S3[1]) / 6],
+    c2: [(2 * S0[0] - 9 * S1[0] + 18 * S2[0] - 5 * S3[0]) / 6, (2 * S0[1] - 9 * S1[1] + 18 * S2[1] - 5 * S3[1]) / 6],
+  };
+}
+
+// Fit the ring's smooth outline (closed periodic CR, or corner-clamped open CR
+// arcs) back to an all-cubic contour IR — one segment per vertex, explicitly
+// closed. `corners` are sorted output vertex indices with corner 0 at index 0.
+export function fitBezierRing(pts, corners = []) {
+  const V = pts.length;
+  const segments = [];
+  const emitSpan = (p0, p1, p2, p3) => {
+    const t0 = 0;
+    const t1 = t0 + Math.max(Math.sqrt(dist(p0, p1)), 1e-6);
+    const t2 = t1 + Math.max(Math.sqrt(dist(p1, p2)), 1e-6);
+    const t3 = t2 + Math.max(Math.sqrt(dist(p2, p3)), 1e-6);
+    const at = (u) => crPoint(p0, p1, p2, p3, t0, t1, t2, t3, t1 + (t2 - t1) * u);
+    segments.push(invertSpan([p1[0], p1[1]], at(1 / 3), at(2 / 3), [p2[0], p2[1]]));
+  };
+  if (corners.length === 0) {
+    for (let i = 0; i < V; i++)
+      emitSpan(pts[(i - 1 + V) % V], pts[i], pts[(i + 1) % V], pts[(i + 2) % V]);
+  } else {
+    for (let j = 0; j < corners.length; j++) {
+      const arc = arcPoints(pts, corners, j);
+      const A = arc.length;
+      const ctrl = [reflectPt(arc[0], arc[1]), ...arc, reflectPt(arc[A - 1], arc[A - 2])];
+      for (let i = 1; i < A; i++) emitSpan(ctrl[i - 1], ctrl[i], ctrl[i + 1], ctrl[i + 2]);
+    }
+  }
+  segments[segments.length - 1].to = [pts[0][0], pts[0][1]]; // exact explicit closure
+  return { start: [pts[0][0], pts[0][1]], segments };
+}
+
+// Cyclic slice of a ring from corner j to corner j+1, both endpoints included.
+function arcPoints(pts, corners, j) {
+  const N = pts.length, m = corners.length;
+  const a = corners[j], b = corners[(j + 1) % m];
+  const out = [];
+  for (let k = a; ; k = (k + 1) % N) {
+    out.push(pts[k]);
+    if (k === b && out.length > 1) break;
+  }
+  return out;
+}
+
+// Reconcile all sections to a shared vertex count: samples spans apportioned
+// among the m corner-delimited arcs by mean arc-length fraction (largest
+// remainder, ties to the lower arc index, minimum 1 span per arc — spec §2).
+function reconcile(resolved, V) {
+  const m = resolved[0].corners.length;
+  for (let i = 1; i < resolved.length; i++)
+    if (resolved[i].corners.length !== m)
+      throw new Error(
+        `loftSmooth: every section must have the same corner count — section ${i} has ${resolved[i].corners.length}, section 0 has ${m}`);
+  if (m === 0)
+    return { rings: resolved.map((r) => resampleClosedSpline(r.pts2d, V)), corners: [] };
+  const V2 = Math.max(V, m);
+  const arcs = resolved.map((r) => Array.from({ length: m }, (_, j) => arcPoints(r.pts2d, r.corners, j)));
+  const fracs = Array.from({ length: m }, () => 0);
+  for (const sectionArcs of arcs) {
+    const lens = sectionArcs.map((a) => polyLen(openArcDense(a)));
+    const perim = lens.reduce((a, b) => a + b, 0);
+    for (let j = 0; j < m; j++) fracs[j] += lens[j] / perim;
+  }
+  for (let j = 0; j < m; j++) fracs[j] /= resolved.length;
+  const extra = V2 - m;
+  const exact = fracs.map((f) => extra * f);
+  const alloc = exact.map(Math.floor);
+  let left = extra - alloc.reduce((a, b) => a + b, 0);
+  const order = exact.map((e, j) => [e - alloc[j], j]).sort((p, q) => q[0] - p[0] || p[1] - q[1]);
+  for (let j = 0; j < left; j++) alloc[order[j][1]]++;
+  const spans = alloc.map((a) => a + 1);
+  const rings = arcs.map((sectionArcs) =>
+    sectionArcs.flatMap((arcPts2, j) => resampleOpenArc(arcPts2, spans[j]).slice(0, -1)));
+  const corners = [];
+  let acc = 0;
+  for (let j = 0; j < m; j++) { corners.push(acc); acc += spans[j]; }
+  return { rings, corners };
+}
+
 /**
  * Densify sparse control sections into a ring list for k.loft.
  * @param {Array} sections  loft-style ring specs ({polygon|sides+radius, z, rotate?, scale?});
- *                          vertex counts may differ between sections.
- * @param {{stations?: number|"controls", samples?: number}} opts
- *   stations — output ring count along the spine (default 8 per span + 1, ≥ 2;
- *     raised to the section count when lower; every control knot is always emitted).
- *     The string "controls" skips cross-station interpolation entirely and emits
- *     one ring per control section at its own z — the B-rep path, where the
- *     backend's native smooth loft (`ruled: false`) does the skinning through
- *     exact wires and only the around-ring reconciliation is needed;
- *   samples  — output vertex count around each ring (default max(64, largest section)).
- * @returns {Array<{polygon: number[][], z: number}>}
+ *                          vertex counts may differ between sections. Point arrays may
+ *                          carry sharp:[indices]; curve contours/Shape2D sections carry
+ *                          corners implicitly.
+ * @param {{stations?: number|"controls", samples?: number, closed?: boolean}} opts
+ *   stations — output ring count along the spine (default 8 per span + 1 open,
+ *     8 per section closed; ≥ 2; raised to the section count when lower; every
+ *     control knot is always emitted). The string "controls" skips cross-station
+ *     interpolation entirely and emits one ring per control section at its own z
+ *     — the B-rep path, where the backend's native smooth loft (`ruled: false`)
+ *     does the skinning through exact wires and only the around-ring
+ *     reconciliation is needed; incompatible with closed:true;
+ *   samples  — output vertex count around each ring (default max(64, largest section));
+ *   closed   — periodic spine: the spline wraps from the last control section back
+ *     to the first (no duplicate ring at the wrap point), needs ≥ 3 sections.
+ * @returns {Array<{polygon: {start, segments}, z: number}>}
  */
-export function smoothLoftRings(sections, { stations, samples } = {}) {
+export function smoothLoftRings(sections, { stations, samples, closed = false } = {}) {
   const resolved = resolveSections(sections);
   const n = resolved.length;
-  const S = stations ?? (n - 1) * 8 + 1;
+  if (closed && stations === "controls")
+    throw new Error('loftSmooth: closed:true cannot combine with stations:"controls"');
+  if (closed && n < 3) throw new Error("loftSmooth: closed:true needs at least 3 control sections");
+  const S = stations ?? (closed ? n * 8 : (n - 1) * 8 + 1);
   const V = samples ?? Math.max(64, ...resolved.map((r) => r.pts2d.length));
   if (stations !== "controls" && !(Number.isFinite(S) && S >= 2 && S <= 1024))
     throw new Error('loftSmooth: stations must be 2…1024 (or "controls")');
   if (!(Number.isFinite(V) && V >= 8 && V <= 2048)) throw new Error("loftSmooth: samples must be 8…2048");
 
-  // 1. Reconcile every section to V vertices on its smooth closed outline.
-  const rings = resolved.map((r) => resampleClosedSpline(r.pts2d, V));
+  // 1. Reconcile every section to a shared vertex count on its smooth closed
+  //    outline — around each corner-delimited arc when corners are present,
+  //    or the whole closed spline (v1-identical) when m = 0.
+  const { rings, corners } = reconcile(resolved, V);
+  const VOut = rings[0].length; // V raised to the corner count when larger
   if (stations === "controls")
-    return resolved.map((r, i) => ({ polygon: rings[i], z: r.z }));
+    return resolved.map((r, i) => ({ polygon: fitBezierRing(rings[i], corners), z: r.z }));
 
   // 2. Shared across-station knots from the centroid spine (chord length in
   //    centroid-xy + z space). Shared knots ⇒ planar output rings (see header).
   const spine = resolved.map((r, i) => {
     let cx = 0, cy = 0;
     for (const [x, y] of rings[i]) { cx += x; cy += y; }
-    return [cx / V, cy / V, r.z];
+    return [cx / VOut, cy / VOut, r.z];
   });
   const knots = [0];
   for (let i = 1; i < n; i++)
     knots.push(knots[i - 1] + Math.max(Math.hypot(
       spine[i][0] - spine[i - 1][0], spine[i][1] - spine[i - 1][1], spine[i][2] - spine[i - 1][2]), 1e-6));
+  if (closed)
+    knots.push(knots[n - 1] + Math.max(Math.hypot(
+      spine[0][0] - spine[n - 1][0], spine[0][1] - spine[n - 1][1], spine[0][2] - spine[n - 1][2]), 1e-6));
 
-  // Reflection phantoms clamp the ends: the curve passes through ring 0 and ring
-  // n−1 exactly, with a natural-looking end tangent.
+  // Reflection phantoms clamp the ends (open mode): the curve passes through
+  // ring 0 and ring n−1 exactly, with a natural-looking end tangent. Closed mode
+  // instead wraps every accessor modulo n — no phantoms, no clamping.
   const reflect = (a, b) => [2 * a[0] - b[0], 2 * a[1] - b[1]];
-  const knotAt = (i) => { // phantom knots mirror the end spacing
+  const wrap = (i) => ((i % n) + n) % n;
+  const knotAt = (i) => { // phantom/periodic knots mirror the end spacing
+    if (closed) {
+      if (i < 0) return knots[0] - (knots[n] - knots[n - 1]);
+      if (i > n) return knots[n] + (knots[1] - knots[0]);
+      return knots[i];
+    }
     if (i < 0) return knots[0] - (knots[1] - knots[0]);
     if (i >= n) return knots[n - 1] + (knots[n - 1] - knots[n - 2]);
     return knots[i];
   };
   const ptAt = (j, i) => {
+    if (closed) return rings[wrap(i)][j];
     if (i < 0) return reflect(rings[0][j], rings[1][j]);
     if (i >= n) return reflect(rings[n - 1][j], rings[n - 2][j]);
     return rings[i][j];
   };
   const zCtrl = (i) => {
+    if (closed) return resolved[wrap(i)].z;
     if (i < 0) return 2 * resolved[0].z - resolved[1].z;
     if (i >= n) return 2 * resolved[n - 1].z - resolved[n - 2].z;
     return resolved[i].z;
@@ -163,38 +382,41 @@ export function smoothLoftRings(sections, { stations, samples } = {}) {
   //    remainder apportionment; ties to the lower index — deterministic), so each
   //    control section appears as an actual output ring, not just a point the
   //    underlying spline passes through. `stations` below the section count is
-  //    raised to it (the knots alone already cost n rings).
-  const tEnd = knots[n - 1];
+  //    raised to it (the knots alone already cost n rings). Closed mode has one
+  //    more span than open mode (the wrap chord back to control 0) and never
+  //    re-emits the final knot — it would duplicate ring 0.
+  const spanCount = closed ? n : n - 1;
+  const tEnd = knots[closed ? n : n - 1];
   const S2 = Math.max(S, n);
   const extra = S2 - n;
   const spans = [];
-  for (let i = 0; i < n - 1; i++) spans.push(knots[i + 1] - knots[i]);
+  for (let i = 0; i < spanCount; i++) spans.push(knots[i + 1] - knots[i]);
   const exact = spans.map((len) => (extra * len) / tEnd);
   const alloc = exact.map(Math.floor);
   let left = extra - alloc.reduce((a, b) => a + b, 0);
   const order = exact.map((e, i) => [e - alloc[i], i]).sort((p, q) => q[0] - p[0] || p[1] - q[1]);
   for (let j = 0; j < left; j++) alloc[order[j][1]]++;
   const ts = [];
-  for (let i = 0; i < n - 1; i++) {
+  for (let i = 0; i < spanCount; i++) {
     ts.push(knots[i]);
     for (let m = 1; m <= alloc[i]; m++) ts.push(knots[i] + (spans[i] * m) / (alloc[i] + 1));
   }
-  ts.push(tEnd);
+  if (!closed) ts.push(tEnd);
 
   // 4. Evaluate the stations. z uses the same segment/knots as every vertex,
   //    evaluated once per station (1-D Barry–Goldman via crPoint).
   const out = [];
   for (const t of ts) {
     let seg = 0; // segment index: t ∈ [knots[seg], knots[seg+1]]
-    while (seg < n - 2 && t > knots[seg + 1]) seg++;
-    const t0 = knotAt(seg - 1), t1 = knots[seg], t2 = knots[seg + 1], t3 = knotAt(seg + 2);
+    while (seg < (closed ? n - 1 : n - 2) && t > knots[seg + 1]) seg++;
+    const t0 = knotAt(seg - 1), t1 = knots[seg], t2 = knotAt(seg + 1), t3 = knotAt(seg + 2);
     const z1d = (a, b, c, d) =>
       crPoint([a, 0], [b, 0], [c, 0], [d, 0], t0, t1, t2, t3, t)[0];
     const z = z1d(zCtrl(seg - 1), zCtrl(seg), zCtrl(seg + 1), zCtrl(seg + 2));
     const polygon = [];
-    for (let j = 0; j < V; j++)
+    for (let j = 0; j < VOut; j++)
       polygon.push(crPoint(ptAt(j, seg - 1), ptAt(j, seg), ptAt(j, seg + 1), ptAt(j, seg + 2), t0, t1, t2, t3, t));
-    out.push({ polygon, z });
+    out.push({ polygon: fitBezierRing(polygon, corners), z });
   }
   return out;
 }

package/src/framework/geometry/op-options.js

@@ -280,7 +280,7 @@ export const KERNEL_OP_SPECS = {
     },
   },
   // loftSmooth: range checks live in loft-smooth.js, next to the defaults they guard.
-  loftSmooth: { toArgs: passThrough("loftSmooth", ["sections", "stations", "samples", "shading"], ["sections"]) },
+  loftSmooth: { toArgs: passThrough("loftSmooth", ["sections", "stations", "samples", "shading", "closed"], ["sections"]) },
   roundedBox:      { toArgs: roundedBoxArgs },
   roundedCylinder: { toArgs: roundedCylinderArgs },
   torus:           { toArgs: torusArgs },

package/src/parts/propeller.js

@@ -1,8 +1,9 @@
 // The k.loftSmooth reference part: a boat propeller — bored hub + N airfoil
 // blades, each blade a spline-interpolated loft of 5 sparse control sections.
 // The "Surface" section keeps the didactic A/B: untick **Smooth** to see the raw
-// k.loft of the same control sections. Spec:
+// k.loft of the same control sections. Specs:
 // docs/superpowers/specs/2026-08-24-loft-smooth-design.md
+// docs/superpowers/specs/2026-08-25-loft-smooth-v2-design.md
 
 // NACA-4-ish airfoil contour, closed and CCW, centered near the quarter chord so
 // per-ring `rotate` twists about a sensible pitch axis. `n` points per surface;
@@ -35,6 +36,16 @@ const bladeSections = (p) =>
       p.camber,
       p.sectionPts,
     ),
+    // The trailing edge is the ring's two end vertices (upper TE vertex 0, lower
+    // TE the last) — this NACA closure (coefficient -0.1036) already brings them
+    // together at the same point, so the "gap" between them is a genuine zero-
+    // length edge, not a blunt base. Tagging vertex 0 as the single corner keeps
+    // that meeting point a crease instead of letting the CR spline round it off;
+    // a *second* tag at the last vertex would mark a zero-length arc between two
+    // coincident corners, which — after the per-section pitch `rotate` below
+    // collapses their sub-epsilon separation to bit-identical floats — the
+    // resampler rejects as a zero-perimeter section.
+    ...(p.sharpTE && p.smooth ? { sharp: [0] } : {}),
     z: p.span * t,
     rotate: p.twistRoot + (p.twistTip - p.twistRoot) * t,
   }));
@@ -67,10 +78,12 @@ export default {
     {
       id: "surface",
       title: "Surface",
-      description: "**Smooth** interpolates the 5 sparse control sections with `loftSmooth`; off shows the raw `k.loft` of the same sections. **Stations/Samples** are the densifier resolution; **Section points** is how sparse the control sections are.",
+      description: "**Smooth** interpolates the 5 sparse control sections with `loftSmooth`; off shows the raw `k.loft` of the same sections. **Sharp trailing edge** tags the TE vertex as a crease instead of letting the spline smear it. **Stations/Samples** are the densifier resolution; **Section points** is how sparse the control sections are.",
       controls: [
         { key: "smooth", type: "checkbox", label: "Smooth (loftSmooth)",
           description: "A/B toggle: spline-densified vs raw loft of identical control sections." },
+        { key: "sharpTE", type: "checkbox", label: "Sharp trailing edge", when: { smooth: 1 },
+          description: "Tags the trailing-edge vertex as a true corner — the spline interpolates it with a crease instead of smearing it round." },
         { key: "stations", label: "Stations", min: 5, max: 128, step: 1, when: { smooth: 1 } },
         { key: "samples", label: "Samples / ring", min: 16, max: 512, step: 4, when: { smooth: 1 } },
         { key: "sectionPts", label: "Section points", min: 6, max: 40, step: 1,
@@ -81,7 +94,7 @@ export default {
   defaults: {
     blades: 3, span: 70, rootChord: 26, tipChord: 16, twistRoot: 62, twistTip: 30,
     thickness: 12, camber: 6, hubD: 30, hubH: 26, boreD: 8,
-    smooth: 1, stations: 48, samples: 128, sectionPts: 12,
+    smooth: 1, sharpTE: 1, stations: 48, samples: 128, sectionPts: 12,
   },
   parts: {
     propeller: {

package/types/kernel.d.ts

@@ -380,15 +380,31 @@ export interface ScrewSweepOptions {
   lefthand?: boolean;
 }
 
+/** One `k.loftSmooth` control section. Point arrays may tag true corners with
+ *  `sharp`; curve contours and Shape2D outlines carry corners implicitly. */
+export interface LoftSmoothSection {
+  polygon?: Contour | Shape2D;
+  sides?: number;
+  radius?: number;
+  z: number;
+  /** Degrees about Z. */
+  rotate?: number;
+  scale?: number | Point2;
+  /** Corner indices into a point-array polygon. */
+  sharp?: number[];
+}
+
 /** k.loftSmooth — spline-interpolated loft of sparse control sections. */
 export interface LoftSmoothOptions {
   /** Sparse control sections; vertex counts may differ between sections. */
-  sections: LoftRing[];
-  /** Output ring count along the spine (default 8 per span + 1). */
+  sections: LoftSmoothSection[];
+  /** Output ring count along the spine (default 8 per span + 1; closed: 8 per section). */
   stations?: number;
   /** Output vertex count around each ring (default max(64, largest section)). */
   samples?: number;
   shading?: "smooth" | "faceted";
+  /** Capless loop — Manifold only, ≥3 sections. */
+  closed?: boolean;
 }
 
 export interface RoundedCylinderOptions {