partforge 0.82.0 → 0.83.1

package/docs/AUTHORING-PARTS.md

@@ -315,7 +315,7 @@ and the detection rule.
 | `k.box({ size, center? })` · `k.box({ min, max })` | `{size:[x,y,z]}` = centered X/Y, base at z=0 (`center:true` also centers Z); `{min,max}` = explicit `[x,y,z]` corners |
 | `k.prism({ points, h, twist?, scaleTop? })` | extrude a 2-D polygon (or an **arc profile** from `roundedProfile`) from z=0; optional `twist` (degrees over the height) and `scaleTop` (uniform top taper: 1 straight, <1 taper in, 0 → point/cone) |
 | `k.extrude({ profile, h, twist?, scaleTop? })` | extrude a **polygon-with-holes** region from z=0 in one op — `profile` is `{ outer, holes? }` where each contour is a points array **or an arc profile** (`roundedProfile`, for true STEP fillets), or a bare points array / arc profile for outer-only; same `twist`/`scaleTop` as `prism` (both backends) |
-| `k.loft({ rings, ruled?, closed?, shading? })` | stack polygon cross-sections into a solid — ruled walls between consecutive rings, capped ends (both backends; `closed:true` capless loops are Manifold-only). `ruled:false` (smooth C2 blend) is honoured only by OCCT/STEP export; the Manifold preview always shows faceted straight walls. `shading?: "smooth" \| "faceted"` overrides facet/smooth shading inference (default: <32-side rings shade as flat facets, drawing no same-surface lines at all — not even their own cap rims — though cut seams against other solids still draw; ≥32 sides shade smooth) |
+| `k.loft({ rings, ruled?, closed?, shading? })` | stack polygon cross-sections into a solid — ruled walls between consecutive rings, capped ends (both backends; `closed:true` capless loops are Manifold-only). A ring's `polygon` may be a point list, `sides`+`radius`, a curve contour, or a single-region hole-free `Shape2D` (multi-region / holed shapes throw). Identical all-line rings are bit-identical on both backends (unchanged legacy). Identical curve-structure rings loft curve-natively on OCCT (STEP keeps true arcs) and facet at fixed LOD on Manifold; structurally different rings auto-resample to a common vertex count with a deterministic seam and share the same faceted STEP at sampling LOD on both backends. `ruled:false` (smooth C2 blend) is honoured only by OCCT/STEP export; the Manifold preview always shows faceted straight walls. `shading?: "smooth" \| "faceted"` overrides facet/smooth shading inference (point-ring default: <32-side rings shade as flat facets, drawing no same-surface lines at all — not even their own cap rims — though cut seams against other solids still draw; ≥32 sides shade smooth. Curve/resample rings shade by tessellation provenance — smooth only along smooth contour spans, with dividing lines at sharp corners and silhouette-kink rings; see the shading-intent note) |
 | `k.sweep({ profile, path, cornerRadius?, closed?, ruled?, smooth? })` | sweep a fixed 2-D profile along a 3-D polyline path — sharp mitered corners (or `cornerRadius` fillets), capped ends (both backends). `closed:true` capless loops and `smooth:true` (OCCT-native swept B-rep, STEP-exact / preview-faceted) are backend-specific, like loft's `closed`/`ruled:false`. `closed:true` loops must be **planar** — RMF frame-transport holonomy can seam-twist a non-planar closed loop where the last station rejoins the first, so only planar closed loops are supported/tested |
 | `k.sphere({ r\|d })` | sphere centred at the origin; bare `k.sphere(r)` also stays valid |
 | `k.roundedBox({ size, center?, round })` | box with rounded edges — `round` = number (all edges) or `{ side?, top?, bottom? }` (vertical edges / rims); built as one hand-meshed ring stack (no booleans at all, cheaper than `fillet`'s cutters); `side` must be 0 or ≥ the rim radii (between clamps with a warning); with `side > 0`, `top + bottom` must be strictly `< h` |
@@ -326,16 +326,32 @@ and the detection rule.
 | `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.union(solids[])` | boolean union |
 
-**`loft` rings** — each ring is `{ polygon:[[x,y],…] | sides+radius, z, rotate?, scale? }`
-(all rings must share the same vertex count; `rotate` is degrees about Z, `scale` is a
-number or `[sx,sy]`). Author rings CCW and ordered by ascending `z` (the `regularPolygon`
-/ `polygon.js` helpers are already CCW); loft self-corrects a fully-inverted result so
-CW-wound or descending-z rings still export a valid outward solid. (Arc profiles from
-`roundedProfile` are **not** accepted as loft rings yet — a ring must be a point array;
-use `prism`/`extrude` for true-arc STEP export.) **`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:
+**`loft` rings** — each ring is `{ polygon:[[x,y],…] | sides+radius | {start,segments} | Shape2D, z, rotate?, scale? }`
+(`rotate` is degrees about Z, `scale` is a number or `[sx,sy]`). A ring's `polygon` may be:
+- a point list `[[x,y],…]` — plain polygon
+- `{sides, radius}` — shorthand for a regular polygon
+- a curve contour `{start:[x,y], segments:[...]}` — from `roundedProfile` (true CIRCLE/CUBIC edges in STEP)
+- a single-region hole-free `Shape2D` — from a 2-D boolean, fillet, or other shape operation
+
+Rings with **identical all-line segment structure** (the same straight-sided shape at different z/scale/rotate) are
+bit-identical on both backends — unchanged legacy behavior, parity by construction. When such a ring set mixes a
+point-list ring with a Shape2D/contour-sourced one, start-vertex correspondence is not author-controlled (a Shape2D's
+contour starts wherever its outline begins) — use per-ring `rotate`, or keep every ring the same form, to control twist
+phase. Rings with **identical curve structure**
+(containing arcs/Béziers, the same shape at different z/scale/rotate) loft curve-natively on OCCT (STEP keeps exact arc
+edges), while a Manifold preview facets at fixed LOD. **Structurally different rings** (e.g. a square morphing to a circle,
+or unequal-N point lists) auto-resample to a common vertex count in shared pure-JS code, with seam = the outermost +X-ray
+crossing from each ring's centroid; use per-ring `rotate` to tune the twist phase. Every backend then lofts the identical
+resampled point rings — parity by construction on both — and STEP is faceted at the sampling LOD.
+
+Author rings CCW and ordered by ascending `z` (the `regularPolygon` / `polygon.js` helpers are already CCW);
+loft self-corrects a fully-inverted result so CW-wound or descending-z rings still export a valid outward solid.
+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.
+
+**`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:
 
 ```js
 // a square tube (extrude a region with a hole) — one op, no boolean cut
@@ -2530,10 +2546,15 @@ OCCT). Within one sub-part's build there is no per-op backend mixing.
 
 **Shading intent.** The kernel decides what shades smooth and where edge lines
 draw — spheres, cylinders and fillets are smooth by construction; boolean cut
-seams always shade hard and draw a line; a loft's facets shade flat when its
-rings have fewer than 32 sides (`shading: "smooth"|"faceted"` on `k.loft`
-overrides the inference either way). If your part previews smooth but would
-print faceted — or the reverse — set the hint rather than changing facet counts.
+seams always shade hard and draw a line; a point-ring loft's facets shade flat
+when its rings have fewer than 32 sides. A curve or resample loft shades by
+**tessellation provenance**: only wall sections that came from a smoothly
+tessellated contour span (an arc/Bézier run) shade smooth, sharp contour
+corners and silhouette-kink rings (an abrupt direction change up the stack,
+like a belly break) flat-shade and draw a dividing line, and a morph's snapped
+corners do the same. `shading: "smooth"|"faceted"` on `k.loft` overrides all of
+this either way. If your part previews smooth but would print faceted — or the
+reverse — set the hint rather than changing facet counts.
 
 > `partforge measure` reports `watertight`/`holes` as `n/a` for OCCT-run parts
 > (Manifold-only topology); `render` works on both. Filleted parts now measure on

package/docs/ERROR-PATTERNS.md

@@ -478,10 +478,25 @@ Variant literal for a curve-adjacent corner: `filletProfile: corner <i> at (<x>,
 - **Symptom:** an intentionally faceted loft (low-side-count rings) previews
   smooth-shaded, but exports/prints show flat facets.
 - **Cause:** the loft's shading policy resolved to smooth — a `shading:
-  "smooth"` hint, `ruled: false`, or rings with 32+ sides.
+  "smooth"` hint, `ruled: false`, rings with 32+ sides, or (for curve/resample
+  rings) the smooth-shaded section came from a smoothly tessellated contour
+  span — arcs/Béziers shade smooth per SECTOR, while sharp corners and
+  silhouette-kink rings flat-shade with a dividing line.
 - **Fix:** pass `shading: "faceted"` to `k.loft` (or drop the smooth-implying
   option) per [AUTHORING-PARTS.md](AUTHORING-PARTS.md) shading-intent note.
 
+## loft-ring-multi-region-shape2d
+
+- **Symptom:** `loft: ring 0 is a Shape2D with 2 regions — a loft ring must be a single closed outline (union the regions into one, or loft each separately)`
+- **Cause:** the Shape2D handed to a loft ring holds several disjoint outlines (usually the result of a union that never overlapped).
+- **Fix:** loft each region as its own solid and union the lofts, or rebuild the profile so the outlines actually merge into one. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Geometry: the kernel / `Solid` API" (`loft` rings).
+
+## loft-ring-has-holes
+
+- **Symptom:** `loft: ring 0 has holes — loft rings must be hole-free outlines (cut the holes from the lofted solid instead)`
+- **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).
+
 ## 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

@@ -284,7 +284,7 @@ above. All ops return a `Solid`.
 | `prism({points, h, twist?, scaleTop?})` | Extrude one CCW contour (point list or arc profile) from z = 0. `twist` = total degrees over the height; `scaleTop` = uniform top scale (1 straight, 0 → apex). |
 | `extrude({profile, h, twist?, scaleTop?, bevel?})` | Same, for a polygon-with-holes region — `profile` is `{outer, holes?}` (bare contour = outer only) — in one op, no per-hole boolean. `profile` may also be a `Shape2D` (see below). `bevel` (number = both rims, `{bottom?, top?}` = per rim) cuts a 45° rim bevel; it desugars at the shared front into extrude + loft + intersect/cut, so it is backend-identical by construction and is **not** a CAD-only op (no OCCT routing). Every profile form works — point array, arc profile, `{outer, holes}` (hole rims flare outward), or `Shape2D` (multi-region bevels each and unions) — but curved profiles are **materialized to point rings** first, so a beveled extrusion is faceted at the sampling LOD even in STEP (arc contours at a fixed pure-JS LOD, backend-identical; a `Shape2D` at its backend's own LOD — `hull`'s parity class). No `twist`/`scaleTop`, and `bottom + top < h` or it throws; a bevel a rim's narrow features cannot take is deterministically reduced with a console warning (`ERROR-PATTERNS.md#extrude-bevel-reduced`). |
 | `revolve({profile, degrees?})` | Revolve a lathe profile `[[r, z], …]` (r ≥ 0) about Z; `degrees` < 360 gives a capped partial revolve. Default 360. |
-| `loft({rings, ruled?, closed?})` | Stack polygon cross-sections (per-ring `z`/`rotate`/`scale`, equal vertex counts) with ruled walls and capped ends. Must self-correct a fully inverted result (CW rings / descending z) to an outward solid. |
+| `loft({rings, ruled?, closed?})` | Stack cross-sections along Z with ruled walls and capped ends (per-ring `z`/`rotate`/`scale`). A ring's `polygon` may be a point list, `sides`+`radius`, a curve contour, or a single-region hole-free `Shape2D` (multi-region / holed shapes throw). Rings with **identical all-line segment structure** (one straight-sided shape reused at different z/scale/rotate) loft **bit-identically** on both backends — parity by construction, unchanged legacy behavior. Rings with **identical curve structure** (containing arcs or Béziers, the same shape at different z/scale/rotate) loft curve-natively on a B-rep kernel — STEP keeps exact arc edges — while a mesh kernel facets the same sections at a fixed LOD (`hull`'s parity class). **Structurally different rings** (a rounded square morphing to a circle, unequal-N point lists) are arc-length-resampled once, in shared pure-JS code, to a common vertex count with a deterministic seam (the outermost +X-ray crossing from each ring's centroid; per-ring `rotate` tunes the phase) and snapped corners — every backend then lofts the **identical** resampled point rings, so the result is parity **by construction** and STEP is faceted at the sampling LOD. Must self-correct a fully inverted result (CW rings / descending z) to an outward 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). |
@@ -309,7 +309,10 @@ mesh backends** (Manifold); B-rep kernels throw a plain `Error` naming the limit
 `smooth: true` (native swept B-rep) are honored only by B-rep kernels; mesh kernels
 render the ruled form. `sweep` `closed: true` loops must be planar. Where both backends build the same
 shape they do it **by construction, not by tolerance**: sweep elbows loft the identical
-station list (`sweep.js`) on both backends.
+station list (`sweep.js`), and structurally-different loft rings loft the identical resampled ring list
+(`loft-rings.js`) on both backends. Structurally-identical all-line rings remain bit-identical on both backends
+(unchanged legacy behavior). Structurally-identical curve rings are the exception by design: the B-rep kernel keeps the
+exact curves (STEP-exact) while a mesh kernel facets them — `hull`'s parity class.
 
 ### Rounded primitives
 
@@ -386,11 +389,20 @@ are present:
   filtered out; Manifold ships policy-gated sharp/seam segments.
 
 `loft` accepts `shading?: "smooth" | "faceted"` to override facet-vs-smooth
-inference: by default, rings with fewer than 32 sides shade as intentional flat
-facets with no same-surface edge lines, while rings with 32+ sides (and
-`ruled: false` lofts) shade smooth. `shading: "smooth"` forces smooth shading;
-`shading: "faceted"` forces facets; any other non-nullish value throws.
-Thresholds live in `src/framework/geometry/shading-policy.js`.
+inference. Point-list (poly-exact) lofts infer as before: rings with fewer than
+32 sides shade as intentional flat facets with no same-surface edge lines, while
+rings with 32+ sides (and `ruled: false` lofts) shade smooth. Curve and resample
+lofts shade by **tessellation provenance** instead of a single whole-solid
+policy: the walls partition into shading sectors split at sharp contour joints
+(and at snapped corners in a resample morph), and into band groups split at
+silhouette-kink rings (wall direction bending more than the 5° tangent bar —
+the same bar at which a B-rep loft's real ring edges draw lines). Sector and
+band-group boundaries flat-shade and draw dividing lines regardless of bend
+angle; only sectors whose facets come from smoothly tessellated curve spans
+shade smooth inside. `shading: "smooth"` forces whole-solid smooth shading;
+`shading: "faceted"` forces facets — either hint bypasses sectoring entirely;
+any other non-nullish value throws. Thresholds live in
+`src/framework/geometry/shading-policy.js`.
 
 Known limitation: the OCCT backend ignores `shading` — a loft forced to OCCT
 via `meta.backend` draws its facet corner edges as B-rep feature lines. The
@@ -401,7 +413,11 @@ collapses it to a single shading surface that inherits the majority policy of
 its registered constituent surfaces, weighted by triangle count. A constituent
 with no registered policy of its own (e.g. a plain boolean tool) still votes,
 as SMOOTH — the policy it actually renders with — and an exact tie resolves to
-the no-lines (faceted) policy.
+the no-lines (faceted) policy. Two exceptions preserve their surface partition
+through labeling instead of collapsing: fillet/chamfer blend bands (base +
+blend re-stamp as two surfaces), and provenance-sectored lofts (every sector
+and band-group run re-stamps 1:1) — in both cases all the resulting surfaces
+carry the one label, so hover/pick still reads a single feature.
 
 **Selectors** (`fillet`/`chamfer` `edges` selector, `shell` `open` face selector) are
 declarative objects, criteria AND-combined:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.82.0",
+  "version": "0.83.1",
   "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-lofted-bottle.js

@@ -0,0 +1,22 @@
+// Self-hosted Geist + Geist Mono for the dev demos, so a standalone forge looks
+// like the product. Dev-only: --pf-sans/--pf-mono fall back to system stacks for
+// any consumer that doesn't load them (spec §2.2).
+import "@fontsource-variable/geist";
+import "@fontsource-variable/geist-mono";
+import loftedBottlePart from "./parts/lofted-bottle.js";
+import { mount } from "./framework/index.js";
+
+// Dev-only example app for the lofted-bottle part (the Shape2D-loft reference part).
+// Identical wiring to app.js — the only thing that differs per part is which definition
+// you import and which worker entry you point at. `npm run dev`, then open
+// /lofted-bottle.html.
+// Dev-only: the handle is stashed on window so scripts/check-app.mjs can drive
+// the embedding contract (runtime.captureCurrent) the way an embedder would.
+window.__pfRuntime = mount(loftedBottlePart, {
+  createWorker: (name) =>
+    new Worker(new URL("./lofted-bottle-worker.js", import.meta.url), { type: "module", name }),
+  onAnnotationSend: (payload) => {
+    window.__pfLastAnnotation = payload;
+    console.log("annotation payload", payload);
+  },
+});

package/src/framework/geometry/kernel.js

@@ -142,7 +142,7 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(o:{size?:number[],center?:boolean,min?:number[],max?:number[]}) => Solid} box   {size} = centered X/Y, base z=0 ({center:true} centers Z too) or {min,max}; legacy (min,max) accepted for now (see file header)
  * @property {(o:{points:number[][],h:number,twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0; legacy (points,h,opts) accepted for now (see file header)
  * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   polygon-with-holes region from z=0; bevel = 45° rim bevel (any profile form incl. Shape2D, materialized to point rings; no twist/scaleTop); legacy (profile,h,opts) accepted for now (see file header)
- * @property {(o:{rings:{polygon?:number[][],sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[],ruled?:boolean,closed?:boolean,shading?:"smooth"|"faceted"}) => Solid} loft   stack polygon cross-sections; shading overrides facet-vs-smooth shading inference; legacy (rings,opts) accepted for now (see file header)
+ * @property {(o:{rings:{polygon?:number[][]|{start:number[],segments:object[]}|Shape2D,sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[],ruled?:boolean,closed?:boolean,shading?:"smooth"|"faceted"}) => Solid} loft   stack polygon cross-sections; polygon accepts point lists, curve contours, or hole-free Shape2D; shading overrides facet-vs-smooth shading inference; legacy (rings,opts) accepted for now (see file header)
  * @property {(o:{profile:number[][],path:number[][],closed?:boolean,cornerRadius?:number,ruled?:boolean,smooth?:boolean}) => Solid} sweep   sweep a 2-D profile along a 3-D polyline; legacy (profile,path,opts) accepted for now (see file header)
  * @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

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

@@ -0,0 +1,377 @@
+// Shared Shape2D/curve-aware loft ring resolution — the pure-JS leaf both backends
+// call before touching a kernel. Lifts every accepted ring form to the curve-contour
+// IR, bakes each ring's scale-then-rotate(Z) transform ONCE, and classifies the loft
+// into one of three modes (see docs/superpowers/plans/2026-08-23-shape2d-loft-design.md):
+//   poly-exact — all-line identical signatures: today's path, bit-for-bit;
+//   curve      — identical signatures with arcs/cubics: matched per-segment sampling
+//                (Manifold) + original curve wires (OCCT, STEP-exact);
+//   resample   — structurally different rings: shared arc-length resample, both
+//                backends loft the IDENTICAL rings (parity by construction).
+import { regularPolygon } from "./polygon.js";
+import { pointsToContour, reverseContour, closeContourGap, arcGeometry, sampleBezier, tessellateContour } from "./profile.js";
+import { rotateProfile, scaleProfile, contourIsCCW, cubicAt, profileCorners } from "./contour-ops.js";
+import { SMOOTH_SIDES_MIN } from "./shading-policy.js";
+
+export const LOFT_SEGS = 64; // fixed pure-JS LOD for curve rings (hull.js precedent)
+
+const isPointList = (x) => Array.isArray(x) && Array.isArray(x[0]);
+const isContour = (x) => x && !Array.isArray(x) && Array.isArray(x.segments);
+
+// Legacy transform bake for point rings — EXACTLY resolveRings' math, kept verbatim so
+// every existing part's loft stays bit-identical (mesh-fillet tools, rim-bevel, roundedBox).
+const bakePts = (pts, r) => {
+  const s = r.scale ?? 1;
+  const [sx, sy] = Array.isArray(s) ? s : [s, s];
+  const rot = ((r.rotate ?? 0) * Math.PI) / 180, cos = Math.cos(rot), sin = Math.sin(rot);
+  return pts.map(([x, y]) => {
+    const X = x * sx, Y = y * sy;
+    return [X * cos - Y * sin, X * sin + Y * cos];
+  });
+};
+
+// Contour bake: scale about origin then rotate about origin — the same composite map,
+// applied through contour-ops so arcs survive similarity maps exactly and become
+// cubics under non-uniform scale (transformContour's rule).
+const bakeContour = (contour, r) => {
+  let c = closeContourGap(contour); // Ensure explicit closing so signature is consistent
+  const s = r.scale ?? 1;
+  if (!(s === 1 || (Array.isArray(s) && s[0] === 1 && s[1] === 1))) c = scaleProfile(c, s, [0, 0]);
+  if ((r.rotate ?? 0) !== 0) c = rotateProfile(c, r.rotate, [0, 0]);
+  return contourIsCCW(c) ? c : reverseContour(c);
+};
+
+export function liftLoftRings(rings) {
+  if (!Array.isArray(rings) || rings.length < 2)
+    throw new Error("loft: rings must be an array of at least 2 rings");
+  return rings.map((r, i) => {
+    if (!r || typeof r !== "object") throw new Error(`loft: ring ${i} must be an object { polygon|sides+radius, z }`);
+    if (!Number.isFinite(r.z)) throw new Error(`loft: ring ${i} needs a finite z`);
+    let poly = r.polygon;
+    if (poly && poly._shape2d) {
+      const regions = poly._regions;
+      if (regions.length === 0) throw new Error(`loft: ring ${i} is an empty Shape2D — nothing to loft`);
+      if (regions.length > 1) throw new Error(
+        `loft: ring ${i} is a Shape2D with ${regions.length} regions — a loft ring must be a single closed outline (union the regions into one, or loft each separately)`);
+      if (regions[0].holes.length > 0) throw new Error(
+        `loft: ring ${i} has holes — loft rings must be hole-free outlines (cut the holes from the lofted solid instead)`);
+      poly = JSON.parse(JSON.stringify(regions[0].outer));
+    }
+    if (!poly && Number.isFinite(r.sides) && Number.isFinite(r.radius)) poly = regularPolygon(r.sides, r.radius);
+    if (isContour(poly)) {
+      const contour = bakeContour(poly, r);
+      const allLines = contour.segments.every((s) => !s.via && !s.c1);
+      if (allLines && contour.segments.length < 3)
+        throw new Error(`loft: ring ${i}'s contour has only ${contour.segments.length} line segment(s) — an all-line contour needs at least 3 to close a polygon (a curved contour, e.g. a circle, may legitimately have fewer)`);
+      return { raw: r, contour, pts: null, z: r.z };
+    }
+    if (!isPointList(poly) || poly.length < 3)
+      throw new Error(`loft: ring ${i} needs polygon:[[x,y],…] (≥3 points), a curve contour, a Shape2D, or sides+radius shorthand`);
+    const pts = bakePts(poly, r);
+    return { raw: r, contour: bakeContour(pointsToContour(poly), r), pts, z: r.z };
+  });
+}
+
+const signatureOf = (contour) => contour.segments.map((s) => (s.c1 ? "C" : s.via ? "A" : "L")).join("");
+
+export function classifyLoftRings(lifted) {
+  const sigs = lifted.map((r) => signatureOf(r.contour));
+  const hasCurve = sigs.some((s) => /[AC]/.test(s));
+  const identical = sigs.every((s) => s === sigs[0]);
+  // Identical all-line signatures imply equal vertex counts (an N-point ring lifts to
+  // exactly N line segments), so this IS today's equal-N legacy case, bit-for-bit.
+  if (identical && !hasCurve) return { mode: "poly-exact", hasCurve: false };
+  if (identical) return { mode: "curve", hasCurve };
+  return { mode: "resample", hasCurve };
+}
+
+// Cache-key form of a ring list: replace live Shape2D values with their content hash
+// so h()'s canonical serializer never walks a shape's methods.
+export function loftRingsKey(rings) {
+  if (!Array.isArray(rings)) return rings;
+  return rings.map((r) => (r && typeof r === "object"
+    ? { ...r, polygon: r.polygon && r.polygon._shape2d ? "s2d:" + r.polygon._hash : r.polygon }
+    : r));
+}
+
+// Natural facet count a segment would get at LOFT_SEGS — the per-segment budget the
+// matched sampler levels up to across rings.
+const segNaturalCount = (prev, seg) => {
+  if (seg.c1) return Math.max(1, sampleBezier(prev, seg.c1, seg.c2, seg.to, LOFT_SEGS).length);
+  if (seg.via) {
+    const g = arcGeometry(prev, seg.via, seg.to);
+    return g ? Math.max(2, Math.ceil((LOFT_SEGS * Math.abs(g.dA)) / (2 * Math.PI))) : 1;
+  }
+  return 1;
+};
+
+// Sample one segment with EXACTLY n points (uniform in angle/parameter), last point
+// pinned to seg.to. Fixed counts are what keep corresponding vertices aligned across
+// rings — the adaptive samplers must not be used here.
+const sampleSegN = (prev, seg, n) => {
+  const out = [];
+  if (seg.c1) {
+    for (let s = 1; s <= n; s++) out.push(cubicAt(prev, seg.c1, seg.c2, seg.to, s / n));
+  } else if (seg.via) {
+    const g = arcGeometry(prev, seg.via, seg.to);
+    if (!g) { for (let s = 1; s <= n; s++) out.push([prev[0] + (seg.to[0] - prev[0]) * (s / n), prev[1] + (seg.to[1] - prev[1]) * (s / n)]); }
+    else for (let s = 1; s <= n; s++) {
+      const ang = g.a0 + g.dA * (s / n);
+      out.push([g.cx + g.r * Math.cos(ang), g.cy + g.r * Math.sin(ang)]);
+    }
+  } else {
+    for (let s = 1; s <= n; s++) out.push([prev[0] + (seg.to[0] - prev[0]) * (s / n), prev[1] + (seg.to[1] - prev[1]) * (s / n)]);
+  }
+  out[out.length - 1] = [seg.to[0], seg.to[1]];
+  return out;
+};
+
+// Curve mode: identical signatures guaranteed by classifyLoftRings. Per segment index,
+// every ring samples with the same count (the max natural count), so vertex i lies at
+// the same curve parameter on every ring; the seam is each contour's start.
+export function matchedTessellation(lifted) {
+  return matchedTessellationDetail(lifted).rings;
+}
+
+// Detail form: also reports the shared per-segment sample counts, which the shading
+// provenance below needs to map contour joints onto sample indices.
+function matchedTessellationDetail(lifted) {
+  const segCount = lifted[0].contour.segments.length;
+  const counts = [];
+  for (let j = 0; j < segCount; j++) {
+    let n = 1, prevs = lifted.map((r) => (j === 0 ? r.contour.start : r.contour.segments[j - 1].to));
+    lifted.forEach((r, k) => { n = Math.max(n, segNaturalCount(prevs[k], r.contour.segments[j])); });
+    counts.push(n);
+  }
+  const rings = lifted.map((r) => {
+    const ring = [[r.contour.start[0], r.contour.start[1]]];
+    let prev = r.contour.start;
+    r.contour.segments.forEach((seg, j) => { for (const p of sampleSegN(prev, seg, counts[j])) ring.push(p); prev = seg.to; });
+    // stored contours close explicitly (last segment lands on start) — drop the closure
+    ring.pop();
+    return ring;
+  });
+  return { rings, counts };
+}
+
+const shoelace = (ring) => ring.reduce((a, [x, y], i) => {
+  const [nx, ny] = ring[(i + 1) % ring.length];
+  return a + x * ny - nx * y;
+}, 0) / 2;
+
+// Deterministic seam: the outermost crossing of the +X ray from the ring's centroid.
+// Returns { edge, t } — a parametric position on the ring's edge list. Falls back to
+// all crossings of the full horizontal line, then to vertex 0, so it is total.
+const seamOf = (ring) => {
+  let cx = 0, cy = 0;
+  for (const [x, y] of ring) { cx += x; cy += y; }
+  cx /= ring.length; cy /= ring.length;
+  let best = null;
+  for (let pass = 0; pass < 2 && !best; pass++) {
+    for (let i = 0; i < ring.length; i++) {
+      const [px, py] = ring[i], [qx, qy] = ring[(i + 1) % ring.length];
+      if ((py <= cy) === (qy <= cy)) continue;            // half-open: each crossing once
+      const t = (cy - py) / (qy - py);
+      const x = px + t * (qx - px);
+      if (pass === 0 && x <= cx) continue;                // pass 0: +X ray only
+      if (!best || x > best.x) best = { edge: i, t, x };
+    }
+  }
+  return best ?? { edge: 0, t: 0, x: ring[0][0] };
+};
+
+// Arc-length resample one CCW ring to N points starting at its seam, then snap each
+// sharp corner onto its nearest sample (closest corner wins a contested sample).
+const resampleRing = (ring, N, corners) => {
+  const seam = seamOf(ring);
+  const pts = [];
+  // unroll the ring into an open polyline starting exactly at the seam point
+  const start = [ring[seam.edge][0] + seam.t * (ring[(seam.edge + 1) % ring.length][0] - ring[seam.edge][0]),
+                 ring[seam.edge][1] + seam.t * (ring[(seam.edge + 1) % ring.length][1] - ring[seam.edge][1])];
+  pts.push(start);
+  for (let k = 1; k <= ring.length; k++) {
+    const i = (seam.edge + k) % ring.length;
+    pts.push([ring[i][0], ring[i][1]]);
+  }
+  // pts is now start → all vertices → start's edge-begin; close it back to start
+  pts.push([start[0], start[1]]);
+  const cum = [0];
+  for (let i = 1; i < pts.length; i++) cum.push(cum[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));
+  const L = cum[cum.length - 1];
+  const out = [];
+  let seg = 0;
+  for (let k = 0; k < N; k++) {
+    const target = (k * L) / N;
+    while (seg < cum.length - 2 && cum[seg + 1] < target) seg++;
+    const span = cum[seg + 1] - cum[seg] || 1;
+    const t = (target - cum[seg]) / span;
+    out.push([pts[seg][0] + t * (pts[seg + 1][0] - pts[seg][0]), pts[seg][1] + t * (pts[seg + 1][1] - pts[seg][1])]);
+  }
+  // corner snapping: a sharp corner within one sample-spacing of a sample replaces it
+  // Snapshot the original sample positions before snapping, so distance calculations
+  // measure against original positions, not mutated ones (contest rule: closer corner wins)
+  const spacing = L / N;
+  const orig = out.map((p) => [p[0], p[1]]);
+  const owner = new Map();   // sample index -> snap distance
+  const ownerOf = new Map(); // corner list index -> sample index it won
+  corners.forEach((c, ci) => {
+    let bi = -1, bd = Infinity;
+    for (let i = 0; i < orig.length; i++) {
+      const d = Math.hypot(orig[i][0] - c[0], orig[i][1] - c[1]);
+      if (d < bd) { bd = d; bi = i; }
+    }
+    if (bd < spacing && (!owner.has(bi) || bd < owner.get(bi))) {
+      out[bi] = [c[0], c[1]];
+      owner.set(bi, bd);
+      for (const [k, v] of ownerOf) if (v === bi) ownerOf.delete(k); // evicted corner loses the sample
+      ownerOf.set(ci, bi);
+    }
+  });
+  return { out, ownerOf };
+};
+
+// Resample mode: every ring tessellated at the fixed LOD, resampled to a common N.
+export function resampleTessellation(lifted) {
+  return resampleTessellationDetail(lifted).rings;
+}
+
+// Detail form: also reports each ring's snapped-corner sample indices, which the
+// shading provenance below uses as sector boundaries.
+function resampleTessellationDetail(lifted) {
+  const source = lifted.map((r) => {
+    let ring = r.pts ?? tessellateContour(r.contour, LOFT_SEGS);
+    // tessellateContour of a contour returns an explicitly closed ring — drop the closure
+    if (ring.length > 1 && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1])
+      ring = ring.slice(0, -1);
+    if (shoelace(ring) < 0) ring = [...ring].reverse();
+    return ring;
+  });
+  const N = Math.max(...source.map((r) => r.length));
+  const rings = [], snapped = [];
+  lifted.forEach((r, i) => {
+    const corners = profileCorners(r.contour);
+    const res = resampleRing(source[i], N, corners.map((c) => c.point));
+    rings.push(res.out);
+    // Only SHARP corners become sector boundaries (see sharpTurn below): a
+    // polygonized circle's 7.5°-per-vertex "corners" all snap, but must not
+    // shatter the ring into per-facet sectors.
+    const sharpSet = new Set();
+    corners.forEach((c, ci) => { if (sharpTurn(c) && res.ownerOf.has(ci)) sharpSet.add(res.ownerOf.get(ci)); });
+    snapped.push(sharpSet);
+  });
+  return { rings, snapped };
+}
+
+// ── Shading provenance ──────────────────────────────────────────────────────
+// Column j is the wall strip between samples j and j+1 (wrapping). A sector is a
+// maximal run of columns between sharp contour features — sharp joints in curve
+// mode, snapped corners in resample mode — so the mesh builder (loft.js) can give
+// each sector its own shading surface. sectorSmooth[k] says whether sector k's
+// facets approximate a smooth curve (its shading policy creases gently and draws
+// no facet wireframe) or are flat/faceted geometry.
+
+// A joint is SHARP (a sector boundary) only when it turns more than a smooth
+// tessellation ever produces per facet — the same 360/SMOOTH_SIDES_MIN bar as the
+// legacy "≥32 sides reads smooth" rule. profileCorners' own 1° bar is author-intent
+// (corner ops); reusing it here would shatter a polygonized circle into sectors.
+const SHARP_TURN_DEG = 360 / SMOOTH_SIDES_MIN;
+const sharpTurn = (corner) => Math.abs(180 - corner.interiorAngleDeg) > SHARP_TURN_DEG;
+
+const sectorsFromBoundaries = (N, boundarySet) => {
+  const B = [...boundarySet].sort((a, b) => a - b);
+  const sectorOf = new Array(N).fill(0);
+  // Known limitation: a SINGLE sharp joint on an otherwise smooth ring (a teardrop
+  // cusp) cannot be expressed — one boundary yields one sector, so both sides of
+  // the cusp share a run and it shades per the sector policy (smooth if any curve).
+  // Splitting the ring artificially would draw a fake dividing line at the split
+  // (smooth facets bend > the 5° cross-run bar at LOFT_SEGS). Add a second corner,
+  // or force `shading: "faceted"`, to make a lone cusp read.
+  if (B.length > 1) {
+    for (let k = 0; k < B.length; k++) {
+      const from = B[k], to = B[(k + 1) % B.length];
+      for (let j = from; j !== to; j = (j + 1) % N) sectorOf[j] = k;
+    }
+  }
+  return sectorOf;
+};
+
+// Curve mode: sector boundaries at sharp joints (profileCorners, unioned across all
+// rings — structurally identical contours can still disagree on which joints bend).
+// A sector is smooth when any column in it samples a curved (arc/cubic) segment.
+const curveShading = (lifted, counts) => {
+  const N = counts.reduce((a, b) => a + b, 0);
+  const jointSample = [0]; // joint j (start of segment j) lands at this sample index
+  for (let j = 1; j < counts.length; j++) jointSample.push(jointSample[j - 1] + counts[j - 1]);
+  const sharp = new Set();
+  for (const r of lifted) for (const c of profileCorners(r.contour)) if (sharpTurn(c)) sharp.add(jointSample[c.index]);
+  const sectorOf = sectorsFromBoundaries(N, sharp);
+  const segSmooth = lifted[0].contour.segments.map((s) => !!(s.via || s.c1));
+  const K = Math.max(...sectorOf) + 1;
+  const sectorSmooth = new Array(K).fill(false);
+  let seg = 0;
+  for (let j = 0; j < N; j++) {
+    while (seg < counts.length - 1 && j >= jointSample[seg + 1]) seg++;
+    if (segSmooth[seg]) sectorSmooth[sectorOf[j]] = true;
+  }
+  return { sectorOf, sectorSmooth };
+};
+
+// Resample mode: sector boundaries at the union of every ring's snapped corners. A
+// sector is smooth when every interior sample on every ring turns gently — the same
+// bar as the legacy "≥ SMOOTH_SIDES_MIN sides reads smooth" rule (360/32 per facet).
+const resampleShading = (rings, snappedSets) => {
+  const N = rings[0].length;
+  const boundaries = new Set();
+  for (const s of snappedSets) for (const i of s) boundaries.add(i);
+  const sectorOf = sectorsFromBoundaries(N, boundaries);
+  const K = Math.max(...sectorOf) + 1;
+  const limit = (2 * Math.PI) / SMOOTH_SIDES_MIN;
+  const sectorSmooth = new Array(K).fill(true);
+  for (const ring of rings)
+    for (let i = 0; i < N; i++) {
+      if (boundaries.has(i)) continue; // corners split sectors; they are not interior turns
+      const p = ring[(i - 1 + N) % N], q = ring[i], r2 = ring[(i + 1) % N];
+      const ux = q[0] - p[0], uy = q[1] - p[1], vx = r2[0] - q[0], vy = r2[1] - q[1];
+      const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+      if (turn > limit) { // the kink sits AT sample i — both adjacent columns' sectors go faceted
+        sectorSmooth[sectorOf[i]] = false;
+        sectorSmooth[sectorOf[(i - 1 + N) % N]] = false;
+      }
+    }
+  return { sectorOf, sectorSmooth };
+};
+
+// Orchestrates lift -> classify -> tessellate into the single shape both backends consume:
+// resolved[i] = { pts2d, z, contour } — pts2d for Manifold's hand-mesh, contour (curve mode
+// only) for OCCT's native wire loft. See docs/superpowers/plans/2026-08-23-shape2d-loft-design.md.
+export function resolveLoftRings(rings) {
+  const lifted = liftLoftRings(rings);
+  const { mode, hasCurve } = classifyLoftRings(lifted);
+  let ptRings, shading = null;
+  if (mode === "poly-exact") {
+    // Point-list rings keep their legacy un-normalized winding for bit-exactness — UNLESS
+    // the ring set also mixes in a contour/Shape2D-sourced ring (r.pts === null), whose
+    // winding bakeContour already forced CCW. Left alone, a CW point ring paired with a
+    // CCW contour ring cancels the side walls (mixed winding) into an empty solid instead
+    // of erroring or self-correcting (loftMesh's volume<0 latch only catches a FULLY
+    // inverted mesh, not this partial cancellation) — so only in the mixed case do we
+    // also normalize each point ring to CCW here. All-point-list ring sets are untouched.
+    const mixed = lifted.some((r) => r.pts) && lifted.some((r) => !r.pts);
+    ptRings = lifted.map((r) => {
+      if (!r.pts) return matchedTessellation([r, r])[0];
+      return mixed && shoelace(r.pts) < 0 ? [...r.pts].reverse() : r.pts;
+    });
+  }
+  else if (mode === "curve") {
+    const d = matchedTessellationDetail(lifted);
+    ptRings = d.rings;
+    shading = curveShading(lifted, d.counts);
+  } else {
+    const d = resampleTessellationDetail(lifted);
+    ptRings = d.rings;
+    shading = resampleShading(d.rings, d.snapped);
+  }
+  return {
+    mode, hasCurve, shading,
+    resolved: lifted.map((r, i) => ({ pts2d: ptRings[i], z: r.z, contour: mode === "curve" ? r.contour : null })),
+  };
+}

package/src/framework/geometry/loft.js

@@ -1,76 +1,153 @@
-// Backend-shared loft support. resolveRings() validates the declarative ring specs and
-// applies each ring's in-plane transform ONCE, so both backends build the identical set
-// of placed cross-sections (Manifold hand-meshes them; OCCT turns each into a wire and
-// calls native loft). loftMesh() is the Manifold path — the helix-tube ring recipe
-// generalized to arbitrary polygon rings via the mesh-build.js helpers.
-import { regularPolygon } from "./polygon.js";
-import { isArcContour } from "./profile.js";
-import { sideQuads, fanCap, manifoldFromMesh, reverseWinding } from "./mesh-build.js";
+// Backend-shared loft support: resolveLoftRings (loft-rings.js) validates and
+// tessellates the declarative ring specs; loftMesh() is the Manifold path — stacked
+// rings stitched with side quads and closed with TRIANGULATED caps (wasm.triangulate),
+// so non-convex Shape2D rings cap correctly (the old centroid fan was star-convex-only).
+//
+// Curve/resample lofts additionally partition their triangles into RUNS carrying
+// reserved original IDs (mesh-fillet's blend-band mechanism): one run per contour
+// sector per band group, plus each cap. Sector boundaries (sharp joints, snapped
+// corners) and band-group boundaries (silhouette kinks bending more than
+// TANGENT_ANGLE — the same bar the B-rep backend draws real edges at) then shade
+// hard and draw dividing lines through creased-normals' existing cross-surface
+// rules, while each smooth sector keeps gentle crease behavior inside. Provenance
+// decides the shading; angle inference alone could not (a 10° belly kink sits far
+// below SMOOTH's 35° crease). Point-ring (poly-exact) lofts and hinted lofts keep
+// the legacy single-surface path bit-for-bit.
+import { resolveLoftRings } from "./loft-rings.js";
+import { sideQuads, manifoldFromMesh, manifoldFromMeshRuns, reverseWinding } from "./mesh-build.js";
+import { TANGENT_ANGLE, LOFT_SECTOR_SMOOTH, LOFT_SECTOR_FACETED, cosDeg } from "./shading-policy.js";
 
-// A ring: { polygon:[[x,y],…] | (sides,radius), z, rotate?:deg, scale?:number|[sx,sy] }.
-// Returns [{ pts2d:[[x,y],…], z }] with scale-then-rotate(Z) baked into pts2d. Throws
-// on malformed input and on rings whose vertex counts differ (straight quad stitching
-// needs a shared N — no re-sampling), so an LLM gets a loud, specific error.
-export function resolveRings(rings) {
-  if (!Array.isArray(rings) || rings.length < 2)
-    throw new Error("loft: rings must be an array of at least 2 rings");
-  const out = rings.map((r, i) => {
-    if (!r || typeof r !== "object") throw new Error(`loft: ring ${i} must be an object { polygon|sides+radius, z }`);
-    if (!Number.isFinite(r.z)) throw new Error(`loft: ring ${i} needs a finite z`);
-    let pts = r.polygon;
-    if (isArcContour(pts)) // arc profiles (roundedProfile) are extrude/prism-only in v1
-      throw new Error(`loft: ring ${i} is an arc profile — loft rings must be a point array (arc rings are not supported yet; use prism/extrude for true STEP arcs)`);
-    if (!pts && Number.isFinite(r.sides) && Number.isFinite(r.radius)) pts = regularPolygon(r.sides, r.radius);
-    if (!Array.isArray(pts) || pts.length < 3)
-      throw new Error(`loft: ring ${i} needs polygon:[[x,y],…] (≥3 points) or sides+radius shorthand`);
-    const s = r.scale ?? 1;
-    const [sx, sy] = Array.isArray(s) ? s : [s, s];
-    const rot = ((r.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;                 // scale in-plane, then rotate about Z
-      return [X * cos - Y * sin, X * sin + Y * cos];
-    });
-    return { pts2d, z: r.z };
-  });
-  const N = out[0].pts2d.length;
-  for (const r of out) if (r.pts2d.length !== N)
-    throw new Error("loft: every ring must have the same number of points (straight quad stitching, no re-sampling)");
-  return out;
+const shoelace = (ring) => ring.reduce((a, [x, y], i) => {
+  const [nx, ny] = ring[(i + 1) % ring.length];
+  return a + x * ny - nx * y;
+}, 0) / 2;
+
+// Triangulated end cap. Winding must stay CONSISTENT with the side walls: a CCW ring's
+// top cap faces +Z and its bottom cap −Z; a CW ring (legacy point lists — walls come
+// out inverted and the whole-mesh volume check below flips everything at once) gets
+// both caps inverted too, so the mesh is orientable either way.
+function triCap(wasm, Tr, ringStart, pts2d, bottom) {
+  const ccw = shoelace(pts2d) >= 0;
+  const ring = ccw ? pts2d : [...pts2d].reverse();
+  const tris = wasm.triangulate([ring], 1e-9);
+  const remap = (i) => ringStart + (ccw ? i : pts2d.length - 1 - i);
+  const flip = bottom !== !ccw; // XOR: see winding table in the test file
+  for (const t of tris) {
+    const a = remap(t[0]), b = remap(t[1]), c = remap(t[2]);
+    if (flip) Tr.push(a, c, b); else Tr.push(a, b, c);
+  }
 }
 
-const centroid = (pts2d, z) => {
-  let cx = 0, cy = 0;
-  for (const [x, y] of pts2d) { cx += x; cy += y; }
-  return [cx / pts2d.length, cy / pts2d.length, z];
-};
+// Interior rings where the wall direction bends more than TANGENT_ANGLE at any
+// vertex column — author-placed silhouette features, not tessellation of a smooth
+// sweep. Matches the bar at which the B-rep backend's real loft edges draw lines,
+// so the Manifold preview and an OCCT export agree on which rings read as features.
+function kinkRingsOf(resolved, closed = false) {
+  const R = resolved.length, N = resolved[0].pts2d.length;
+  const cosKink = cosDeg(TANGENT_ANGLE);
+  const kinks = new Set();
+  // open lofts bend only at interior rings; a closed loop also bends across the
+  // wrap, so rings 0 and R-1 are checked there too (their neighbors wrap modulo R)
+  for (let k = closed ? 0 : 1; k < (closed ? R : R - 1); k++) {
+    const A = resolved[(k - 1 + R) % R], B = resolved[k], C = resolved[(k + 1) % R];
+    for (let i = 0; i < N; i++) {
+      const ux = B.pts2d[i][0] - A.pts2d[i][0], uy = B.pts2d[i][1] - A.pts2d[i][1], uz = B.z - A.z;
+      const vx = C.pts2d[i][0] - B.pts2d[i][0], vy = C.pts2d[i][1] - B.pts2d[i][1], vz = C.z - B.z;
+      const lu = Math.hypot(ux, uy, uz), lv = Math.hypot(vx, vy, vz);
+      // a zero-length band (duplicated ring) has no direction — it cannot bend;
+      // without this skip the 0-dot always reads as a >5° kink and splits runs
+      if (lu < 1e-9 || lv < 1e-9) continue;
+      if ((ux * vx + uy * vy + uz * vz) / (lu * lv) < cosKink) { kinks.add(k); break; }
+    }
+  }
+  return kinks;
+}
 
-// Manifold path: stack the resolved rings, stitch side quads, and (unless closed) fan a
-// cap over each end from its centroid. Caps assume star-convex-from-centroid rings, which
-// covers regular n-gons and every polygon.js helper. Returns a raw Manifold (caller T()s).
-//
-// NOTE on `ruled`: the OCCT backend's native loft honours `ruled:false` (a smooth C2 blend
-// between rings); this hand-mesh always emits faceted straight walls between consecutive
-// rings and ignores `ruled`. So `ruled:false` previews faceted here and only exports the
-// true smooth surface via the OCCT (STEP) path — documented on the loft doc row.
-export function loftMesh(wasm, rings, { closed = false } = {}) {
-  const resolved = resolveRings(rings);
+// Run-partitioned mesh: wall triangles grouped by (band group × sector), caps as
+// their own runs, every run stamped with a freshly reserved original ID and its
+// policy recorded in `runPolicies` for the backend to register.
+function sectoredMesh(wasm, resolvedLoft, kinks, { closed = false } = {}, runPolicies) {
+  const { resolved, shading } = resolvedLoft;
+  const N = resolved[0].pts2d.length, R = resolved.length;
+  const V = [];
+  for (const { pts2d, z } of resolved) for (const [x, y] of pts2d) V.push(x, y, z);
+
+  const bands = closed ? R : R - 1;
+  const groupOf = new Array(bands);
+  let g = 0;
+  for (let b = 0; b < bands; b++) { if (b > 0 && kinks.has(b)) g++; groupOf[b] = g; }
+  // closed loop: unless ring 0 itself kinks, the last group continues into the first
+  if (closed && g > 0 && !kinks.has(0)) for (let b = bands - 1; b >= 0 && groupOf[b] === g; b--) groupOf[b] = 0;
+
+  const K = Math.max(...shading.sectorOf) + 1;
+  const runTris = new Map(); // (group * K + sector) -> flat tri indices
+  for (let b = 0; b < bands; b++) {
+    const i0 = b * N, i1 = ((b + 1) % R) * N;
+    for (let j = 0; j < N; j++) {
+      const key = groupOf[b] * K + shading.sectorOf[j];
+      let arr = runTris.get(key);
+      if (!arr) runTris.set(key, (arr = []));
+      const a = i0 + j, b2 = i0 + (j + 1) % N, cc = i1 + j, dd = i1 + (j + 1) % N;
+      arr.push(a, dd, cc, a, b2, dd); // same winding as sideQuads
+    }
+  }
+  const capBottom = [], capTop = [];
+  if (!closed) {
+    triCap(wasm, capBottom, 0, resolved[0].pts2d, true);
+    triCap(wasm, capTop, (R - 1) * N, resolved[R - 1].pts2d, false);
+  }
+
+  const wallKeys = [...runTris.keys()].sort((a, b) => a - b);
+  const totalRuns = wallKeys.length + (closed ? 0 : 2);
+  const base = wasm.Manifold.reserveIDs(totalRuns);
+  const Tr = [], runIndex = [0], runOriginalID = [];
+  let next = base;
+  for (const key of wallKeys) {
+    for (const t of runTris.get(key)) Tr.push(t);
+    runIndex.push(Tr.length);
+    runOriginalID.push(next);
+    runPolicies?.set(next, shading.sectorSmooth[key % K] ? LOFT_SECTOR_SMOOTH : LOFT_SECTOR_FACETED);
+    next++;
+  }
+  for (const cap of closed ? [] : [capBottom, capTop]) {
+    for (const t of cap) Tr.push(t);
+    runIndex.push(Tr.length);
+    runOriginalID.push(next);
+    runPolicies?.set(next, LOFT_SECTOR_FACETED); // caps are planar
+    next++;
+  }
+
+  let out = manifoldFromMeshRuns(wasm, V, Tr, runIndex, runOriginalID);
+  if (out.volume() < 0) {          // descending-z stacks: rebuild outward, runs unchanged
+    out.delete?.();
+    reverseWinding(Tr);
+    out = manifoldFromMeshRuns(wasm, V, Tr, runIndex, runOriginalID);
+  }
+  return out;
+}
+
+export function loftMesh(wasm, rings, opts = {}, runPolicies = null) {
+  const rl = Array.isArray(rings) ? resolveLoftRings(rings) : rings;
+  const { resolved, shading } = rl;
+  const { closed = false, shading: hint } = opts;
+  if (shading && hint == null) {
+    const kinks = kinkRingsOf(resolved, closed);
+    const K = Math.max(...shading.sectorOf) + 1;
+    // Partition only when there is a boundary to express; a single smooth sector
+    // with no kinks keeps the legacy single-surface path (and its policy inference).
+    if (K > 1 || kinks.size > 0) return sectoredMesh(wasm, rl, kinks, opts, runPolicies);
+  }
   const N = resolved[0].pts2d.length;
   const V = [];
   for (const { pts2d, z } of resolved) for (const [x, y] of pts2d) V.push(x, y, z);
   const Tr = [];
   sideQuads(Tr, resolved.length, N, closed);
   if (!closed) {
-    const first = resolved[0], lastR = resolved[resolved.length - 1];
-    fanCap(V, Tr, 0, N, centroid(first.pts2d, first.z), true);                    // bottom faces −Z
-    fanCap(V, Tr, (resolved.length - 1) * N, N, centroid(lastR.pts2d, lastR.z), false); // top faces +Z
+    triCap(wasm, Tr, 0, resolved[0].pts2d, true);
+    triCap(wasm, Tr, (resolved.length - 1) * N, resolved[resolved.length - 1].pts2d, false);
   }
   let out = manifoldFromMesh(wasm, V, Tr);
-  // The mesh helpers wind for CCW rings ordered along +Z. CW-wound rings or descending-z
-  // rings invert every face, yielding a negative-volume solid that ofMesh imports without
-  // complaint but that behaves BACKWARDS under booleans (cut adds material). Detect the
-  // inversion and rebuild with reversed winding so loft is winding/z-order agnostic — this
-  // matches OCCT, whose native loft always returns a positively-oriented solid.
-  if (out.volume() < 0) {
+  if (out.volume() < 0) {          // CW rings / descending z: rebuild outward (unchanged)
     out.delete?.();
     reverseWinding(Tr);
     out = manifoldFromMesh(wasm, V, Tr);

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

@@ -1,5 +1,6 @@
 import { helixTube } from "./helix-tube.js";
 import { loftMesh } from "./loft.js";
+import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
 import { sweepMesh } from "./sweep.js";
 import { roundedBoxRings } from "./rounded-solids.js";
 import { tessellateContour, tessellateProfile } from "./profile.js";
@@ -434,6 +435,34 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         const g0 = m.getMesh();
         const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
         const oids0 = new Set(g0.runOriginalID);
+        // Sector-aware re-stamp: a provenance-sectored loft (the `sector` policy
+        // marker) must keep every run's identity — folding them (either the plain
+        // asOriginal below or the blend path's two-group stamp) would erase the
+        // sector creases and dividing lines the runs exist to draw. Re-stamp every
+        // distinct id 1:1 onto fresh reserved ids: each keeps its policy (blend
+        // runs riding along keep BLEND), all map to the one label string, and the
+        // fresh ids give the same reuse-under-another-label guarantee as
+        // asOriginal(). Unregistered ids (plain boolean tools) stay unregistered —
+        // they shade SMOOTH by default exactly as before.
+        if ([...oids0].some((oid) => !!oidPolicies.get(oid)?.sector)) {
+          const olds = [...oids0];
+          const base2 = Manifold.reserveIDs(olds.length);
+          const mapId = new Map(olds.map((o2, i2) => [o2, base2 + i2]));
+          g0.runOriginalID = Uint32Array.from(g0.runOriginalID, (o2) => mapId.get(o2));
+          const o = T(new Manifold(g0));
+          g0.delete?.();
+          const setIds = [];
+          for (const [oldId, newId] of mapId) {
+            featureLabels.set(newId, name);
+            const pol = oidPolicies.get(oldId);
+            if (pol !== undefined) oidPolicies.set(newId, pol);
+            setIds.push(newId);
+          }
+          return { value: wrap(o, lh), pin: o, dispose: () => {
+            for (const id2 of setIds) { featureLabels.delete(id2); oidPolicies.delete(id2); }
+            o.delete?.();
+          } };
+        }
         if ([...oids0].some(isBlend)) {
           const baseId = Manifold.reserveIDs(2), blendId = baseId + 1;
           // base-group policy: the same triangle-weighted majority vote as the plain
@@ -605,16 +634,29 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // Ring loft: hand-meshed via the shared ring-mesh helpers (helix-tube recipe).
     // Cached atomically; the hash folds every ring's points/z/rotate/scale and the
     // opts (including `shading`, so toggling the hint is a fresh cache node).
-    // asOriginal() stamps a stable originalID; the shading policy (inferred from
-    // the rings, or forced by `shading`) registers under it for the crease pass
-    // and lives exactly as long as the cache pins the solid.
+    // Sectored lofts (curve/resample rings with sharp features or silhouette kinks)
+    // come back already stamped with reserved per-run original IDs, whose policies
+    // loftMesh reports through the out-param — register them all and never
+    // asOriginal() (it would fold the runs into one surface and erase every
+    // provenance crease). Unsectored lofts keep the legacy single-surface path:
+    // asOriginal() + one inferred policy. Either way the registrations live
+    // exactly as long as the cache pins the solid.
     loft: (rings, opts = {}) => {
-      const key = h("loft", rings, opts);
+      const key = h("loft", loftRingsKey(rings), opts);
       return cache.lookup(key, () => {
-        const raw = T(loftMesh(wasm, rings, opts));
+        const rl = resolveLoftRings(rings);        // resolve once: mesh + shading share it
+        const runPol = new Map();
+        const raw = T(loftMesh(wasm, rl, opts, runPol));
+        if (runPol.size > 0) {
+          for (const [oid, pol] of runPol) oidPolicies.set(oid, pol);
+          return { value: wrap(raw, key), pin: raw, dispose: () => {
+            for (const oid of runPol.keys()) oidPolicies.delete(oid);
+            raw.delete?.();
+          } };
+        }
         const m = T(raw.asOriginal());
         const id = m.originalID();
-        oidPolicies.set(id, loftShadingPolicy(rings, opts));
+        oidPolicies.set(id, loftShadingPolicy(rl, opts));
         return { value: wrap(m, key), pin: m, dispose: () => { oidPolicies.delete(id); m.delete?.(); } };
       });
     },

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

@@ -51,3 +51,19 @@ export function manifoldFromMesh(wasm, V, Tr) {
   mesh.delete?.(); // input mesh is consumed by ofMesh; free it (caller tracks `out`)
   return out;
 }
+
+// Same import, but with the triangles partitioned into runs carrying pre-reserved
+// original IDs (Manifold.reserveIDs), so downstream shading (creased-normals) can
+// treat each run as its own surface with its own policy — and the partition
+// survives every boolean, exactly like mesh-fillet's blend bands. `runIndex` is in
+// triVert units (3 × triangle count, MeshGL convention), first entry 0, last Tr.length.
+export function manifoldFromMeshRuns(wasm, V, Tr, runIndex, runOriginalID) {
+  const mesh = new wasm.Mesh({
+    numProp: 3, vertProperties: Float32Array.from(V), triVerts: Uint32Array.from(Tr),
+    runIndex: Uint32Array.from(runIndex), runOriginalID: Uint32Array.from(runOriginalID),
+  });
+  mesh.merge();
+  const out = wasm.Manifold.ofMesh(mesh);
+  mesh.delete?.();
+  return out;
+}

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

@@ -23,7 +23,7 @@ import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
-import { resolveRings } from "./loft.js";
+import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
 import { resolveSweepStations } from "./sweep.js";
 import { normalizeProfile } from "./profile.js";
 import { roundedRectContour } from "./rounded-solids.js";
@@ -423,14 +423,25 @@ export function createOcctKernel(replicad) {
     });
   };
 
-  // ring loft: each ring becomes a closed polygon wire placed at its z (native loft closes
-  // the ends for closed wires). closed:true loops are Manifold-only (replicad loft is open).
+  // ring loft: mode "curve" (structurally identical curve rings) lofts the ORIGINAL
+  // baked contours as true arc/spline wires — STEP stays curve-exact; every other mode
+  // lofts the same resolved point rings the Manifold backend stitches, so parity is by
+  // construction (ThruSections' own wire-matching never gets to pick a different seam).
+  // closed:true loops are Manifold-only (replicad loft is open).
+  // ThruSections can hand back a NEGATIVELY-oriented solid for some all-cubic wires
+  // even though every input wire is CCW (arc and line wires never trigger this), so a
+  // volume latch restores the positive orientation — the OCCT twin of loftMesh's
+  // whole-mesh volume<0 rebuild on the Manifold side.
   const loftOp = (rings, { ruled = true, closed = false } = {}) => {
     if (closed) throw new Error("loft: closed:true loops are only supported on the Manifold backend");
-    const key = h("loft", rings, ruled);
+    const key = h("loft", loftRingsKey(rings), ruled);
     return cached(key, () => {
-      const wires = resolveRings(rings).map(({ pts2d, z }) => contourDrawing(pts2d).sketchOnPlane("XY", z).wire);
-      return wrap(loft(wires, { ruled }), [], key);
+      const { mode, resolved } = resolveLoftRings(rings);
+      const wires = resolved.map(({ pts2d, contour, z }) =>
+        (mode === "curve" ? contourDrawing(contour) : contourDrawing(pts2d)).sketchOnPlane("XY", z).wire);
+      const solid = loft(wires, { ruled });
+      if (measureVolume(solid) < 0) solid.wrapped.Reverse();
+      return wrap(solid, [], key);
     });
   };
 

package/src/framework/geometry/profile.js

@@ -53,6 +53,26 @@ export function normalizeProfile(profile) {
   return { outer, holes };
 }
 
+// Solve the circle through (p0, via, p1) and the CCW-normalized sweep from p0 to p1
+// that passes through `via`. Returns null for a collinear triple (callers emit a
+// straight segment). Shared by sampleArc and loft-rings' fixed-count arc sampler.
+export function arcGeometry(p0, via, p1) {
+  const [ax, ay] = p0, [bx, by] = via, [cx0, cy0] = p1;
+  const d = 2 * (ax * (by - cy0) + bx * (cy0 - ay) + cx0 * (ay - by));
+  if (Math.abs(d) < 1e-12) return null;
+  const sa = ax * ax + ay * ay, sb = bx * bx + by * by, sc = cx0 * cx0 + cy0 * cy0;
+  const cx = (sa * (by - cy0) + sb * (cy0 - ay) + sc * (ay - by)) / d;
+  const cy = (sa * (cx0 - bx) + sb * (ax - cx0) + sc * (bx - ax)) / d;
+  const r = Math.hypot(ax - cx, ay - cy);
+  const a0 = Math.atan2(ay - cy, ax - cx);
+  const av = Math.atan2(by - cy, bx - cx);
+  const a1 = Math.atan2(cy0 - cy, cx0 - cx);
+  const twoPi = 2 * Math.PI;
+  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
+  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
+  return { cx, cy, r, a0, dA: vCCW <= dCCW ? dCCW : dCCW - twoPi };
+}
+
 // Sample the circular arc through (p0, via, p1) — the three-point form roundedProfile
 // emits — into a point list p1…pN (EXCLUDING the start p0, which the ring already holds;
 // the last point is exactly p1). The circle is recovered from the circumcircle of the
@@ -63,27 +83,15 @@ export function normalizeProfile(profile) {
 // triple falls back to a single straight segment to p1 — the same "plain line" the OCCT
 // side gets when roundedProfile emits no `via`.
 export function sampleArc(p0, via, p1, segs) {
-  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = p1;
-  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
-  if (Math.abs(d) < 1e-12) return [[cx, cy]];            // collinear → straight line
-  const sa = ax * ax + ay * ay, sb = bx * bx + by * by, sc = cx * cx + cy * cy;
-  const ux = (sa * (by - cy) + sb * (cy - ay) + sc * (ay - by)) / d;
-  const uy = (sa * (cx - bx) + sb * (ax - cx) + sc * (bx - ax)) / d;
-  const rr = Math.hypot(ax - ux, ay - uy);
-  const a0 = Math.atan2(ay - uy, ax - ux);
-  const av = Math.atan2(by - uy, bx - ux);
-  const a1 = Math.atan2(cy - uy, cx - ux);
-  const twoPi = 2 * Math.PI;
-  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
-  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
-  const dA = vCCW <= dCCW ? dCCW : dCCW - twoPi;          // pick the sweep containing `via`
-  const steps = Math.max(2, Math.ceil((segs * Math.abs(dA)) / twoPi));
+  const g = arcGeometry(p0, via, p1);
+  if (!g) return [[p1[0], p1[1]]];                        // collinear → straight line
+  const steps = Math.max(2, Math.ceil((segs * Math.abs(g.dA)) / (2 * Math.PI)));
   const out = [];
   for (let s = 1; s <= steps; s++) {
-    const ang = a0 + dA * (s / steps);
-    out.push([ux + rr * Math.cos(ang), uy + rr * Math.sin(ang)]);
+    const ang = g.a0 + g.dA * (s / steps);
+    out.push([g.cx + g.r * Math.cos(ang), g.cy + g.r * Math.sin(ang)]);
   }
-  out[out.length - 1] = [cx, cy];                        // pin the exact endpoint
+  out[out.length - 1] = [p1[0], p1[1]];                   // pin the exact endpoint
   return out;
 }
 

package/src/framework/geometry/shading-policy.js

@@ -17,6 +17,13 @@ export const FACETED = Object.freeze({ creaseAngle: 10, sameSurfaceLines: false
 // stay invisible while real mitre crossings still draw.
 export const BLEND = Object.freeze({ creaseAngle: 35, sameSurfaceLines: true, boundaryLines: true });
 
+// Loft sector policies: identical crease/line behavior to SMOOTH/FACETED, plus the
+// `sector` marker label() uses to preserve a sectored loft's runs 1:1 when it
+// re-stamps original IDs (a plain asOriginal would fold the sectors into one
+// surface and erase every provenance crease and dividing line).
+export const LOFT_SECTOR_SMOOTH = Object.freeze({ ...SMOOTH, sector: true });
+export const LOFT_SECTOR_FACETED = Object.freeze({ ...FACETED, sector: true });
+
 export const COPLANAR_ANGLE = 5;  // deg — cut seams bending less than this are coplanar: no line
 export const TANGENT_ANGLE = 5;   // deg — B-rep edges whose faces agree within this are tangent: no line
 export const MIN_EDGE = 0.01;     // mm — drop shorter segments (degenerate slivers, pole edges)
@@ -36,18 +43,17 @@ export const SMOOTH_SIDES_MIN = 32;
 
 export const cosDeg = (deg) => Math.cos((deg * Math.PI) / 180);
 
-// Loft shading inference. An explicit `shading` hint wins; `ruled:false` asks
-// OCCT for a smoothly blended surface, so the Manifold preview of the same part
-// must shade smooth too; otherwise low-side-count rings are intentional facets.
-export function loftShadingPolicy(rings, { shading, ruled } = {}) {
+// Loft shading inference over RESOLVED rings (resolveLoftRings' result). An explicit
+// `shading` hint wins; `ruled:false` must preview smooth (it exports smooth via OCCT);
+// any curved ring segment (arc/cubic) is smooth-surface intent; otherwise low
+// resolved side counts are intentional facets.
+export function loftShadingPolicy(resolvedLoft, { shading, ruled } = {}) {
   if (shading === "smooth") return SMOOTH;
   if (shading === "faceted") return FACETED;
   if (shading != null) throw new Error('loft: shading must be "smooth" | "faceted"');
   if (ruled === false) return SMOOTH;
+  if (resolvedLoft?.hasCurve) return SMOOTH;
   let maxSides = 0;
-  if (Array.isArray(rings)) for (const r of rings) {
-    const n = Array.isArray(r?.polygon) ? r.polygon.length : (Number.isFinite(r?.sides) ? r.sides : 0);
-    if (n > maxSides) maxSides = n;
-  }
+  for (const r of resolvedLoft?.resolved ?? []) if (r.pts2d.length > maxSides) maxSides = r.pts2d.length;
   return maxSides >= SMOOTH_SIDES_MIN ? SMOOTH : FACETED;
 }

package/src/framework/geometry/sweep.js

@@ -5,7 +5,7 @@
 // set of 3-D cross-section stations. BOTH backends build from that SAME station list —
 // Manifold hand-meshes it (sweepMesh below, the loft/helix-tube recipe via mesh-build.js),
 // OCCT lofts the same rings ruled (occt-backend.js). So the elbow shape agrees BY
-// CONSTRUCTION, not by tolerance — the same parity mechanism loft's resolveRings uses.
+// CONSTRUCTION, not by tolerance — the same parity mechanism loft's resolveLoftRings uses.
 //
 // Corners: cornerRadius==0 → a SHARP MITER (one station per vertex, in the bisecting
 // plane, stretched by 1/cos(turn/2) so straight walls meet flush). cornerRadius>0 →

package/src/lofted-bottle-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/lofted-bottle.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/parts/lofted-bottle.js

@@ -0,0 +1,61 @@
+// Example PartDefinition — the Shape2D-loft reference part. One rounded-square Shape2D
+// is reused up the body with per-ring scales (structurally identical rings: OCCT lofts
+// the original arc wires, so STEP keeps true circles); the shoulder morphs that square
+// into a circle (structurally different rings: both backends loft the identical
+// resampled sections). See docs/AUTHORING-PARTS.md for the conventions.
+import { circleProfile } from "partforge/geometry";
+
+export default {
+  meta: { title: "Lofted Bottle", units: "mm" },
+  parameters: [
+    {
+      id: "body",
+      title: "Bottle",
+      description: "A bottle lofted from a rounded-square base to a round neck (`k.loft` " +
+        "with `Shape2D` rings). **Corner radius** shapes the base; **Belly** bulges the body.",
+      presets: {
+        "Flask": { width: 40, bodyH: 70, cornerR: 8, belly: 1.15, neckD: 22, neckH: 25 },
+        "Square jar": { width: 60, bodyH: 50, cornerR: 6, belly: 1.0, neckD: 40, neckH: 12 },
+        "Slim vial": { width: 24, bodyH: 60, cornerR: 10, belly: 1.05, neckD: 14, neckH: 20 },
+      },
+      advanced: [
+        { key: "width", label: "Base width", unit: "mm", min: 20, max: 80, step: 1, description: "Across-flats width of the rounded-square base." },
+        { key: "bodyH", label: "Body height", unit: "mm", min: 30, max: 120, step: 1, description: "Height of the square-section body." },
+        { key: "cornerR", label: "Corner radius", unit: "mm", min: 1, max: 12, step: 0.5, description: "Base corner rounding — these arcs stay true circles in STEP." },
+        { key: "belly", label: "Belly", min: 0.9, max: 1.4, step: 0.05, description: "Mid-body scale — above 1 bulges, below 1 pinches." },
+        { key: "neckD", label: "Neck diameter", unit: "mm", min: 10, max: 50, step: 1, description: "Round neck diameter at the mouth." },
+        { key: "neckH", label: "Neck height", unit: "mm", min: 8, max: 40, step: 1, description: "Height of the square-to-circle shoulder." },
+      ],
+    },
+  ],
+  defaults: { width: 40, bodyH: 70, cornerR: 8, belly: 1.15, neckD: 22, neckH: 25 },
+  parts: {
+    bottle: {
+      label: "Bottle", views: ["bottle"], export: { name: "lofted-bottle" },
+      build: (k, p) => {
+        const half = p.width / 2;
+        const r = Math.min(p.cornerR, half - 0.5); // fillet must fit the half-width
+        const sq = k.shape2d([[-half, -half], [half, -half], [half, half], [-half, half]]).fillet(r);
+        // Body: one Shape2D reused with per-ring scale → curve mode (STEP-exact arcs).
+        const body = k.loft({ rings: [
+          { polygon: sq, z: 0 },
+          { polygon: sq, z: p.bodyH * 0.45, scale: p.belly },
+          { polygon: sq, z: p.bodyH },
+        ] }).label("Body");
+        // Shoulder: rounded square → circle → resample mode (shared rings, both backends).
+        const shoulder = k.loft({ rings: [
+          { polygon: sq, z: p.bodyH },
+          { polygon: circleProfile(p.neckD / 2), z: p.bodyH + p.neckH },
+        ] }).label("Shoulder");
+        return body.union(shoulder);
+      },
+    },
+  },
+  views: { bottle: { label: "Bottle" } },
+  verify: {
+    expect: {
+      bottle: { holes: 0, bbox: "<=[120,120,165]" },
+      _view: { overlaps: 0 },
+    },
+  },
+};