partforge 0.83.1 → 0.84.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? })` | 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.union(solids[])` | boolean union |
 
 **`loft` rings** — each ring is `{ polygon:[[x,y],…] | sides+radius | {start,segments} | Shape2D, z, rotate?, scale? }`
@@ -349,6 +350,24 @@ 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. Sections must be point rings — vertex order and the vertex-0
+seam are how corresponding points line up across sections.
+
 **`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,20 @@ 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
+
+- **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.
+
+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-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.
+- **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).
+
 ## 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?})` | 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). |
 | `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.84.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,22 @@ 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.
+  // B-rep detection: `toSTEP` exists here only on a B-rep backend — the stub for
+  // mesh kernels is assigned later in this function.
+  const brepLoft = typeof k.toSTEP === "function";
+  k.loftSmooth ??= ({ sections, stations, samples, shading = "smooth" }) =>
+    brepLoft
+      ? k.loft({ rings: smoothLoftRings(sections, { stations: "controls", samples }), ruled: false })
+      : k.loft({ rings: smoothLoftRings(sections, { stations, samples }), shading });
+
   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}) => 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,200 @@
+// 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.
+import { isArcContour } from "./profile.js";
+
+// 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.
+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;
+    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]);
+      }
+    }
+    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]) => {
+      const X = x * sx, Y = y * sy;
+      return [X * cos - Y * sin, X * sin + Y * cos];
+    });
+    return { pts2d, 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;
+}
+
+/**
+ * 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}>}
+ */
+export function smoothLoftRings(sections, { stations, samples } = {}) {
+  const resolved = resolveSections(sections);
+  const n = resolved.length;
+  const S = stations ?? (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));
+  if (stations === "controls")
+    return resolved.map((r, i) => ({ polygon: rings[i], 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];
+  });
+  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));
+
+  // Reflection phantoms clamp the ends: the curve passes through ring 0 and ring
+  // n−1 exactly, with a natural-looking end tangent.
+  const reflect = (a, b) => [2 * a[0] - b[0], 2 * a[1] - b[1]];
+  const knotAt = (i) => { // phantom knots mirror the end spacing
+    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 (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 (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).
+  const tEnd = knots[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]);
+  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++) {
+    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);
+
+  // 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);
+    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++)
+      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 });
+  }
+  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"], ["sections"]) },
   roundedBox:      { toArgs: roundedBoxArgs },
   roundedCylinder: { toArgs: roundedCylinderArgs },
   torus:           { toArgs: torusArgs },

package/src/parts/propeller.js

@@ -0,0 +1,115 @@
+// 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:
+// docs/superpowers/specs/2026-08-24-loft-smooth-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,
+    ),
+    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. **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: "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, 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,17 @@ export interface ScrewSweepOptions {
   lefthand?: boolean;
 }
 
+/** 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). */
+  stations?: number;
+  /** Output vertex count around each ring (default max(64, largest section)). */
+  samples?: number;
+  shading?: "smooth" | "faceted";
+}
+
 export interface RoundedCylinderOptions {
   r?: number;
   d?: number;
@@ -460,6 +471,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;