partforge 0.83.1 → 0.85.0

package/docs/AUTHORING-PARTS.md

@@ -324,6 +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?, 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? }`
@@ -349,6 +350,52 @@ loft self-corrects a fully-inverted result so CW-wound or descending-z rings sti
 Multi-region or holed `Shape2D` throws — loft each region as its own solid and union the lofts, or cut holes from
 the lofted solid after it closes.
 
+**Smooth organic lofts.** When the silhouette should be a smooth curve rather
+than faceted stations, don't densify rings by hand — hand `k.loftSmooth` the
+few sections you can reason about and let it interpolate (both backends;
+`k.loft` stays the right tool for deliberate facets and exact station control):
+
+```js
+const sections = [0, 0.3, 0.6, 0.85, 1].map((t) => ({
+  polygon: airfoil(chord(t)),        // plain [[x,y],…] point rings; counts may differ
+  z: span * t,
+  rotate: pitch(t),                  // authored twist sweeps correctly — vertex j
+}));                                 // is the same material line on every section
+const blade = k.loftSmooth({ sections });
+```
+
+Raise `samples` if the cross-section shows facets, `stations` if banding runs
+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
 default or `cornerRadius` fillets. Worked snippets:

package/docs/ERROR-PATTERNS.md

@@ -497,6 +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-corner-count-mismatch
+
+- **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.
+
+## 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` 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,6 +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?, 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.83.1",
+  "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/app-propeller.js

@@ -0,0 +1,15 @@
+// Glue for the loftSmooth propeller reference part (see parts/propeller.js).
+// Dev-only: `npm run dev`, then open /propeller.html.
+import "@fontsource-variable/geist";
+import "@fontsource-variable/geist-mono";
+import part from "./parts/propeller.js";
+import { mount } from "./framework/index.js";
+
+window.__pfRuntime = mount(part, {
+  createWorker: (name) =>
+    new Worker(new URL("./propeller-worker.js", import.meta.url), { type: "module", name }),
+  onAnnotationSend: (payload) => {
+    window.__pfLastAnnotation = payload;
+    console.log("annotation payload", payload);
+  },
+});

package/src/framework/geometry/kernel-front.js

@@ -25,6 +25,7 @@ import { DEFAULT_FONT_BYTES } from "./fonts/default-font.js";
 import { convexHull, hullPoints } from "./hull.js";
 import { latheRoundedRect, torusContour } from "./rounded-solids.js";
 import { screwCrossSection } from "./screw-profile.js";
+import { smoothLoftRings } from "./loft-smooth.js";
 
 export function finishKernel(k) {
   // Compound default: bored-through cylinder (tool overshoots 2 mm each end for
@@ -55,6 +56,35 @@ export function finishKernel(k) {
       twist: (lefthand ? -360 : 360) * turns,
     });
 
+  // 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, 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, closed }), ...(shading ? { shading } : {}), closed });
+  };
+
   for (const [op, { toArgs, check }] of Object.entries(KERNEL_OP_SPECS)) {
     const raw = k[op];
     if (!raw) continue;

package/src/framework/geometry/kernel.js

@@ -23,6 +23,8 @@ export const KERNEL_OPS = [
   "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
   "loft", "sweep", "helixSweptTube", "screwSweep", "union", "shape2d", "text2d", "hull", "hullChain", "toSTEP",
   "roundedCylinder", "torus", "roundedBox", "import",
+  // Additive in 0.84 (no CONTRACT_VERSION bump — the import-op precedent).
+  "loftSmooth",
 ];
 
 // Backend-optional kernel ops: the sub-part cache brackets + WASM lifetime hooks.
@@ -147,6 +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,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

@@ -0,0 +1,422 @@
+// The k.loftSmooth densifier (see the loftSmooth row in docs/KERNEL-CONTRACT.md and
+// docs/superpowers/specs/2026-08-24-loft-smooth-design.md).
+// Shared spline densifier behind k.loftSmooth: sparse control sections in, a dense
+// ring list for k.loft out. Pure JS and backend-free, so both backends receive the
+// IDENTICAL densified station list — parity by construction, the sweep/screwSweep
+// precedent — rather than each backend interpolating its own surface.
+//
+// Interpolation is Catmull-Rom both ways:
+//   • around each ring — centripetal (α=0.5) through the section's control points,
+//     closed/periodic, resampled to a shared vertex count uniformly by arc length
+//     (centripetal because airfoil-style sections cluster points unevenly, and
+//     uniform CR overshoots on uneven chords);
+//   • across stations — through each vertex index's control polyline, with ONE
+//     shared knot vector taken from the centroid spine (centroid + z chord length).
+//     Shared knots mean every vertex's z blend is identical, so output rings stay
+//     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.
+//
+// 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. 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");
+  return sections.map((s, i) => {
+    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;
+    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 = [];
+    }
+    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);
+    let pts2d = pts.map(([x, y]) => {
+      const X = x * sx, Y = y * sy;
+      return [X * cos - Y * sin, X * sin + Y * cos];
+    });
+    // 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 };
+  });
+}
+
+// Barry–Goldman pyramid for one Catmull-Rom segment: evaluates the curve through
+// p1..p2 at knot value t ∈ [t1, t2], for arbitrary (e.g. centripetal) knots.
+function crPoint(p0, p1, p2, p3, t0, t1, t2, t3, t) {
+  const lerpP = (a, b, ta, tb) => {
+    const w = tb === ta ? 0 : (t - ta) / (tb - ta);
+    return [a[0] + (b[0] - a[0]) * w, a[1] + (b[1] - a[1]) * w];
+  };
+  const a1 = lerpP(p0, p1, t0, t1), a2 = lerpP(p1, p2, t1, t2), a3 = lerpP(p2, p3, t2, t3);
+  const b1 = lerpP(a1, a2, t0, t2), b2 = lerpP(a2, a3, t1, t3);
+  return lerpP(b1, b2, t1, t2);
+}
+
+const dist = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+
+// Closed centripetal Catmull-Rom through `pts`, resampled to `n` points uniformly
+// by arc length (measured on a dense polyline — SUB samples per control segment).
+const SUB = 8;
+export function resampleClosedSpline(pts, n) {
+  const N = pts.length;
+  const dense = [];
+  for (let i = 0; i < N; i++) {
+    const p0 = pts[(i - 1 + N) % N], p1 = pts[i], p2 = pts[(i + 1) % N], p3 = pts[(i + 2) % N];
+    // Centripetal knots (α=0.5); coincident control points get a tiny ε so the
+    // pyramid never divides by zero.
+    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));
+  }
+  // Uniform-by-arc-length resample of the dense closed polyline.
+  const M = dense.length;
+  const cum = [0];
+  for (let i = 1; i <= M; i++) cum.push(cum[i - 1] + dist(dense[i - 1], dense[i % M]));
+  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 < n; j++) {
+    const target = (j / n) * total;
+    while (cum[seg + 1] < target) seg++;
+    const a = dense[seg], b = dense[(seg + 1) % M];
+    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]);
+  }
+  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. 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, closed = false } = {}) {
+  const resolved = resolveSections(sections);
+  const n = resolved.length;
+  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 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: 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 / 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 (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 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;
+  };
+
+  // 3. Station parameter list: every control knot is always emitted, plus interior
+  //    stations distributed per span proportionally to knot length (largest-
+  //    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). 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 < 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 < spanCount; i++) {
+    ts.push(knots[i]);
+    for (let m = 1; m <= alloc[i]; m++) ts.push(knots[i] + (spans[i] * m) / (alloc[i] + 1));
+  }
+  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 < (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 < 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: fitBezierRing(polygon, corners), z });
+  }
+  return out;
+}

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

@@ -279,6 +279,8 @@ export const KERNEL_OP_SPECS = {
       if (!(o.turns > 0)) throw new Error("screwSweep: turns must be > 0");
     },
   },
+  // loftSmooth: range checks live in loft-smooth.js, next to the defaults they guard.
+  loftSmooth: { toArgs: passThrough("loftSmooth", ["sections", "stations", "samples", "shading", "closed"], ["sections"]) },
   roundedBox:      { toArgs: roundedBoxArgs },
   roundedCylinder: { toArgs: roundedCylinderArgs },
   torus:           { toArgs: torusArgs },

package/src/parts/propeller.js

@@ -0,0 +1,128 @@
+// 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. 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;
+// cosine spacing clusters points at the leading edge, which is exactly the uneven
+// spacing the centripetal densifier is supposed to handle.
+const airfoil = (chord, thickPct, camberPct, n) => {
+  const t = thickPct / 100, m = camberPct / 100, p = 0.4;
+  const yt = (x) => 5 * t * (0.2969 * Math.sqrt(x) - 0.126 * x - 0.3516 * x * x + 0.2843 * x ** 3 - 0.1036 * x ** 4);
+  const yc = (x) => (x < p ? (m / (p * p)) * (2 * p * x - x * x) : (m / ((1 - p) ** 2)) * (1 - 2 * p + 2 * p * x - x * x));
+  const upper = [], lower = [];
+  for (let i = 0; i <= n; i++) {
+    const x = (1 - Math.cos((i / n) * Math.PI)) / 2; // cosine spacing, LE→TE
+    upper.push([x, yc(x) + yt(x)]);
+    lower.push([x, yc(x) - yt(x)]);
+  }
+  // TE→LE along the top, LE→TE along the bottom; drop duplicated LE/TE points.
+  const pts = [...upper.reverse().slice(0, -1), ...lower.slice(1)];
+  return pts.map(([x, y]) => [(x - 0.3) * chord, y * chord]);
+};
+
+// Five control stations up the span: a propeller-y chord outline (widest mid-span,
+// closing toward a rounded tip) and a root→tip pitch-angle washout.
+const SPAN_T = [0, 0.3, 0.6, 0.85, 1];
+const CHORD_MUL = [1, 1.12, 1.0, 0.72, 0.28];
+const bladeSections = (p) =>
+  SPAN_T.map((t, i) => ({
+    polygon: airfoil(
+      (p.rootChord + (p.tipChord - p.rootChord) * t) * CHORD_MUL[i],
+      p.thickness * (1 - 0.45 * t), // blades thin toward the tip
+      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,
+  }));
+
+export default {
+  meta: { title: "Propeller", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "prop",
+      title: "Propeller",
+      description: "A boat propeller: bored hub + airfoil blades. The blade is the organic-surface exerciser — every surface is a `loftSmooth` of 5 sparse control sections.",
+      controls: [
+        { key: "blades", label: "Blades", min: 2, max: 6, step: 1 },
+        { key: "span", label: "Blade span", unit: "mm", min: 30, max: 120, step: 1 },
+        { key: "rootChord", label: "Root chord", unit: "mm", min: 10, max: 50, step: 1 },
+        { key: "tipChord", label: "Tip chord", unit: "mm", min: 6, max: 40, step: 1 },
+        { key: "twistRoot", label: "Root pitch", unit: "°", min: 0, max: 80, step: 1,
+          description: "Blade angle at the root. 0° puts the chord in the rotation plane." },
+        { key: "twistTip", label: "Tip pitch", unit: "°", min: 0, max: 80, step: 1 },
+        { key: "thickness", label: "Thickness", unit: "%", min: 4, max: 25, step: 1,
+          description: "Airfoil thickness as % of chord, at the root." },
+        { key: "camber", label: "Camber", unit: "%", min: 0, max: 12, step: 1 },
+        { type: "group", title: "Hub", collapsed: "auto", controls: [
+          { key: "hubD", label: "Hub diameter", unit: "mm", min: 14, max: 60, step: 1 },
+          { key: "hubH", label: "Hub length", unit: "mm", min: 10, max: 60, step: 1 },
+          { key: "boreD", label: "Shaft bore", unit: "mm", min: 2, max: 20, step: 0.5 },
+        ] },
+      ],
+    },
+    {
+      id: "surface",
+      title: "Surface",
+      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,
+          description: "Points per airfoil *surface* in each control section — the sparse input both paths share." },
+      ],
+    },
+  ],
+  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, sharpTE: 1, stations: 48, samples: 128, sectionPts: 12,
+  },
+  parts: {
+    propeller: {
+      label: "Propeller", views: ["propeller"], export: { name: "propeller" },
+      build: (k, p) => {
+        const sections = bladeSections(p);
+        const bladeUp = p.smooth
+          ? k.loftSmooth({ sections, stations: p.stations, samples: p.samples })
+          : k.loft({ rings: sections });
+        // Built span-up (+Z); lay it radial along +X — the airfoil chord then sits
+        // in the axis/rotation-plane frame, so `rotate` above reads as pitch angle.
+        // Root sinks to 62% of hub radius so the union has generous overlap.
+        const blade = bladeUp.rotateY(90).translate([p.hubD * 0.31, 0, 0]).label("Blade");
+        const blades = [];
+        for (let i = 0; i < p.blades; i++) blades.push(blade.clone().rotateZ((360 / p.blades) * i));
+        const hub = k.cylinder({ r: p.hubD / 2, h: p.hubH })
+          .translate([0, 0, -p.hubH / 2]).label("Hub")
+          .cut(k.cylinder({ r: p.boreD / 2, h: p.hubH + 4 }).translate([0, 0, -p.hubH / 2 - 2]).label("Bore"));
+        return k.union([hub, ...blades]);
+      },
+    },
+  },
+  views: { propeller: { label: "Propeller" } },
+  verify: {
+    expect: {
+      // One through-hole (the shaft bore); everything unioned into one watertight body.
+      propeller: { holes: 1, bbox: "<=[300,300,300]" },
+      _view: { overlaps: 0 },
+    },
+  },
+};

package/src/propeller-worker.js

@@ -0,0 +1,4 @@
+// Glue for the loftSmooth propeller reference part (see parts/propeller.js).
+import part from "./parts/propeller.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/types/kernel.d.ts

@@ -380,6 +380,33 @@ 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: 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 {
   r?: number;
   d?: number;
@@ -460,6 +487,8 @@ export interface GeometryKernel {
   helixSweptTube(o: HelixSweptTubeOptions): Solid;
   /** Sweep an axial lathe profile by screw motion — threads. */
   screwSweep(o: ScrewSweepOptions): Solid;
+  /** Spline-interpolated loft of sparse control sections. */
+  loftSmooth(o: LoftSmoothOptions): Solid;
   /** Rim round-overs via one lathe revolve; curve-exact in STEP. */
   roundedCylinder(o: RoundedCylinderOptions): Solid;
   torus(o: TorusOptions): Solid;