partforge 0.130.1 → 0.131.0

package/docs/AUTHORING-PARTS.md

@@ -452,7 +452,7 @@ and the detection rule.
 | `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` |
 | `k.roundedCylinder({ r\|d, h, center?, round })` | cylinder with rounded rims — `round` = number (both) or `{ top?, bottom? }`; `round: r` with `top+bottom = h` gives a sphere (capsule when `h > 2r`); one lathe revolve, curve-exact in STEP |
 | `k.torus({ rMajor, rMinor })` | torus centered at the origin (tube centerline in z=0); `0 < rMinor < rMajor` |
-| `k.revolve({ profile, degrees? })` | revolve a lathe profile `[[r,z],…]` (r ≥ 0) around the Z axis (full or partial) |
+| `k.revolve({ profile, degrees? })` | revolve a lathe profile in `[r, z]` (r ≥ 0) around the Z axis (full or partial): a point list, a `{start, segments}` path contour (its arcs stay exact), an `{outer, holes}` region, or a `Shape2D`. A partial sweep spends the circle count in proportion to its angle |
 | `k.helixSweptTube({ pathR, profileR, pitch, turns, z0, lefthand })` | circle swept along a helix (e.g. a rope groove). **Not for threads** — the profile is always circular and rides a frenet frame that rolls with the helix, tilting a tooth off-axis. For threads use `k.screwSweep` |
 | `k.screwSweep({ profile, pitch, turns, lefthand? })` | screw-motion sweep of an **axial** lathe profile `[[r, z], …]` (same convention as `k.revolve`) — threads, worms, helical ridges. `h = pitch · turns`. The profile's axial extent must not exceed `pitch`; a profile spanning exactly `pitch` must be **periodic** (first radius == last radius) and yields a complete threaded body with no boolean (both backends) |
 | `k.loftSmooth({ sections, stations?, samples?, shading?, closed? })` | smooth organic loft: ≥2 sparse control sections — point rings, `sides`+`radius`, curve contours, or `Shape2D`, vertex/corner counts may differ per section — interpolated with splines on both backends — the "here are 5 airfoil sections, make it smooth" op. The surface passes through every section exactly. A point section may tag `sharp: [indices]` to keep those vertices true corners instead of letting the spline round them off; a curve/`Shape2D` section gets its corners implicitly from its own non-smooth joints. All sections need the same corner count. `closed: true` closes the loft into a loop (Manifold-only, like `k.loft`). See the propeller reference part (`sharpTE` toggle) |
@@ -527,13 +527,14 @@ Pass `closed: true` to close the loft into a loop instead of capping both
 ends (Manifold-only, same restriction as `k.loft`'s `closed`; a part that
 needs STEP export can't use it).
 
-**`sweep`** takes the same CCW `polygon.js` outline as its `profile` and a plain `[[x,y,z],…]` point list as its
+**`sweep`** takes a CCW outline as its `profile` — a point list, or a path contour it samples to one at 48 points
+per circle (a tube's cost is its ring size times its stations) — 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
-k.extrude({ profile: { outer: roundedRectPolygon(40, 30, 4), holes: [circleProfile(6)] }, h: 10 });
+k.extrude({ profile: { outer: roundedRectProfile(40, 30, 4), holes: [circleProfile(6)] }, h: 10 });
 
 // a tapered, twisting faceted vase wall (see src/parts/faceted-vase.js)
 const rings = [];
@@ -545,12 +546,14 @@ k.loft({ rings });                      // ruled walls, capped ends
 k.sweep({ profile: circleProfile(3), path: [[0, 0, 0], [0, 0, 20], [15, 0, 20]], cornerRadius: 5 });
 
 // round every corner of any CCW outline, then extrude/loft/prism it
-k.prism({ points: filletPolygon(bracketOutline, 3), h: 4 });   // tessellated corners (faceted in STEP)
-k.prism({ points: roundedProfile(bracketOutline, 3), h: 4 });  // true CIRCLE corners in STEP export
+k.prism({ points: roundedProfile(bracketOutline, 3), h: 4 });  // true CIRCLE corners, refined at export
+
+// a bayonet lug: an exact annular sector (never a sampled one — see "Profiles & patterns")
+k.prism({ points: ringSectorProfile(28, 30, 36), h: 2 });
 
 // print clearance on an arbitrary cut profile, or an inset wall
-k.extrude({ profile: offsetPolygon(slotPolygon(20, 3), 0.2), h: 10 });   // slot cut 0.2 mm looser all around
-offsetPolygon(outline, -wall, { corners: "sharp" });                     // inset a wall (see planter.js)
+k.extrude({ profile: k.shape2d(slotProfile(20, 3)).offset(0.2), h: 10 });   // slot cut 0.2 mm looser; arcs stay arcs
+offsetPolygon(outline, -wall, { corners: "sharp" });                        // inset a wall (see planter.js)
 
 // A mounting tab: square at the root, semicircular at the tip. The arc names the
 // point it must pass THROUGH (its apex), so its direction can never flip — there is
@@ -574,17 +577,19 @@ k.extrude({ profile: lip, h: 3 });
 const shell = k.roundedBox({ size: [60, 40, 22], round: { side: 4, top: 2, bottom: 0 } });
 ```
 
-2-D polygon helpers for `prism`/`extrude`/`loft`: `import { piePolygon, hexPolygon,
-regularPolygon, roundedRectPolygon, starPolygon, slotPolygon, circleProfile, filletPolygon,
-roundedProfile, offsetPolygon, pathProfile } from "partforge/geometry"`. `filletPolygon(points, r, { segs? })` rounds
-every corner of a CCW polygon (per-corner radius clamped so neighbouring arcs never overlap)
-and returns points usable by `prism`/`extrude`/`loft` on both backends — but it **bakes each
-corner into line facets**, so STEP corners are faceted. `roundedProfile(points, r | r[])`
-rounds corners the same way but keeps them **mathematically true** — it carries the arc
-symbolically so STEP export gets real circular edges. Use it for `prism`/`extrude`/`loft` alike (loft lifts arc rings into its curve mode). A scalar `r` rounds every corner; a per-corner
+2-D profile helpers for `prism`/`extrude`/`revolve`/`loft`: `import { pathProfile, roundedProfile,
+ringSectorProfile, slotProfile, pieProfile, roundedRectProfile, circleProfile, circlePolygon, hexPolygon,
+regularPolygon, starPolygon, offsetPolygon } from "partforge/geometry"`. **The naming rule:
+`*Profile` helpers return exact curves** — a path contour whose arcs the kernel facets per
+quality tier, finer at export, and OCCT keeps as true circles — **and `*Polygon` helpers return
+straight-edged point lists**, which are built and exported exactly as written (see "Profiles &
+patterns"). `roundedProfile(points, r | r[])` rounds every corner of a CCW polygon (per-corner
+radius clamped so neighbouring arcs never overlap) and carries each arc **symbolically**, so STEP
+export gets real circular edges. Use it for `prism`/`extrude`/`loft` alike (loft lifts arc rings into its curve mode). A scalar `r` rounds every corner; a per-corner
 `r[]` (length = points) rounds selectively (a `0`, a zero-length edge, or a straight/180°
 corner stays sharp). `offsetPolygon(profile, delta, { corners?, segs? })` offsets a
-point-list polygon or `{ outer, holes }` region by `delta` mm — positive grows material,
+point-list polygon or `{ outer, holes }` region by `delta` mm (a path contour is sampled to
+points first, 48 per circle; `k.shape2d(profile).offset(delta)` keeps arcs exact) — positive grows material,
 negative insets; regions offset material-wise (outer `+delta`, holes `−delta`, so a
 clearance loosens the whole cut). `corners` picks the convex-corner style: `"round"`
 (default; the true Minkowski clearance), `"chamfer"`, or `"sharp"` (miter, falling back to
@@ -1487,17 +1492,31 @@ purpose — see "Conditions: `when` and `whenFalse`" above for the split.
 
 Pure helpers from `partforge/geometry` (no backend dependency):
 
-**2-D profiles** (CCW point arrays for `k.prism` / `k.revolve`):
-`roundedRectPolygon(w,h,r)`, `regularPolygon(n,r,{flat})`, `ellipsePolygon(rx,ry)`,
-`slotPolygon(length,r)` (overall length = `length + 2r`), `starPolygon(points,outerR,innerR)`,
-`ringSectorPolygon(innerR,outerR,arcDeg)` (**arcDeg < 360** — a full ring is a contour-with-hole;
-cut an inner cylinder from an outer one instead).
-`circleProfile(r, center?)` — a circle of radius `r` centered at `[cx,cy]` (default origin).
-Compose it for round solids: `k.prism({ points: circleProfile(r), h })` is a cylinder, and
-**use `k.torus({ rMajor, rMinor })` for a torus** — it desugars to a revolve of
-an arc-exact circle profile (`k.revolve({ profile: circleProfile(minorR,
-[majorR, 0]) })` is the faceted hand-rolled equivalent; the primitive keeps
-real TORUS faces in STEP).
+**2-D profiles.** One naming rule: **`*Profile` = exact curves, `*Polygon` = straight edges.**
+
+*Exact curves* — CCW path contours `{start, segments}` whose arcs the kernel facets per
+quality tier (finer at export, see "Preview vs print quality") and OCCT keeps as true circles
+in STEP. Use these for every round outline that shows or fits:
+`ringSectorProfile(innerR,outerR,arcDeg)` (0 < innerR < outerR, **0 < arcDeg < 360** — a full
+ring is a region with a hole: extrude `{ outer, holes }` or cut an inner cylinder from an outer
+one), `pieProfile(tipR,arcDeg)` (a sector from the origin), `slotProfile(length,r)` (overall
+length = `length + 2r`; `length` 0 is a circle), `roundedRectProfile(w,h,r)` (r clamped to
+min(w,h)/2), `roundedProfile(points,r)` (round any polygon's corners), and `pathProfile()`.
+
+*Straight edges* — CCW point arrays, built and exported exactly as written:
+`regularPolygon(n,r,{flat})`, `hexPolygon(r)`, `starPolygon(points,outerR,innerR)`,
+`ellipsePolygon(rx,ry)` (a fixed 48-point ellipse — there is no exact-curve form), and
+`circlePolygon(r, center?, segs = 48)` — a circle as a fixed point list, for a deliberately
+faceted circle or point math of your own (mapping, indexing, spreading its points).
+
+*Circles.* `circleProfile(r, center?)` is the circle to hand to an op — `prism`, an `extrude`
+outline or hole, `k.shape2d`, `revolve`, `hull`, `loft`, `sweep`. **It is in transition**:
+today it returns the same 48 points as `circlePolygon`, and a coming release turns it into an
+exact curve like the other `*Profile` helpers. So pass it straight to an op and **never map,
+index or spread its result — use `circlePolygon` for that**. Until then, an exact circle in a
+2-D profile is `slotProfile(0, r)`. For a round SOLID use `k.cylinder` (a prism of 48 points is
+a 48-sided prism, never refined at export), and **use `k.torus({ rMajor, rMinor })` for a
+torus** — the primitive keeps real TORUS faces in STEP.
 
 **Patterns** (return `Solid[]` — feed to `k.union(...)` for features or `s.cutAll(...)` for holes):
 `linearPattern(solid, count, [dx,dy,dz])`, `circularPattern(solid, count, { center, axis, angle, rotateCopies })`.
@@ -1594,9 +1613,9 @@ the tooth.
 
 ```js
 // Keyhole plate: union a disc onto a rect, punch a slot, extrude.
-const plate = k.shape2d(roundedRectPolygon(40, 24, 4))
+const plate = k.shape2d(roundedRectProfile(40, 24, 4))
   .union(circleProfile(8))
-  .cut(slotPolygon(16, 3))
+  .cut(slotProfile(16, 3))
   .extrude({ h: 3 });   // sugar for k.extrude({ profile: …, h: 3 }); .revolve({ degrees }) too
 ```
 
@@ -1732,7 +1751,7 @@ Three rules worth internalizing before reaching for any of this:
 
 A practical trap with the broad selectors: `"all"`/`"convex"`/`"concave"` match **every**
 matching corner, including ones you didn't mean to touch. Union a curve-native outline
-with a *tessellated* point-list shape (e.g. `circleProfile`, still a faceted polygon —
+with a *tessellated* point-list shape (e.g. `circlePolygon`, a faceted polygon —
 see "Profiles & patterns") and every one of that polygon's facet vertices becomes its
 own small convex corner in the result; a `corners: "convex"` fillet then tries to round
 all of them, including the tiny ones whose neighboring facet is too short to hold any
@@ -1784,12 +1803,12 @@ Like any `Shape2D`, the result composes with booleans and offset — you can uni
 
 ```js
 // Emboss text onto a plate
-const baseplate = k.extrude({ profile: roundedRectPolygon(100, 60, 4), h: 5 });
+const baseplate = k.extrude({ profile: roundedRectProfile(100, 60, 4), h: 5 });
 const emboss = k.text2d("v2.0", { size: 8 }).offset(0.2);  // 0.2 mm relief
 const part = baseplate.cut(k.extrude({ profile: emboss, h: 1 }));
 
 // Deboss text into a lid
-const lid = k.extrude({ profile: circleProfile(40), h: 3 });
+const lid = k.cylinder({ r: 40, h: 3 });
 const deboss = k.text2d("PART-042", { size: 6 });
 const carved = lid.cut(k.extrude({ profile: deboss, h: 0.5 }));
 
@@ -3967,10 +3986,13 @@ symptom first** — it maps error text → cause → fix. The invariants, one li
 - **Never sample an arc into points by hand.** A `Math.cos` loop hides the sweep direction
   in a sign, and a wrong sign produces a self-crossing outline that builds with inverted
   fill and no error — only a `profile-self-intersects` warning
-  ([profile-self-intersects](ERROR-PATTERNS.md#profile-self-intersects)). Build curved
-  outlines with `pathProfile().arcTo(to, via)`, `roundedProfile`, `filletPolygon`,
-  `slotPolygon`, `ringSectorPolygon` and `circleProfile`; mirror a symmetric half with
-  `mirrorProfile`.
+  ([profile-self-intersects](ERROR-PATTERNS.md#profile-self-intersects)). And a sampled arc
+  is frozen at the facets you wrote: a point list is exported exactly as written, so a
+  print shows them, however fine the export is
+  ([profile-sampled-arc](ERROR-PATTERNS.md#profile-sampled-arc)). Build curved outlines
+  with `pathProfile().arcTo(to, via)` and the exact-curve `*Profile` helpers
+  (`ringSectorProfile`, `slotProfile`, `pieProfile`, `roundedRectProfile`,
+  `roundedProfile`); mirror a symmetric half with `mirrorProfile`.
 - **Preview vs print quality:** Manifold bakes segment counts in at primitive creation,
   so builds are quality-agnostic; the export path uses a separate "print" kernel. Preview
   facets every circle at 116 segments. Print sizes each circle by chord tolerance — the
@@ -3980,6 +4002,12 @@ symptom first** — it maps error text → cause → fix. The invariants, one li
   is a part that exports: the old flat 480 turned a 0.75 mm rivet into 115,200 triangles
   and a body with a few hundred of them into an out-of-memory trap at export
   ([export-kernel-out-of-memory](ERROR-PATTERNS.md#export-kernel-out-of-memory)).
+  **Only curves the kernel knows about are refined**: primitives, a revolve's sweep, and
+  the arcs of a path contour or `Shape2D`. A point list — from a `*Polygon` helper or a
+  loop of your own — is exported exactly as written, so there is no resolution setting
+  to raise; build the curve with a `*Profile` helper or `arcTo` instead. A partial
+  `revolve` spends the circle count in proportion to its sweep (a 36° revolve takes a
+  tenth of a circle's segments), so its facets match a full revolve's.
   **Doubly-curved surfaces are the exception on both tiers:** a sphere, a lathe's
   profile arcs (`torus`, `roundedCylinder`, a `revolve` of your own rounded `Shape2D`)
   and a `roundedBox`'s corners all spend the segment count squared (6,728 triangles

package/docs/ERROR-PATTERNS.md

@@ -206,9 +206,9 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 
 ## ring-sector-full-circle
 
-- **Symptom:** `ringSectorPolygon: arcDeg must be < 360 (use a cut for a full ring)`
-- **Cause:** A full annulus can't be a single simple polygon — it's a contour-with-hole.
-- **Fix:** Cut an inner cylinder from an outer one (or `k.extrude({ profile: { outer, holes }, h })`); use `ringSectorPolygon` only for partial arcs. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Profiles & patterns".
+- **Symptom:** `ringSectorPolygon: arcDeg must be < 360 (use a cut for a full ring)`, or `ringSectorProfile: arcDeg must be between 0 and 360 (exclusive), got 360`
+- **Cause:** A full annulus can't be a single simple contour — it's a contour-with-hole.
+- **Fix:** Cut an inner cylinder from an outer one (or `k.extrude({ profile: { outer, holes }, h })`); use `ringSectorProfile` only for partial arcs. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Profiles & patterns".
 
 ## occt-closed-loop-unsupported
 
@@ -284,7 +284,7 @@ The sphere variant is `sphere: pass exactly one of r/d` (same cause and fix).
 - **Cause:** malformed input to `offsetPolygon` — too few points after dedup, or (variant messages) a non-finite `delta`, non-finite coordinates, an unknown `corners` style, or a profile that is neither a point list nor `{outer, holes}`.
 - **Fix:** pass a CCW `[[x,y],…]` list (≥ 3 distinct points) or `{outer, holes}`, a finite `delta` in mm, and `corners: "round" | "chamfer" | "sharp"` — see [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Profiles & patterns".
 
-Variant literals under this entry: `offsetPolygon: delta must be a finite number`, `offsetPolygon: coordinates must be finite numbers`, `offsetPolygon: corners must be "round" | "chamfer" | "sharp"`, `offsetPolygon: profile must be a point list or {outer, holes}`.
+Variant literals under this entry: `offsetPolygon: delta must be a finite number`, `offsetPolygon: coordinates must be finite numbers`, `offsetPolygon: corners must be "round" | "chamfer" | "sharp"`, `offsetPolygon: profile must be a point list, a path contour, or {outer, holes}`.
 
 ## offset-polygon-input-self-intersects
 
@@ -779,7 +779,7 @@ between the Manifold preview and the OCCT STEP export.
 - **Cause:** *(partforge ≥ 0.69.)* A fillet/chamfer the geometry (or its own selector) defeats no longer fails the whole build on either backend: the op returns its input solid unchanged, everything downstream still applies, and the skip is recorded on the build result's `warnings` (`kernel.takeBuildWarnings()` / the `meshes` message's `warnings: [{part, message}]`).
 - **Fix:** Read the parenthesized reason. A bad selector (unknown plane, wrong `at` height) is a part bug — fix the selector. A geometry-defeated blend usually wants a smaller magnitude or simpler input (clamp per the entry above), or the feature deliberately left off. Treat the warning as "this feature did not land", never as a cosmetic note — the shape on screen genuinely lacks it.
 
-  The same channel carries every other degrade in a build: an `extrude` rim bevel reduced or skipped (`extrude bevel <b> …`), a `roundedBox` rim radius clamped to `round.side`, and the `Shape2D` corner-op clamps in the two entries above. The same channel also carries [profile-self-intersects](#profile-self-intersects) — a hand-authored outline that crosses itself and built with inverted fill. A build result's `warnings` is the complete list of what the part asked for and did not get — or, for `profile-self-intersects`, asked for and should not have.
+  The same channel carries every other degrade in a build: an `extrude` rim bevel reduced or skipped (`extrude bevel <b> …`), a `roundedBox` rim radius clamped to `round.side`, and the `Shape2D` corner-op clamps in the two entries above. The same channel also carries [profile-self-intersects](#profile-self-intersects) — a hand-authored outline that crosses itself and built with inverted fill — and [profile-sampled-arc](#profile-sampled-arc), an arc sampled into a point list coarsely enough that a print will show its facets. A build result's `warnings` is the complete list of what the part asked for and did not get — or, for `profile-self-intersects`, asked for and should not have.
 
 ## control-default-not-literal
 
@@ -821,7 +821,13 @@ between the Manifold preview and the OCCT STEP export.
 
 - **Symptom:** The build succeeds and its result carries a warning like `extrude: profile self-intersects near (12.3400, -6.3800) — the outline crosses itself, so the fill inverts there …` (also `prism: profile …`, `revolve: profile …`, `sweep: profile …`, `loft: ring 2 …`, `shape2d: profile …`), and the rendered part has a cavity, a missing lobe, or a sliver where a curved edge should be. Identical text on both backends.
 - **Cause:** *(partforge ≥ 0.112.)* A hand-authored 2-D profile (a point list, a `pathProfile` contour, a `{outer, holes}` region — handed to a factory op, to `k.shape2d`, or as a `Shape2D` boolean operand) crosses itself. Manifold fills a point ring even-odd, so the crossing quietly inverts the fill on one side instead of failing. The usual author of the crossing is an arc sampled into points by hand (a `Math.cos` loop) whose sweep sign or endpoint order is wrong, or a mirrored half whose point order was not reversed. The kernel now runs `validateProfile` on the way in and reports each crossing on the build result's `warnings`; a `Shape2D` is not re-validated, `text2d`/`vector2d` lifts are trusted, and a profile over 4000 segments is skipped (for `loft`, the ceiling is the sum over all its rings). At most **three** crossings are reported per profile — the third reads `… (and N more crossings on this profile)` — so one badly-drawn star cannot evict every other warning in the build. A hole whose edge touches or runs along its outer is **not** reported: that builds exactly as drawn, and only a contour crossing itself inverts the fill.
-- **Fix:** Rebuild the curved parts of the outline with `pathProfile(start).lineTo(p).arcTo(to, via).close()` — a three-point arc sweeps through `via`, so its direction cannot flip — or with the `partforge/geometry` helpers (`roundedProfile`, `filletPolygon`, `slotPolygon`, `ringSectorPolygon`, `circleProfile`); build a symmetric half once and `mirrorProfile` it rather than writing the mirror by hand. Confirm with `validateProfile(profile).ok` before extruding. The reported coordinate is in the profile's own frame (before any `rotate`/`at`).
+- **Fix:** Rebuild the curved parts of the outline with `pathProfile(start).lineTo(p).arcTo(to, via).close()` — a three-point arc sweeps through `via`, so its direction cannot flip — or with the exact-curve `partforge/geometry` helpers (`roundedProfile`, `ringSectorProfile`, `slotProfile`, `pieProfile`, `roundedRectProfile`); build a symmetric half once and `mirrorProfile` it rather than writing the mirror by hand. Confirm with `validateProfile(profile).ok` before extruding. The reported coordinate is in the profile's own frame (before any `rotate`/`at`).
+
+## profile-sampled-arc
+
+- **Symptom:** The build succeeds and its result carries a warning like `prism: profile traces an arc in straight facets (radius ≈ 30.0 mm, 9.0° per facet, up to 0.09 mm inside the true curve) — a point list is built and exported exactly as written, so a print shows those facets. …` (also `extrude: profile …`, `revolve: profile …`, `shape2d: profile …`). A printed part with that outline shows flat spots, and a fit built on it (a bayonet lug in its track, a pin in a slot) binds or rattles. Identical text on both backends.
+- **Cause:** *(partforge ≥ 0.131.)* A point list is built and exported exactly as written: only curves the kernel knows about — primitives, a revolve's sweep, and the arcs of a path contour or `Shape2D` — are faceted per quality tier and refined at export. An arc sampled into a point list keeps the facets it was sampled with, however fine the export. The round `*Polygon` helpers sample at 32 per circle (`ringSectorPolygon`, `slotPolygon`, `piePolygon`, and `roundedRectPolygon`'s corners), `filletPolygon` at 8 segments per corner whatever its angle, `circlePolygon` (and, until it becomes an exact curve, `circleProfile`) at 48, and a hand-written `Math.cos` loop at whatever it was given. The kernel reports the worst run in a profile: three or more facets turning by the same amount, at most 20° each, whose chord sits more than 0.05 mm inside the true arc. The end facets of a run may be shorter (an offset trims them), and coordinates may carry about 0.01 mm of rounding. Hexagons and other deliberate polygons, small holes, and finely sampled loops stay quiet, as does an arc of only two facets, which can't be told from a bend. It checks the outlines the author hands to `prism`, `extrude`, `revolve` and `k.shape2d`, including a bevelled `extrude`'s. It doesn't check what the kernel samples itself (a bevel's rim, a `screwSweep`'s section, a `hull`), or `loft` and `sweep`, which sample curve rings at their own fixed detail. At most three lines are reported per build.
+- **Fix:** Rebuild the outline from exact curves: `ringSectorProfile`, `slotProfile`, `pieProfile` and `roundedRectProfile` trace the same outlines as their `*Polygon` namesakes, `roundedProfile` rounds any polygon's corners, and `pathProfile(start).arcTo(to, via)` builds anything else — all are path contours the kernel facets per tier and refines at export (and OCCT keeps as true circles in STEP). There is no export-resolution setting to raise instead. For an exact circle in a 2-D profile use `slotProfile(0, r)`; for a round solid, `k.cylinder`. Sampling more points by hand only moves the facets, and it keeps them frozen.
 
 ## export-kernel-out-of-memory
 

package/docs/KERNEL-CONTRACT.md

@@ -283,7 +283,7 @@ above. All ops return a `Solid`.
 | `box({size, center?})` · `box({min, max})` | Axis-aligned box: `{size:[x,y,z]}` centered in X/Y with base at z = 0 (`center: true` also centers Z), or explicit `[x,y,z]` `{min, max}` corners. |
 | `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. |
+| `revolve({profile, degrees?})` | Revolve a lathe profile in `[r, z]` (r ≥ 0) about Z; `degrees` < 360 gives a capped partial revolve. Default 360. `profile` may be a point list, a `Shape2D`, or — lifted to a `Shape2D` by the kernel front before the op runs — a `{start, segments}` path contour or an `{outer, holes}` region. A mesh backend spends its circle count in proportion to the sweep. |
 | `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`. |
@@ -718,9 +718,13 @@ case appears; add its deterministic fixture and establish the source-domain trut
 `partforge/geometry` ships pure-JS helpers of several kinds. The **contour builders**
 (`piePolygon`, `hexPolygon`, `regularPolygon`, `roundedRectPolygon`, `ellipsePolygon`,
 `slotPolygon`, `starPolygon`, `ringSectorPolygon`, `circleProfile`, `cornerArc`,
-`filletPolygon`, `roundedProfile`) are pure functions from numbers to plain CCW point
+`filletPolygon`, `roundedProfile`, `ringSectorProfile`, `pieProfile`, `slotProfile`,
+`roundedRectProfile`, `circlePolygon`) are pure functions from numbers to plain CCW point
 lists or arc profiles — *data already in this contract's input format*, with no kernel
-dependency at all. The **solid patterns** (`linearPattern`, `circularPattern`) take a
+dependency at all. The naming rule: `*Profile` builders return path contours with symbolic
+arcs, `*Polygon` builders return point lists. `circleProfile` is in transition: it still
+returns `circlePolygon`'s 48 points, and becomes a path contour in 0.132, once stored parts
+that do point math on it have been migrated to `circlePolygon`. The **solid patterns** (`linearPattern`, `circularPattern`) take a
 `Solid` and call only ops from the tables above (`clone`/`translate`/`rotate`/
 `boundingBox`). The **profile transform** (`offsetPolygon`) takes a point list or
 `{outer, holes}` region and grows or shrinks it by a delta in mm — printer-clearance
@@ -867,6 +871,12 @@ The new mount claims that reply and drops it, rather than letting its own handle
 the reply's `error` as a failed build or its `download` as a viewbar save. The previous
 mount already rejected that export when it was disposed.
 
+`captureView` replies cross a rebind the same way, and `mount()` handles them the same
+way. Its `capture-generate` jobIds (`cap-<b>-<n>`) are unique to each mount, so a previous
+mount's `capture-meshes` can never settle the new mount's capture with the old geometry,
+and the new mount claims and drops that reply, including an `error`. The previous mount
+already resolved that capture to `null` when it was disposed.
+
 **Cancellation granularity is the sub-part.** The guard is checked only between
 sub-parts (one macrotask yield each), so a single long WASM op — a big boolean, an OCCT
 fillet — runs to completion no matter how stale it is. That is by design: WASM kernel

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.130.1",
+  "version": "0.131.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/capture-build.js

@@ -2,7 +2,23 @@
 // does NOT go through the regen loop. Same shape as export-controller's pending
 // Map (export-controller.js): allocate a jobId, resolve when the matching
 // reply arrives. Pure — no DOM, no worker; `send` is injected.
+
+// Job ids are unique per capture build, not just per mount: `cap-<b>-<n>`,
+// where <b> numbers the capture builds this module has made. Each mount makes
+// one, but a host may keep a worker across mounts (partforge-cloud's pool
+// rebinds it with setPart), and that worker's replies then reach whichever
+// mount is listening now. A capture-generate runs to completion, so a disposed
+// mount's capture still answers after the remount. When every mount numbered
+// its captures from 1, that late reply settled the next mount's same-numbered
+// capture with pre-edit geometry. The same scheme as export-controller.js's
+// `export-<c>-<n>`.
+let builds = 0;
+// Every id any capture build mints, so a reply to another build's job is
+// recognised even though this build never sent it.
+const CAPTURE_JOB_ID = /^cap-\d+-\d+$/;
+
 export function createCaptureBuild({ send }) {
+  const build = ++builds;
   let nextId = 1;
   let disposed = false;
   const pending = new Map(); // jobId -> resolve
@@ -12,12 +28,12 @@ export function createCaptureBuild({ send }) {
     // worker (a silent no-op) and its promise would hang forever. Resolve null instead
     // — captureView's documented "disposed runtime resolves null" contract.
     if (disposed) return Promise.resolve(null);
-    // String-namespaced ("cap-N") so a capture jobId stays outside
+    // String-namespaced ("cap-") so a capture jobId stays outside
     // export-controller's "export-"/"warm-" ids — both share the same worker
     // message space, and exportCtl.handleMessage claims every id in its own
     // namespace before checking type, so a colliding id could otherwise settle
     // the wrong promise.
-    const jobId = `cap-${nextId++}`;
+    const jobId = `cap-${build}-${nextId++}`;
     return new Promise((resolve) => {
       pending.set(jobId, resolve);
       // cache:true so the worker reuses its per-sub-part geometry memo (the
@@ -26,13 +42,14 @@ export function createCaptureBuild({ send }) {
     });
   }
 
-  // Returns true iff this message was a reply this controller owns (so the
-  // caller — mount.js's onWorkerMessage — can skip it entirely). Keyed on
-  // membership in `pending` first: the namespaced jobId guarantees another
-  // channel's message never matches, so a hit here is always ours. A failed
-  // build (the worker's shared catch posts a generic error/needs-occt/
-  // needs-import-mesh, jobId intact) resolves to null rather than leaving the
-  // caller hanging forever — captureView treats null as "capture failed, skip".
+  // Returns true iff this message is a reply to a capture job (so the caller —
+  // mount.js's onWorkerMessage — can skip it entirely): a pending job is
+  // settled, any other capture id is dropped. Keyed on membership in `pending`
+  // first: the namespaced jobId guarantees another channel's message never
+  // matches, so a hit here is always ours. A failed build (the worker's shared
+  // catch posts a generic error/needs-occt/needs-import-mesh, jobId intact)
+  // resolves to null rather than leaving the caller hanging forever —
+  // captureView treats null as "capture failed, skip".
   // needs-import-mesh MUST be claimed here rather than falling through to
   // mount's live-loop crossover case: this capture job never went through the
   // regen loop, so treating its reply as a live crossover would call
@@ -43,7 +60,12 @@ export function createCaptureBuild({ send }) {
   // gets primed by the next live build instead.
   function handleMessage(data) {
     const jobId = data?.jobId;
-    if (jobId == null || !pending.has(jobId)) return false;
+    // A capture id with nothing pending here: a job this build already
+    // settled, or one a disposed build sent to a worker the host kept. Either
+    // way its promise is already settled, so claim the reply and drop it.
+    // Passing it on would let mount's switch read an "error" as a failed build
+    // and a needs-import-mesh as a live crossover.
+    if (jobId == null || !pending.has(jobId)) return typeof jobId === "string" && CAPTURE_JOB_ID.test(jobId);
     if (data.type === "capture-meshes") {
       pending.get(jobId)(data.meshes);
     } else if (data.type === "error" || data.type === "needs-occt" || data.type === "needs-import-mesh") {

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

@@ -19,6 +19,7 @@ import { normalizeOpentype, parseFont } from "./opentype-interop.js";
 const opentype = normalizeOpentype(opentypeNamespace);
 import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
+import { isPathContour, contourToPoints } from "./profile.js";
 import { textGlyphs } from "./text2d.js";
 import { placeRegions } from "./vector2d.js";
 import { beveledExtrude } from "./rim-bevel.js";
@@ -29,6 +30,11 @@ import { screwCrossSection } from "./screw-profile.js";
 import { smoothLoftRings } from "./loft-smooth.js";
 
 export function finishKernel(k) {
+  // Runs a composition that tessellates curves itself without its facets being reported
+  // as the author's sampled arcs (profile-warnings.js). The lint probe's kernel has no
+  // warner, so there it just runs fn.
+  const quietArcs = (fn) => (k._warnProfile?.quietArcs ? k._warnProfile.quietArcs(fn) : fn());
+
   // Compound default: bored-through cylinder (tool overshoots 2 mm each end for
   // a clean cut). Assigned BEFORE the wrap loop so the fallback composition gets
   // the same key validation as a backend-native override.
@@ -50,12 +56,14 @@ export function finishKernel(k) {
   // (see screw-profile.js for why that identity holds, and why the profile must be
   // densified first). No backend override: both backends twist natively, so this
   // is one implementation and STEP gets a real twisted B-rep rather than a loft.
+  // Its cross-section is densified here, not by the author, so its facets are quieted
+  // (see quietArcs below).
   k.screwSweep ??= ({ profile, pitch, turns, lefthand = false }) =>
-    k.extrude({
+    quietArcs(() => k.extrude({
       profile: screwCrossSection(profile, pitch, { lefthand }),
       h: pitch * turns,
       twist: (lefthand ? -360 : 360) * turns,
-    });
+    }));
 
   // Compound default: a tapped (internally threaded) hole, as ONE cut tool.
   //
@@ -179,11 +187,45 @@ export function finishKernel(k) {
   // into extrude + loft + intersect (rim-bevel.js), so both backends share one
   // implementation and the probe records no CAD-only op. beveledExtrude calls
   // back into the wrapped k.extrude/k.loft, so caching and validation apply.
+  // The bevel tessellates the author's curves itself (at its own LOD) before calling the
+  // wrapped extrude/loft, so its sampled arcs are quieted — they are not the author's —
+  // and the author's own outline is checked for sampled arcs up front instead.
   const specExtrude = k.extrude;
-  k.extrude = (...a) =>
-    a.length === 1 && isPlainOptions(a[0]) && a[0].bevel !== undefined
-      ? beveledExtrude(k, a[0])
-      : specExtrude(...a);
+  k.extrude = (...a) => {
+    if (!(a.length === 1 && isPlainOptions(a[0]) && a[0].bevel !== undefined)) return specExtrude(...a);
+    k._warnProfile?.("extrude: profile", a[0].profile, { sampledArcs: true, crossings: false });
+    return quietArcs(() => beveledExtrude(k, a[0]));
+  };
+
+  // revolve takes a {start, segments} path contour (pathProfile, roundedProfile, the
+  // *Profile helpers) by lifting it to a Shape2D here — before the spec-wrapped op —
+  // so a curve helper works everywhere a point list does and both backends get the
+  // Shape2D lathe path (profile arcs at the double-curvature count, true arcs on OCCT).
+  // An {outer, holes} region is lifted the same way. The options-form rule is the
+  // normative one (KERNEL-CONTRACT.md "Calling convention"): a lone plain object is an
+  // options bag, so `k.revolve(contour)` alone is options form and is refused exactly as
+  // the lint probe refuses it; the positional form takes the contour with its options,
+  // `k.revolve(contour, { degrees })`.
+  const specRevolve = k.revolve;
+  const liftLathe = (p) =>
+    p && typeof p === "object" && !p._shape2d && !Array.isArray(p) && (isPathContour(p) || p.outer !== undefined)
+      ? k.shape2d(p)
+      : p;
+  k.revolve = (...a) => {
+    if (!(a.length === 1 && isPlainOptions(a[0]))) return specRevolve(liftLathe(a[0]), ...a.slice(1));
+    return specRevolve("profile" in a[0] ? { ...a[0], profile: liftLathe(a[0].profile) } : a[0]);
+  };
+
+  // sweep places its profile point by point along the path, so a path contour is sampled
+  // to a point ring first — at a fixed 48 per circle (contourToPoints), the density a
+  // circleProfile tube has always had, not the per-tier rule: a tube's triangle count is
+  // its ring count times its stations, and a long path has many.
+  const specSweep = k.sweep;
+  const sweepRing = (p) => (p && !p._shape2d && isPathContour(p) ? contourToPoints(p) : p);
+  k.sweep = (...a) => {
+    if (!(a.length === 1 && isPlainOptions(a[0]))) return specSweep(sweepRing(a[0]), ...a.slice(1));
+    return specSweep("profile" in a[0] ? { ...a[0], profile: sweepRing(a[0].profile) } : a[0]);
+  };
 
   k.toSTEP ??= () => { throw new KernelCapabilityError("toSTEP requires the OCCT backend"); };
   k.shape2d ??= () => { throw new KernelCapabilityError("shape2d requires the Manifold backend"); };
@@ -291,7 +333,9 @@ export function finishKernel(k) {
   k.hull = (inputs) => {
     if (!Array.isArray(inputs) || inputs.length === 0)
       throw new Error("hull: inputs must be a non-empty array");
-    return k.shape2d(convexHull(inputs.flatMap(hullPoints)));
+    // Trusted: a convex hull cannot cross itself, and its points are sampled here, not by
+    // the author, so neither profile warning applies to it.
+    return k.shape2d.trusted(convexHull(inputs.flatMap(hullPoints)));
   };
   // Swept hull over an ordered sequence (≥2): union of the hull of each consecutive pair.
   k.hullChain = (inputs) => {

package/src/framework/geometry/kernel.js

@@ -149,8 +149,8 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(o:{points:number[][]|{start:number[],segments:object[]},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[][]|{start:number[],segments:object[]}|{outer:number[][],holes?:number[][][]}|Shape2D,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[][]|{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[][]|Shape2D,degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted for now (see file header)
+ * @property {(o:{profile:number[][]|{start:number[],segments:object[]},path:number[][],closed?:boolean,cornerRadius?:number,ruled?:boolean,smooth?:boolean}) => Solid} sweep   sweep a 2-D profile along a 3-D polyline (a path contour is sampled to points, 48 per circle); legacy (profile,path,opts) accepted for now (see file header)
+ * @property {(o:{profile:number[][]|{start:number[],segments:object[]}|{outer:number[][],holes?:number[][][]}|Shape2D,degrees?:number}) => Solid} revolve   revolve a lathe profile in [r,z] around Z (a path contour or region is lifted to a Shape2D); 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:{d:number,pitch:number,turns:number,depth?:number,crest?:number,lefthand?:boolean,rootSink?:number,overshoot?:number}) => Solid} tappedBore   compound: a tapped hole as ONE cut tool — bore plus thread, root sunk inside the bore so the two never share a face

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

@@ -826,8 +826,14 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // dephase and horn-containment arithmetic assume it), bounded only by the tier's
     // cap: it may still never EXCEED kernel quality, but it is not re-bounded by the
     // part-scale rule meant for circles nobody sized by hand.
+    // A partial sweep spends the circle count in proportion to its angle: Manifold takes
+    // `density` as the slice count for the sweep it is given, so handing it the full-circle
+    // count put 116 slices into a 36° lug (932 triangles where 100 carry the same facet
+    // angle). Floored at 3, below which Manifold substitutes its own default.
     revolve: (pts, { degrees = 360, segs: segsOverride } = {}) => {
-      const densityFor = (maxR) => segsOverride != null ? Math.min(segs, segsOverride) : segsAt(maxR);
+      const turn = Math.abs(degrees);   // a negative sweep is the same angle the other way
+      const sweep = (n) => (turn >= 360 ? n : Math.max(3, Math.ceil((n * turn) / 360)));
+      const densityFor = (maxR) => segsOverride != null ? Math.min(segs, segsOverride) : sweep(segsAt(maxR));
       if (pts && pts._shape2d) {
         // Keyed on the override, not the resolved density, so a cache hit never
         // materializes the CrossSection just to measure its bounds.

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

@@ -247,6 +247,10 @@ const passThrough = (op, valid, required) => (o) => {
   return [o];
 };
 
+// The ops where a point list's sampled arc is worth a warning: each takes a path
+// contour instead and facets it per tier (profile-warnings.js, "Sampled arcs").
+const SAMPLED_ARCS = Object.freeze({ sampledArcs: true });
+
 // Kernel factory ops under the options convention. finishKernel() wraps each:
 // normalize (if options form) → check → raw backend op.
 export const KERNEL_OP_SPECS = {
@@ -257,11 +261,11 @@ export const KERNEL_OP_SPECS = {
   // warner first) reports a self-crossing hand-authored profile as a build
   // warning — the build proceeds; see profile-warnings.js.
   prism:    { toArgs: prismArgs, check: checkScaleTop("prism"),
-    warn: (warnProfile, points) => warnProfile?.("prism: profile", points) },
+    warn: (warnProfile, points) => warnProfile?.("prism: profile", points, SAMPLED_ARCS) },
   extrude:  { toArgs: extrudeArgs, check: (profile, h, opts) => {
     checkNonEmptyProfile("extrude", profile);
     checkScaleTop("extrude")(profile, h, opts);
-  }, warn: (warnProfile, profile) => warnProfile?.("extrude: profile", profile) },
+  }, warn: (warnProfile, profile) => warnProfile?.("extrude: profile", profile, SAMPLED_ARCS) },
   revolve:  { toArgs: revolveArgs, check: (pts) => {
     checkNonEmptyProfile("revolve", pts);
     if (pts && pts._shape2d) {
@@ -272,13 +276,13 @@ export const KERNEL_OP_SPECS = {
       if (pts.boundingBox().min[0] < -1e-5) throw new Error("revolve: profile radius must be ≥ 0");
       return;
     }
-    // revolve takes a lathe POINT LIST or a Shape2D — it has no contour path, and a
-    // {start, segments} contour used to reach the loop below and die as a bare
-    // "pts is not iterable" TypeError. Name the real problem instead.
+    // A {start, segments} contour never gets here: finishKernel's revolve lifts it to a
+    // Shape2D before this check runs. Anything else that is not a point list used to die
+    // in the loop below as a bare "pts is not iterable" TypeError; name the problem.
     if (!Array.isArray(pts) || !pts.every((p) => Array.isArray(p)))
-      throw new Error("revolve: profile must be an [[r, z], …] point list or a Shape2D (a {start, segments} contour is not accepted — lift it with k.shape2d first)");
+      throw new Error("revolve: profile must be an [[r, z], …] point list, a {start, segments} contour, or a Shape2D");
     for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
-  }, warn: (warnProfile, pts) => warnProfile?.("revolve: profile", pts) },
+  }, warn: (warnProfile, pts) => warnProfile?.("revolve: profile", pts, SAMPLED_ARCS) },
   // The loft ceiling is an AGGREGATE over the rings, never per ring: loftSmooth
   // densifies a handful of control sections into dozens of rings, each of which
   // sits comfortably under the per-profile bound, so a per-ring ceiling let a

package/src/framework/geometry/polygon.js

@@ -1,4 +1,5 @@
 // 2-D polygon helpers shared by parts that call kernel.prism().
+import { isPathContour, contourToPoints } from "./profile.js";
 
 // CCW polygon points for a circular-sector "pie" from the origin, radius tipR.
 export function piePolygon(tipR, arcDeg, segs = 32) {
@@ -274,6 +275,100 @@ export function roundedProfile(points, r) {
   return { start, segments, arc: true };
 }
 
+// ── Curve twins of the round *Polygon helpers ────────────────────────────────
+// ringSectorProfile / pieProfile / slotProfile / roundedRectProfile trace the SAME
+// outline as their *Polygon twins — same start point, same CCW direction, same
+// extent — but return a path contour { start, segments } whose arcs are symbolic
+// three-point arcs, like roundedProfile's. A point list is exported exactly as it
+// was written; a path contour is faceted by the kernel per quality tier (finer at
+// export) and becomes true CIRCLE edges on OCCT, so these are the ones to use for
+// any curve that shows or fits. The naming rule: *Profile = exact curves,
+// *Polygon = straight edges.
+
+const rad = (deg) => (deg * Math.PI) / 180;
+const polar = (r, deg) => [r * Math.cos(rad(deg)), r * Math.sin(rad(deg))];
+const SEG_EPS = 1e-9;
+
+// Accumulates a contour from `start`, dropping any line that would not move the pen
+// (a clamped rounded rect's straight run, a zero-length slot) — a zero-length
+// segment is a degenerate edge to every consumer downstream.
+function contourFrom(start) {
+  const segments = [];
+  let cur = start;
+  const moves = (p) => Math.hypot(p[0] - cur[0], p[1] - cur[1]) > SEG_EPS;
+  const api = {
+    line(to) { if (moves(to)) { segments.push({ to }); cur = to; } return api; },
+    arc(to, via) { segments.push({ to, via }); cur = to; return api; },
+    // Closes explicitly on `start`, so contour-ops' corner walk sees the real last edge.
+    close() { api.line(start); return { start, segments }; },
+  };
+  return api;
+}
+
+function checkSweep(name, arcDeg) {
+  if (!(arcDeg > 0 && arcDeg < 360))
+    throw new Error(`${name}: arcDeg must be between 0 and 360 (exclusive), got ${arcDeg}`);
+}
+
+// Annular sector from angle 0 to arcDeg: outer arc CCW, then the inner arc back.
+// arcDeg < 360 — a full ring is a region with a hole, so cut an inner cylinder from
+// an outer one (or extrude { outer, holes }) instead.
+export function ringSectorProfile(innerR, outerR, arcDeg) {
+  checkSweep("ringSectorProfile", arcDeg);
+  if (innerR === 0) throw new Error("ringSectorProfile: innerR must be > 0 — use pieProfile for a sector from the centre");
+  if (!(innerR > 0 && innerR < outerR))
+    throw new Error(`ringSectorProfile: innerR must be > 0 and < outerR, got innerR=${innerR}, outerR=${outerR}`);
+  return contourFrom([outerR, 0])
+    .arc(polar(outerR, arcDeg), polar(outerR, arcDeg / 2))
+    .line(polar(innerR, arcDeg))
+    .arc([innerR, 0], polar(innerR, arcDeg / 2))
+    .close();
+}
+
+// Circular sector ("pie slice") from the origin, radius tipR, from angle 0 to arcDeg.
+export function pieProfile(tipR, arcDeg) {
+  if (!(tipR > 0)) throw new Error(`pieProfile: tipR must be > 0, got ${tipR}`);
+  checkSweep("pieProfile", arcDeg);
+  return contourFrom([0, 0])
+    .line([tipR, 0])
+    .arc(polar(tipR, arcDeg), polar(tipR, arcDeg / 2))
+    .close();
+}
+
+// Stadium slot: two r-radius semicircles whose centres are `length` apart (overall
+// length = length + 2r), centred on the origin, long axis along X. length 0 is a circle.
+export function slotProfile(length, r) {
+  if (!(r > 0)) throw new Error(`slotProfile: r must be > 0, got ${r}`);
+  if (!(length >= 0)) throw new Error(`slotProfile: length must be ≥ 0, got ${length}`);
+  const hl = length / 2;
+  return contourFrom([hl, -r])
+    .arc([hl, r], [hl + r, 0])
+    .line([-hl, r])
+    .arc([-hl, -r], [-hl - r, 0])
+    .close();
+}
+
+// w × h rectangle centred on the origin with radius-r corners; r is clamped to
+// min(w, h)/2 like roundedRectPolygon's (fully clamped, it is a stadium or a circle),
+// and r ≤ 0 is the plain rectangle.
+export function roundedRectProfile(w, h, r) {
+  if (!(w > 0 && h > 0)) throw new Error(`roundedRectProfile: w and h must be > 0, got w=${w}, h=${h}`);
+  if (!Number.isFinite(r)) throw new Error(`roundedRectProfile: r must be a finite number (0 for square corners), got ${r}`);
+  const hw = w / 2, hh = h / 2;
+  const rr = Math.max(0, Math.min(r, Math.min(w, h) / 2));
+  if (rr === 0) return contourFrom([hw, -hh]).line([hw, hh]).line([-hw, hh]).line([-hw, -hh]).close();
+  const m = rr * (1 - Math.SQRT1_2);   // a corner arc's midpoint sits m in from both edges
+  return contourFrom([hw, hh - rr])
+    .arc([hw - rr, hh], [hw - m, hh - m])
+    .line([-(hw - rr), hh])
+    .arc([-hw, hh - rr], [-(hw - m), hh - m])
+    .line([-hw, -(hh - rr)])
+    .arc([-(hw - rr), -hh], [-(hw - m), -(hh - m)])
+    .line([hw - rr, -hh])
+    .arc([hw, -(hh - rr)], [hw - m, -(hh - m)])
+    .close();
+}
+
 const PATTERN_AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
 
 // `count` copies of `solid` translated by i*step ([dx,dy,dz]) for i in 0..count-1.
@@ -302,11 +397,12 @@ export function circularPattern(solid, count, { center = [0, 0, 0], axis = "Z",
   return out;
 }
 
-// CCW circle of radius r centered at [cx, cy]. A shared 2-D profile primitive:
-// compose with the kernel's profile ops — e.g. revolve(circleProfile(minorR,
-// [majorR, 0])) is a torus, prism(circleProfile(r), h) a cylinder.
-export function circleProfile(r, center = [0, 0], segs = 48) {
-  if (!(r > 0)) throw new Error("circleProfile: r must be > 0");
+// CCW circle of radius r centred at [cx, cy] as a FIXED point list of `segs` vertices
+// (default 48), starting at angle 0. The point-list circle: a deliberately faceted
+// circle, point math of your own (mapping, indexing), or anything that must stay
+// exactly as written. Exported unchanged at every quality tier.
+export function circlePolygon(r, center = [0, 0], segs = 48) {
+  if (!(r > 0)) throw new Error("circlePolygon: r must be > 0");
   const [cx, cy] = center;
   const pts = [];
   for (let i = 0; i < segs; i++) {
@@ -316,6 +412,17 @@ export function circleProfile(r, center = [0, 0], segs = 48) {
   return pts;
 }
 
+// A circle for passing to a kernel op (prism, extrude outline or hole, shape2d, revolve,
+// hull, loft, sweep). TRANSITIONAL: today it returns exactly circlePolygon's 48 points;
+// partforge 0.132 turns it into an exact curve like the other *Profile helpers. Stored
+// parts that do point math on it are migrated to circlePolygon before that release
+// (see docs/superpowers/specs/2026-09-28-curve-profile-helpers-design.md), so new code
+// should never map, index or spread its result — use circlePolygon for that.
+export function circleProfile(r, center = [0, 0], segs = 48) {
+  if (!(r > 0)) throw new Error("circleProfile: r must be > 0");
+  return circlePolygon(r, center, segs);
+}
+
 // --- offsetPolygon ---------------------------------------------------------
 
 const OFFSET_EPS = 1e-9;
@@ -400,13 +507,17 @@ function lineIntersect(p, dp, q, dq) {
 // derive() and build() alike. See AUTHORING-PARTS.md "Profiles & patterns".
 export function offsetPolygon(profile, delta, opts = {}) {
   const { corners = "round", segs = 8 } = opts;
+  // A path contour is sampled to points first (48 per circle), since this offset is a
+  // point-list operation; k.shape2d(profile).offset(delta) offsets arcs exactly instead.
+  if (isPathContour(profile)) return offsetPolygon(contourToPoints(profile), delta, opts);
   if (profile !== null && typeof profile === "object" && !Array.isArray(profile)) {
-    if (!Array.isArray(profile.outer)) throw new Error("offsetPolygon: profile must be a point list or {outer, holes}");
-    const region = { outer: offsetPolygon(profile.outer, delta, opts) };
-    if (profile.holes) region.holes = profile.holes.map((h) => offsetPolygon(h, -delta, opts));
+    const ring = (c) => (isPathContour(c) ? contourToPoints(c) : c);
+    if (!Array.isArray(ring(profile.outer))) throw new Error("offsetPolygon: profile must be a point list, a path contour, or {outer, holes}");
+    const region = { outer: offsetPolygon(ring(profile.outer), delta, opts) };
+    if (profile.holes) region.holes = profile.holes.map((h) => offsetPolygon(ring(h), -delta, opts));
     return region;
   }
-  if (!Array.isArray(profile)) throw new Error("offsetPolygon: profile must be a point list or {outer, holes}");
+  if (!Array.isArray(profile)) throw new Error("offsetPolygon: profile must be a point list, a path contour, or {outer, holes}");
   if (typeof delta !== "number" || !Number.isFinite(delta)) throw new Error("offsetPolygon: delta must be a finite number");
   if (corners !== "round" && corners !== "chamfer" && corners !== "sharp")
     throw new Error('offsetPolygon: corners must be "round" | "chamfer" | "sharp"');

package/src/framework/geometry/profile-warnings.js

@@ -70,13 +70,168 @@ export function profileWarningMessages(prefix, profile) {
   return msgs;
 }
 
+// ── Sampled arcs ─────────────────────────────────────────────────────────────
+// A point list is built and exported exactly as written, so an arc sampled into it —
+// by a round *Polygon helper or a hand-written Math.cos loop — keeps its facets in
+// every export, where a path-contour arc is faceted by the kernel and refined for
+// print. A 36° bayonet lug from ringSectorPolygon at r = 30 mm had four 9° facets,
+// ~0.09 mm inside the true arc, on a fit with 0.25 mm of clearance (partforge-cloud
+// feedback #144). Nothing said so. This finds such runs and reports the worst one.
+//
+// A run is a stretch of consecutive vertices that all turn the same small amount
+// (≤ SAMPLED_ARC_MAX_STEP_DEG) between edges of one length — equal chords at equal turns
+// lie on one circle, and the turn IS the angular step. Its two END facets may be shorter
+// than the interior ones and still count: an offset or a boolean trims the first and last
+// facet of a sampled arc but leaves its turns alone (a clearance-shrunk lug is the #144
+// case exactly). A run is reported when it spans ≥ SAMPLED_ARC_MIN_EDGES facets and its
+// chord sits more than SAMPLED_ARC_SAG_MM inside the true arc. The step bound keeps
+// deliberate polygons out (a hexagon turns 60°, an octagon 45°); the sag bound keeps out
+// arcs sampled finely enough, or small enough, that no print shows it (a 48-gon hole
+// under ~23 mm radius, a dense loop). Two-facet arcs are not reported: one turn between
+// two edges cannot be told from a deliberate bend.
+export const SAMPLED_ARC_SAG_MM = 0.05;
+export const SAMPLED_ARC_MAX_STEP_DEG = 20;
+export const SAMPLED_ARC_MIN_EDGES = 3;
+const REL_TOL = 1e-4;
+// Absolute point noise tolerated in an authored or derived point list: coordinates
+// rounded to 0.01 mm (toFixed(2)), or passed through a transform or an offset.
+const NOISE_MM = 0.01;
+
+const SAMPLED_ARC_COACH =
+  "a point list is built and exported exactly as written, so a print shows those facets. " +
+  "Build curves with the *Profile helpers (ringSectorProfile, slotProfile, pieProfile, " +
+  "roundedRectProfile, roundedProfile) or pathProfile().arcTo(…) — the kernel facets those, finer at export.";
+
+// The worst sampled-arc run in one closed point ring, or null.
+// → { r, stepDeg, sag } for the run with the largest chord sagitta.
+export function worstSampledArc(ring) {
+  if (!Array.isArray(ring)) return null;
+  let pts = ring;
+  const [fx, fy] = pts[0] ?? [], [lx, ly] = pts[pts.length - 1] ?? [];
+  if (pts.length > 1 && Math.hypot(lx - fx, ly - fy) < 1e-12) pts = pts.slice(0, -1);   // explicit closure
+  const n = pts.length;
+  if (n < SAMPLED_ARC_MIN_EDGES + 1 || n > PROFILE_VALIDATE_MAX_SEGMENTS) return null;
+  // edge i runs p[i] → p[i+1]; junction i is the turn from edge i into edge i+1
+  const len = [], dir = [];
+  for (let i = 0; i < n; i++) {
+    const [ax, ay] = pts[i], [bx, by] = pts[(i + 1) % n];
+    len.push(Math.hypot(bx - ax, by - ay));
+    dir.push(Math.atan2(by - ay, bx - ax));
+  }
+  const turn = dir.map((d, i) => {
+    let t = dir[(i + 1) % n] - d;
+    while (t <= -Math.PI) t += 2 * Math.PI;
+    while (t > Math.PI) t -= 2 * Math.PI;
+    return t;
+  });
+  const maxStep = (SAMPLED_ARC_MAX_STEP_DEG * Math.PI) / 180;
+  const lenTol = (L) => Math.max(REL_TOL * L, 2 * NOISE_MM);
+  const arcTurn = (i) => { const t = Math.abs(turn[i]); return t > 1e-9 && t <= maxStep + 1e-12; };
+  // Junction i turns like junction i-1 across edge i (their shared edge): same direction,
+  // same amount within the noise an edge of that length can put on a direction.
+  const sameTurn = (i) => {
+    const p = (i - 1 + n) % n;
+    if (!arcTurn(p) || !arcTurn(i) || !(len[i] > 1e-12) || Math.sign(turn[i]) !== Math.sign(turn[p])) return false;
+    return Math.abs(turn[i] - turn[p]) <= Math.max(REL_TOL * Math.abs(turn[p]), (4 * NOISE_MM) / len[i]);
+  };
+  let worst = null;
+  // A run of k ≥ 2 junctions from `first`: interior edges first+1 … first+k-1, all of
+  // length L; the end facets (edges first and first+k) count when no longer than L.
+  const consider = (first, k, L, turnSum) => {
+    if (k < 2) return;
+    const endLen = [len[first], len[(first + k) % n]];
+    const edges = (k - 1) + endLen.filter((e) => e <= L + lenTol(L)).length;
+    if (edges < SAMPLED_ARC_MIN_EDGES) return;
+    const step = Math.abs(turnSum / k);
+    const r = L / (2 * Math.sin(step / 2));
+    const sag = r * (1 - Math.cos(step / 2));
+    if (sag > SAMPLED_ARC_SAG_MM && (!worst || sag > worst.sag))
+      worst = { r, stepDeg: (step * 180) / Math.PI, sag };
+  };
+  // Start the walk at a turn break so no run is split across the wrap. A ring with no
+  // break (a regular n-gon, a circleProfile) is one run all the way round.
+  let start = -1;
+  for (let i = 0; i < n; i++) if (!sameTurn(i)) { start = i; break; }
+  if (start === -1) {
+    const L = len[0];
+    if (arcTurn(0) && len.every((e) => Math.abs(e - L) <= lenTol(L))) {
+      const step = Math.abs(turn.reduce((a, t) => a + t, 0) / n);
+      const r = L / (2 * Math.sin(step / 2)), sag = r * (1 - Math.cos(step / 2));
+      if (sag > SAMPLED_ARC_SAG_MM) worst = { r, stepDeg: (step * 180) / Math.PI, sag };
+    }
+    return worst;
+  }
+  let first = start, k = 1, L = NaN, turnSum = turn[start];
+  for (let s = 1; s <= n; s++) {
+    const i = (start + s) % n;
+    // junction i extends the run when it turns alike AND its incoming edge (edge i, an
+    // interior edge of the run) matches the run's interior length
+    if (s < n && sameTurn(i) && (k === 1 || Math.abs(len[i] - L) <= lenTol(L))) {
+      if (k === 1) L = len[i];
+      k++; turnSum += turn[i];
+      continue;
+    }
+    consider(first, k, L, turnSum);
+    // a length break still leaves junction i turning alike with i-1: it may start a new
+    // run that shares that junction, so restart from i-1 when that is the case
+    if (s < n && sameTurn(i) && k > 1) {
+      first = (i - 1 + n) % n; k = 2; L = len[i]; turnSum = turn[first] + turn[i];
+    } else {
+      first = i; k = 1; L = NaN; turnSum = turn[i];
+    }
+  }
+  return worst;
+}
+
+// One message per profile naming its worst sampled arc, or [] when none shows. Only
+// point-list rings are examined: a path contour or a Shape2D carries its arcs
+// symbolically, so the kernel already facets them per tier.
+export function sampledArcMessages(prefix, profile) {
+  if (!profile || profile._shape2d) return [];
+  const rings = Array.isArray(profile)
+    ? [profile]
+    : profile.outer ? [profile.outer, ...(Array.isArray(profile.holes) ? profile.holes : [])] : [];
+  let worst = null;
+  for (const ring of rings) {
+    if (!Array.isArray(ring) || !Array.isArray(ring[0])) continue;   // a contour ring: exact
+    const w = worstSampledArc(ring);
+    if (w && (!worst || w.sag > worst.sag)) worst = w;
+  }
+  if (!worst) return [];
+  return [
+    `${prefix} traces an arc in straight facets (radius ≈ ${worst.r.toFixed(1)} mm, ` +
+    `${worst.stepDeg.toFixed(1)}° per facet, up to ${worst.sag.toFixed(2)} mm inside the true curve) — ` +
+    SAMPLED_ARC_COACH,
+  ];
+}
+
+// Sampled-arc lines per build. Each names a different radius, so dedupe alone does not
+// bound them, and the warning list is shared with every other degrade in the build.
+export const SAMPLED_ARC_MAX_PER_BUILD = 3;
+
 // A per-kernel warner: `warn` records each distinct message at most once until
 // `reset` (the backend calls reset inside takeBuildWarnings, i.e. per drain).
+// `opts.sampledArcs` also reports a coarsely sampled arc — asked for only by the ops
+// where a path contour would be refined instead (prism, extrude, revolve, shape2d); loft
+// and sweep sample curve rings at their own fixed LOD, so the advice would not hold
+// there. `opts.crossings: false` skips the self-intersection check (a caller that
+// validates the same outline again downstream). `warn.quietArcs(fn)` runs a kernel
+// composition that tessellates curves itself (a rim bevel, a screw sweep) without
+// blaming its points on the author, who wrote curves.
 export function makeProfileWarner(recordWarning) {
   const seen = new Set();
-  const warn = (prefix, profile) => {
+  let quiet = 0, arcLines = 0;
+  const warn = (prefix, profile, opts) => {
     if (typeof recordWarning !== "function") return;
-    for (const msg of profileWarningMessages(prefix, profile)) {
+    const msgs = opts?.crossings === false ? [] : profileWarningMessages(prefix, profile);
+    if (opts?.sampledArcs && quiet === 0 && arcLines < SAMPLED_ARC_MAX_PER_BUILD) {
+      for (const msg of sampledArcMessages(prefix, profile)) {
+        if (seen.has(msg) || arcLines >= SAMPLED_ARC_MAX_PER_BUILD) continue;
+        arcLines++;
+        msgs.push(msg);
+      }
+    }
+    for (const msg of msgs) {
       if (seen.has(msg)) continue;
       seen.add(msg);
       recordWarning(msg);
@@ -89,5 +244,9 @@ export function makeProfileWarner(recordWarning) {
   // reaches paper.js through contour-ops.js.
   warn.segmentCount = profileSegmentCount;
   warn.maxSegments = PROFILE_VALIDATE_MAX_SEGMENTS;
-  return { reset: () => seen.clear(), warn };
+  warn.quietArcs = (fn) => {
+    quiet++;
+    try { return fn(); } finally { quiet--; }
+  };
+  return { reset: () => { seen.clear(); arcLines = 0; }, warn };
 }

package/src/framework/geometry/profile.js

@@ -209,6 +209,19 @@ export function tessellateContour(contour, segs) {
   return out;
 }
 
+// A path contour as a plain point ring for the consumers that take point lists only
+// (sweep's stations, offsetPolygon): sampled at a fixed full-circle resolution, not the
+// kernel's per-tier rule, with the explicit closing point dropped. 48 per circle is the
+// density circleProfile/circlePolygon has always had, so a circle swept or offset as a
+// curve comes out like the 48-gon that used to be passed there (sampleArc's ceiling can
+// add one facet at some radii — the same circle, one vertex finer).
+export const CURVE_POINT_SEGS = 48;
+export function contourToPoints(contour, segs = CURVE_POINT_SEGS) {
+  const ring = tessellateContour(closeContourGap(contour), segs);
+  const first = ring[0], last = ring[ring.length - 1];
+  return Math.hypot(last[0] - first[0], last[1] - first[1]) < 1e-9 ? ring.slice(0, -1) : ring;
+}
+
 // Normalize + tessellate a whole region to { outer:[[x,y],…], holes:[[[x,y],…],…] } of
 // point rings, ready for CrossSection.ofPolygons on the Manifold path.
 export function tessellateProfile(profile, segs) {

package/src/framework/geometry/shape2d.js

@@ -60,7 +60,7 @@ export function makeShape2dFactory({ segs, extrude, revolve, recordWarning, warn
   const liftRegions = (x, { trusted = false } = {}) => {
     if (x && x._shape2d) return deepCopy(x._regions);
     checkProfile(x);
-    if (!trusted) warnProfile?.("shape2d: profile", x);
+    if (!trusted) warnProfile?.("shape2d: profile", x, { sampledArcs: true });
     return liftProfile(x).regions.map(ensureRegionWinding);
   };
 

package/src/framework/mount.js

@@ -526,7 +526,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // Lets the "error" case below tell a correlated tessellation failure apart
     // from an unrelated build error sharing the same message type, so it can
     // reset the latch instead of stranding it at "requested" forever.
-    // String-namespaced ("tess-N"), mirroring capture-build.js's "cap-N" —
+    // String-namespaced ("tess-N"), mirroring capture-build.js's "cap-" ids —
     // this request shares the OCCT worker's message space with
     // export-controller's "export-"/"warm-" jobIds, and exportCtl.handleMessage
     // (called before mount's own switch, below) claims every id in its own
@@ -1015,6 +1015,8 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       if (exportCtl.handleMessage(data, onDownload)) return;
       // captureView's off-loop build channel: consume its replies before the
       // live `meshes` case — capture-meshes must never touch live cache/display.
+      // Like exportCtl, it also claims a disposed mount's late capture reply on
+      // a worker the host kept, so a stale "error" never reads as a failed build.
       if (captureBuild.handleMessage(data)) return;
       switch (data.type) {
         case "ready":

package/src/parts/bracket.js

@@ -4,9 +4,11 @@
 //   • cutAll      — four corner bolt holes drilled in one batch
 //   • cut         — a central bore
 //   • offset      — an optional print-clearance grow with rounded corners
-// The rounded corners and circular holes are true arcs (curve-native profiles), so
-// the whole outline stays curve-exact. Open /bracket.html after `npm run dev`.
-import { roundedRectPolygon, circleProfile } from "partforge/geometry";
+// The rounded corners and the clip disc are exact arcs (*Profile helpers; slotProfile(0, r)
+// is an exact circle), which the kernel refines at export. The small bolt holes use
+// circleProfile's fixed 48-gon, within 0.05 mm of round at this size.
+// Open /bracket.html after `npm run dev`.
+import { roundedRectProfile, slotProfile, circleProfile } from "partforge/geometry";
 
 export default {
   meta: { title: "Cross bracket", units: "mm", background: 0x15181d, environment: "workshop" },
@@ -60,10 +62,10 @@ export default {
       export: { name: "cross-bracket" },
       display: { material: "powder-coat", color: 0x2b2f36 },
       build: (k, p) => {
-        const barH = k.shape2d(roundedRectPolygon(p.span, p.bar, p.corner));
-        const barV = k.shape2d(roundedRectPolygon(p.bar, p.span, p.corner));
+        const barH = k.shape2d(roundedRectProfile(p.span, p.bar, p.corner));
+        const barV = k.shape2d(roundedRectProfile(p.bar, p.span, p.corner));
         let plate = barH.union(barV);                                        // union
-        if (p.clip) plate = plate.intersect(k.shape2d(circleProfile(p.span / 2)));  // intersect
+        if (p.clip) plate = plate.intersect(k.shape2d(slotProfile(0, p.span / 2)));  // intersect (an exact disc)
         const d = p.span / 2 - p.inset;
         const holes = [[d, d], [-d, d], [d, -d], [-d, -d]].map((c) => circleProfile(p.hole_d / 2, c));
         plate = plate.cutAll(holes);                                         // batch cut

package/src/parts/gasket.js

@@ -10,7 +10,7 @@
 // on, so this build's `Shape2D.fillet` (backend-identical pure JS — KERNEL-CONTRACT.md
 // "One shared implementation") does not read as a CAD-only op, and the part
 // auto-routes to fast Manifold like any other non-B-rep part.
-import { pathProfile, circleProfile } from "partforge/geometry";
+import { pathProfile, circleProfile, circlePolygon } from "partforge/geometry";
 
 // Pure dimension math shared with test/gasket-part.test.js, which re-derives the same
 // 2-D profile with the free contour-ops/paper-bridge functions (no kernel) to check
@@ -77,7 +77,7 @@ export default {
         // Boss centers sit exactly ON the bottom edge (y = 0) — the coincident-edge
         // union case: each tab straddles the existing straight edge rather than
         // merely touching it at a point.
-        const tabs = [[-tabX, 0], [tabX, 0]].map(([cx, cy]) => circleProfile(tabR, [cx, cy], tabSegs));
+        const tabs = [[-tabX, 0], [tabX, 0]].map(([cx, cy]) => circlePolygon(tabR, [cx, cy], tabSegs));
 
         // Fillet the outer convex corners, THEN cut the bolt holes. Note this ordering
         // trades away the STEP-CIRCLE fidelity the "fillet after booleans" rule buys

package/src/parts/nameplate.js

@@ -3,7 +3,7 @@
 // exact curve regions, then either raised above (emboss) or cut into (deboss) a
 // rounded plate. The plate itself is a Shape2D rounded-rectangle, so the part also
 // exercises shape2d + the extrude/boolean path. Open /nameplate.html after `npm run dev`.
-import { roundedRectPolygon } from "partforge/geometry";
+import { roundedRectProfile } from "partforge/geometry";
 
 export default {
   meta: { title: "Nameplate", units: "mm", background: 0x15181d },
@@ -76,7 +76,7 @@ export default {
         const w = (bb.max[0] - bb.min[0]) + 2 * p.margin;
         const h = (bb.max[1] - bb.min[1]) + 2 * p.margin;
         const corner = Math.max(0, Math.min(p.corner, Math.min(w, h) / 2 - 0.5));
-        const plate = k.extrude({ profile: k.shape2d(roundedRectPolygon(w, h, corner)), h: p.thickness }).label("Plate");
+        const plate = k.extrude({ profile: k.shape2d(roundedRectProfile(w, h, corner)), h: p.thickness }).label("Plate");
         const relief = k.extrude({ profile: text, h: p.depth });
         return p.engrave
           ? plate.cut(relief.translate([0, 0, p.thickness - p.depth]))

package/types/geometry.d.ts

@@ -27,31 +27,54 @@ export type { ArcContour, Contour, Corner2D, CornerSelector, MirrorAxis2, Point2
  */
 export type ProfileInput = number[][] | Contour | Region2D | Region2D[];
 
-/** A pie/sector wedge with its tip at the origin. */
+/**
+ * A pie/sector wedge with its tip at the origin, as a FACETED point list.
+ * @deprecated Use `pieProfile` — its arc is exact and refined at export; this
+ * one's facets (32 per circle) are exported exactly as written.
+ */
 export function piePolygon(tipR: number, arcDeg: number, segs?: number): PointsContour;
 
 /** A regular hexagon of circumradius `r`. */
 export function hexPolygon(r: number): PointsContour;
 
-/** A `w` × `h` rectangle centred at the origin with corner radius `r`. */
+/**
+ * A `w` × `h` rectangle centred at the origin with corner radius `r`, as a FACETED point list.
+ * @deprecated Use `roundedRectProfile` — exact corner arcs, refined at export.
+ */
 export function roundedRectPolygon(w: number, h: number, r: number, segs?: number): PointsContour;
 
 /** A regular `n`-gon of circumradius `r`; `flat: true` seats a flat side down. */
 export function regularPolygon(n: number, r: number, opts?: { flat?: boolean }): PointsContour;
 
+/** An ellipse as a FACETED point list (`segs`, default 48) — there is no exact-curve form. */
 export function ellipsePolygon(rx: number, ry: number, segs?: number): PointsContour;
 
-/** A stadium/slot; overall length is `length + 2r`. */
+/**
+ * A stadium/slot; overall length is `length + 2r`, as a FACETED point list.
+ * @deprecated Use `slotProfile` — exact semicircles, refined at export.
+ */
 export function slotPolygon(length: number, r: number, segs?: number): PointsContour;
 
 export function starPolygon(points: number, outerR: number, innerR: number): PointsContour;
 
-/** An annular sector. `arcDeg` must be < 360 — a full ring is a contour-with-hole. */
+/**
+ * An annular sector, as a FACETED point list (32 facets per circle).
+ * @deprecated Use `ringSectorProfile` — exact arcs, refined at export.
+ */
 export function ringSectorPolygon(innerR: number, outerR: number, arcDeg: number, segs?: number): PointsContour;
 
 /**
- * A CCW circle of radius `r` centred at `center`, as a FACETED point list
- * (`segs` segments). For curve-exact corners use `roundedProfile`/`pathProfile`.
+ * A CCW circle of radius `r` centred at `center`, as a FIXED point list of `segs`
+ * vertices (default 48), starting at angle 0. The point-list circle: for a deliberately
+ * faceted circle or point math of your own (mapping, indexing).
+ */
+export function circlePolygon(r: number, center?: Point2, segs?: number): PointsContour;
+
+/**
+ * A circle for passing to a kernel op (prism, extrude outline or hole, shape2d, revolve,
+ * hull, loft, sweep). Transitional: today it returns exactly `circlePolygon`'s 48 points,
+ * and partforge 0.132 turns it into an exact curve like the other `*Profile` helpers —
+ * so never map, index or spread its result; use `circlePolygon` for point math.
  */
 export function circleProfile(r: number, center?: Point2, segs?: number): PointsContour;
 
@@ -69,7 +92,8 @@ export function cornerArc(
 
 /**
  * Round every corner of a CCW polygon, BAKING each arc into line facets — so
- * STEP corners are faceted. Use `roundedProfile` for true circular edges.
+ * STEP corners are faceted and export never refines them.
+ * @deprecated Use `roundedProfile` — the same corners, carried as exact arcs.
  */
 export function filletPolygon(points: PointsContour, r: number, opts?: { segs?: number }): PointsContour;
 
@@ -81,6 +105,24 @@ export function filletPolygon(points: PointsContour, r: number, opts?: { segs?:
  */
 export function roundedProfile(points: PointsContour, r: number | number[]): ArcContour;
 
+// ── Exact-curve profiles ──────────────────────────────────────────────────────
+// The naming rule: `*Profile` helpers return exact curves (a path contour whose arcs
+// the kernel facets per quality tier, finer at export, and OCCT keeps as true circles);
+// `*Polygon` helpers return straight-edged point lists, exported exactly as written.
+// Each of these traces the same outline as its `*Polygon` namesake.
+
+/** An annular sector from angle 0 to `arcDeg` (0 < arcDeg < 360; 0 < innerR < outerR). */
+export function ringSectorProfile(innerR: number, outerR: number, arcDeg: number): ArcContour;
+
+/** A circular sector ("pie slice") from the origin, radius `tipR`, from angle 0 to `arcDeg`. */
+export function pieProfile(tipR: number, arcDeg: number): ArcContour;
+
+/** A stadium slot: semicircle centres `length` apart (overall `length + 2r`); length 0 is a circle. */
+export function slotProfile(length: number, r: number): ArcContour;
+
+/** A `w` × `h` rectangle centred at the origin with radius-`r` corners (clamped to min(w, h)/2). */
+export function roundedRectProfile(w: number, h: number, r: number): ArcContour;
+
 /** The fluent builder `pathProfile` returns. `close()` snapshots the contour. */
 export interface PathProfileBuilder {
   lineTo(to: Point2): PathProfileBuilder;
@@ -105,12 +147,14 @@ export type OffsetCorners = "round" | "chamfer" | "sharp";
 
 /**
  * Offset a point-list polygon or an `{ outer, holes }` region by `delta` mm —
- * positive grows material, negative insets (regions offset material-wise).
+ * positive grows material, negative insets (regions offset material-wise). A path
+ * contour (or a region of them) is sampled to points first, 48 per circle, and the
+ * result is always point lists; `k.shape2d(profile).offset(delta)` keeps arcs exact.
  * Simple polygon in, simple polygon out: an offset that would collapse or split
  * the contour THROWS. Pure, so it works in `derive()` as well as `build()`.
  */
 export function offsetPolygon(
-  profile: PointsContour,
+  profile: PointsContour | ArcContour,
   delta: number,
   opts?: { corners?: OffsetCorners; segs?: number },
 ): PointsContour;

package/types/kernel.d.ts

@@ -359,7 +359,8 @@ export interface LoftOptions {
 }
 
 export interface SweepOptions {
-  profile: PointsContour;
+  /** A point list, or a `{start, segments}` path contour sampled to one (48 per circle). */
+  profile: PointsContour | ArcContour;
   /** A 3-D polyline, `[[x, y, z], …]`. */
   path: Point3[];
   /** Capless loop (must be planar) — Manifold only. */
@@ -370,7 +371,11 @@ export interface SweepOptions {
   smooth?: boolean;
 }
 
-/** `k.revolve` — a lathe profile `[[r, z], …]` with `r >= 0`, revolved about Z. */
+/**
+ * `k.revolve` — a lathe profile in `[r, z]` with `r >= 0`, revolved about Z: a point
+ * list, a `{start, segments}` path contour (lifted to a Shape2D, so its arcs stay
+ * exact), or a Shape2D.
+ */
 export interface RevolveOptions {
   profile: ProfileInput;
   degrees?: number;