partforge 0.16.0 → 0.19.0

package/docs/AUTHORING-PARTS.md

@@ -151,11 +151,18 @@ k.prism({ points: roundedProfile(bracketOutline, 3), h: 4 });  // true CIRCLE co
 // 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)
+
+// A tab with one free-form curved side (exact on STEP, faceted at mesh LOD):
+const tab = pathProfile([0, 0])
+  .lineTo([20, 0]).lineTo([20, 8])
+  .cubicTo([0, 8], [14, 16], [6, 16])   // curved top edge
+  .close();
+k.extrude({ profile: tab, h: 3 });
 ```
 
 2-D polygon helpers for `prism`/`extrude`/`loft`: `import { piePolygon, hexPolygon,
 regularPolygon, roundedRectPolygon, starPolygon, slotPolygon, circleProfile, filletPolygon,
-roundedProfile, offsetPolygon } from "partforge/geometry"`. `filletPolygon(points, r, { segs? })` rounds
+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[])`
@@ -173,6 +180,7 @@ an offset whose true result would collapse or split into multiple contours (e.g.
 dumbbell past its waist) **throws** a greppable error rather than returning degenerate
 geometry. Being pure, it works in `derive()` as well as `build()` — the natural home for
 clearance math.
+`pathProfile(start)` is a fluent builder for a curve-native path contour (`lineTo` / `arcTo` / `cubicTo` / `close`); cubic segments become exact B-rep spline edges on the OCCT/STEP backend and facet at the mesh LOD on Manifold — the same exact-vs-faceted split as `roundedProfile` arcs.
 **Import geometry helpers from `partforge/geometry`, never from `partforge`** — the main
 entry pulls in the DOM viewer/controls, and your build functions run in a Web Worker
 (importing the main entry there throws `document is not defined`).
@@ -466,6 +474,30 @@ const hole = k.cylinder({ r: 2, h: 20 }).translate([20, 0, 0]);
 body = body.cutAll(circularPattern(hole, 8, { axis: "Z" }));   // 8 bolt holes on a 40mm circle
 ```
 
+## 2-D booleans
+
+`k.shape2d(profile)` lifts a point list, arc profile, or region into a `Shape2D` — an opaque 2-D boolean value. You can then compose booleans, and feed the result directly to `extrude` or `revolve` without materializing intermediate regions. The same `content-hash caching` discipline applies: identical arguments produce identical geometry.
+
+**Shape2D booleans are a build-time operation** (not `derive()`), and the curve semantics differ between backends: on OCCT the result carries exact circular arcs and Bézier curves into STEP export; on Manifold the curves facet to mesh LOD.
+
+```js
+// Keyhole plate: union a disc onto a rect, punch a slot, extrude.
+const plate = k.shape2d(roundedRectPolygon(40, 24, 4))
+  .union(circleProfile(8))
+  .cut(slotPolygon(16, 3));
+k.extrude({ profile: plate, h: 3 });
+```
+
+```js
+// A 0.2 mm printer clearance around a bore, then a 2 mm wall inset:
+const bore  = k.shape2d(circleProfile(3)).offset(0.2);            // looser
+const wall  = k.shape2d(outer).offset(-2, { corners: "sharp" });  // inset, mitered
+```
+
+(This achieves the same geometry as building the profiles separately and using `k.extrude({ profile: { outer, holes }, h })`, but the Shape2D path is more idiomatic for complex 2-D operations.)
+
+`Shape2D.offset(delta, {corners})` grows (`delta>0`) or insets (`delta<0`) a shape with round/chamfer/sharp corners — curve-preserving on OCCT, faceted at mesh LOD on Manifold; it throws if the offset collapses the shape. (For `derive()`/main-thread clearance math on plain point lists, use the pure `offsetPolygon` helper instead.)
+
 ---
 
 ## Wiring a part into a runnable app

package/docs/ERROR-PATTERNS.md

@@ -221,6 +221,33 @@ Variant literals under this entry: `offsetPolygon: delta must be a finite number
 - **Cause:** the true offset of this shape at this `|delta|` is not a single simple polygon (e.g. insetting a dumbbell past its waist would split it in two) — out of `offsetPolygon`'s envelope.
 - **Fix:** reduce `|delta|`, or decompose the profile into separately-offset simple contours.
 
+## cubic-segment-mixes-arc-and-cubic
+
+- **Symptom:** `extrude: <role> segment cannot mix arc (via) and cubic (c1/c2)`
+- **Cause:** A path-contour segment carries both `via` (three-point arc) and `c1`/`c2` (cubic Bézier). A segment is exactly one kind.
+- **Fix:** Drop `via` for a cubic, or drop `c1`/`c2` for an arc. Use `pathProfile().arcTo(to, via)` or `.cubicTo(to, c1, c2)` to build segments.
+
+## cubic-segment-missing-controls
+
+- **Symptom:** `extrude: <role> cubic segment needs c1 and c2 as finite [x,y]`
+- **Cause:** A cubic segment is missing `c1` or `c2`, or a control point is not a finite `[x,y]` (e.g. `NaN`, wrong length).
+- **Fix:** Provide both control points as finite `[x,y]`. A cubic Bézier needs two controls between the previous point and `to`.
+
+## shape2d-simple-not-single-region
+
+- **Symptom:** `Shape2D.simple: result has N regions, not 1 (use toRegions())`
+- **Cause:** `.simple()` was called on a boolean result that is empty or split into multiple disjoint regions (e.g. `intersect` of disjoint shapes, or a `cut` that severs a shape in two).
+- **Fix:** Use `.toRegions()` to get the array, or adjust the operands so the result is a single connected region. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "2-D booleans".
+
+## shape2d-offset-collapses
+
+- **Symptom:** `Shape2D.offset: offset collapses the shape (reduce |delta|)`
+- **Cause:** A negative (inset) `offset` removed more than the shape's half-width,
+  leaving no geometry — or the delta is larger than the feature it offsets.
+- **Fix:** Reduce `|delta|`, or check the source profile is large enough for the
+  inset. Realistic clearances (fractions of a mm) and wall insets up to the
+  narrowest feature never trip this.
+
 # Hardware library
 
 Reserved for `hardware-*` patterns (issue #30). No entries yet.

package/package.json

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

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

@@ -8,7 +8,9 @@
 //     cache hashes normalized args;
 //   - default compound-op compositions — a backend only overrides one when it has
 //     a reason to (Manifold's boredCylinder hashes atomically for its solid cache);
-//   - a KernelCapabilityError stub for toSTEP when the backend can't write B-rep.
+//   - a KernelCapabilityError stub for toSTEP / shape2d when a backend lacks that
+//     capability (Manifold can't do toSTEP; both backends now define shape2d, so
+//     that stub is dead in practice — kept as a safety net for a future backend).
 // The per-Solid twin of this layer is addSugar() in solid-sugar.js.
 import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
@@ -31,6 +33,7 @@ export function finishKernel(k) {
   }
 
   k.toSTEP ??= () => { throw new KernelCapabilityError("toSTEP requires the OCCT backend"); };
+  k.shape2d ??= () => { throw new KernelCapabilityError("shape2d requires the Manifold backend"); };
 
   return k;
 }

package/src/framework/geometry/kernel.js

@@ -19,7 +19,7 @@ export const CONTRACT_VERSION = 1;
 // Ops every backend kernel must implement.
 export const KERNEL_OPS = [
   "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
-  "loft", "sweep", "helixSweptTube", "union", "toSTEP",
+  "loft", "sweep", "helixSweptTube", "union", "shape2d", "toSTEP",
 ];
 
 // Backend-optional kernel ops: the Manifold cache brackets + WASM lifetime hooks.
@@ -30,7 +30,7 @@ export const KERNEL_OPTIONAL_OPS = [
 
 // Ops every Solid must implement (including the sugar addSugar() attaches).
 export const SOLID_OPS = [
-  "cut", "cutAll", "intersect", "clone", "label", "boundingBox", "volume",
+  "cut", "cutAll", "intersect", "union", "clone", "label", "boundingBox", "volume",
   "translate", "rotate", "rotateX", "rotateY", "rotateZ", "rotateAbout", "along", "at",
   "mirror", "scale", "toMesh", "toSTL", "toIndexedMesh",
   "fillet", "chamfer", "shell",
@@ -40,6 +40,11 @@ export const SOLID_OPS = [
 // guards with `typeof`); OCCT has no cheap equivalent.
 export const SOLID_OPTIONAL_OPS = ["genus", "isEmpty"];
 
+// Public methods every Shape2D exposes (2-D boolean value; contract-linted).
+export const SHAPE2D_OPS = [
+  "union", "cut", "cutAll", "intersect", "offset", "area", "boundingBox", "toRegions", "simple", "clone",
+];
+
 // Solid ops only OCCT implements natively. Single source of truth: probe.js routes
 // a part to OCCT when its build uses one of these, and the Manifold backend
 // generates its KernelCapabilityError stubs from the same list — adding an op here
@@ -51,6 +56,7 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(tool: Solid) => Solid} cut
  * @property {(tools: Solid[]) => Solid} cutAll      batch subtract (backend-optimized)
  * @property {(other: Solid) => Solid} intersect     boolean intersection (both backends)
+ * @property {(other: Solid) => Solid} union         boolean union with one other solid (n-ary: k.union([...]))
  * @property {() => Solid} clone   independent copy (replicad consumes solids on transform)
  * @property {(name: string) => Solid} label   name this solid's surface for hover/pick feature attribution (survives transforms + booleans; same name on several solids merges into one feature)
  * @property {() => {min:number[],max:number[],center:number[],size:number[]}} boundingBox   axis-aligned bounds (query)
@@ -75,6 +81,17 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {() => number} [genus]     through-hole count (Manifold only)
  * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)
  *
+ * @typedef {Object} Shape2D  An opaque 2-D boolean value (both backends: Manifold wraps a CrossSection, OCCT a replicad Drawing). `_`-prefixed keys are backend internals.
+ * @property {(other: Shape2D|number[][]) => Shape2D} union
+ * @property {(other: Shape2D|number[][]) => Shape2D} cut
+ * @property {(others: (Shape2D|number[][])[]) => Shape2D} cutAll   batch subtract
+ * @property {(other: Shape2D|number[][]) => Shape2D} intersect
+ * @property {() => number} area   net area (outers minus holes), mm²
+ * @property {() => {min:number[],max:number[]}} boundingBox   axis-aligned 2-D bounds
+ * @property {() => {outer:number[][],holes:number[][][]}[]} toRegions   materialize into region arrays (assembleRegions)
+ * @property {() => {outer:number[][],holes:number[][][]}} simple   toRegions(), unwrapped — throws unless exactly 1 region
+ * @property {() => Shape2D} clone   independent handle
+ *
  * @typedef {Object} GeometryKernel
  * @property {(o:{r?:number,d?:number,r1?:number,r2?:number,d1?:number,d2?:number,h:number,center?:boolean}) => Solid} cylinder   canonical: {r|d,h} straight, {r1,r2,h}|{d1,d2,h} cone; legacy (rBottom,rTop,h,opts) accepted until contract v2
  * @property {(o:{od:number,h:number,bore:number}) => Solid} boredCylinder   compound: bored-through cylinder (one cache node)
@@ -87,6 +104,7 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(o:{profile:number[][],degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted until v2
  * @property {(o:{pathR:number,profileR:number,pitch:number,turns:number,z0:number,lefthand:boolean}) => Solid} helixSweptTube
  * @property {(solids:Solid[]) => Solid} union
+ * @property {(profile: number[][]|{outer:number[][],holes?:number[][][]}|Shape2D) => Shape2D} shape2d   2-D boolean value (both backends: Manifold wraps a CrossSection, OCCT a replicad Drawing)
  * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only (Manifold throws KernelCapabilityError)
  * @property {(name:string) => void} [beginSubPart]   open a per-sub-part solid-cache round (Manifold only)
  * @property {() => void} [endSubPart]                close the cache round (always pair with beginSubPart)

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

@@ -5,6 +5,8 @@ import { tessellateContour, tessellateProfile } from "./profile.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
 import { addSugar } from "./solid-sugar.js";
+import { addShape2dSugar } from "./shape2d-sugar.js";
+import { assembleRegions } from "./shape2d-regions.js";
 import { finishKernel } from "./kernel-front.js";
 
 const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
@@ -49,6 +51,63 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     return { value: wrap(m, hash), pin: m, dispose: () => m.delete?.() };
   });
 
+  // 2-D cross-section value. Mirrors wrap()/cached(): booleans route through the
+  // solid cache (dispose frees the CrossSection); operands fold by _hash.
+  const cachedCS = (hash, computeCS) => cache.lookup(hash, () => {
+    const cs = computeCS();                     // already T()-tracked
+    return { value: wrapShape2d(cs, hash), pin: cs, dispose: () => cs.delete?.() };
+  });
+  const liftCS = (x) => (x && x._shape2d ? x : shape2d(x));
+  const wrapShape2d = (cs, hash) => addShape2dSugar({
+    _cs: cs,
+    _shape2d: true,
+    _hash: hash,
+    union:     (o) => { const t = liftCS(o); return cachedCS(h("union2d", hash, t._hash), () => T(cs.add(t._cs))); },
+    cut:       (o) => { const t = liftCS(o); return cachedCS(h("cut2d", hash, t._hash), () => T(cs.subtract(t._cs))); },
+    cutAll:    (os) => {
+      if (os.length === 0) return wrapShape2d(cs, hash);            // identity — no new WASM / cache entry (avoids double-free)
+      const ts = os.map(liftCS);
+      // The reducer's inner T() already tracks every step (incl. the final) — no
+      // outer T() around the reduce, or the result lands in `tracked` twice and
+      // cleanup() double-frees it. os is non-empty here, so the seed cs is never
+      // returned; the result is always a fresh subtract, never aliasing the input.
+      return cachedCS(h("cutAll2d", hash, ts.map((t) => t._hash)), () => ts.reduce((acc, t) => T(acc.subtract(t._cs)), cs));
+    },
+    intersect: (o) => { const t = liftCS(o); return cachedCS(h("intersect2d", hash, t._hash), () => T(cs.intersect(t._cs))); },
+    offset: (delta, { corners = "round", segs: nSeg = segs } = {}) => {
+      if (!["round", "chamfer", "sharp"].includes(corners))
+        throw new Error('Shape2D.offset: corners must be "round" | "chamfer" | "sharp"');
+      if (!Number.isFinite(delta)) throw new Error("Shape2D.offset: delta must be a finite number");
+      // chamfer is a true 45° bevel — Clipper2 has no bevel join, but a Round join
+      // forced to a single chord per corner (circularSegments=4 → 1 segment per corner
+      // whose turn ≤ 90°, i.e. interior angle ≥ 90°) IS the bevel: round's tangent points
+      // are exactly the bevel's endpoints. Matches OCCT's `bevel` to float precision for
+      // interior angle ≥ 90° (square 142.0000, pentagon 298.920). At acute (<90°) convex
+      // corners Clipper2 emits 2 chords (ceil(turn/90°)), so Manifold bulges ~0.4% beyond
+      // OCCT's single-chord bevel there. round = arc at mesh LOD; sharp = miter.
+      const [joinType, cseg] = corners === "sharp" ? ["Miter", nSeg]
+        : corners === "chamfer" ? ["Round", 4]
+        : ["Round", nSeg];
+      return cachedCS(h("offset2d", hash, delta, corners, cseg), () => {
+        const out = T(cs.offset(delta, joinType, 2, cseg));       // miterLimit 2 (Clipper2 default)
+        if (out.numContour() === 0) throw new Error("Shape2D.offset: offset collapses the shape (reduce |delta|)");
+        return out;
+      });
+    },
+    area: () => cs.area(),
+    boundingBox: () => { const r = cs.bounds(); return { min: [r.min[0], r.min[1]], max: [r.max[0], r.max[1]] }; },
+    toRegions: () => assembleRegions(cs.toPolygons()),
+    clone: () => wrapShape2d(cs, hash),
+  });
+  const shape2d = (profile) => {
+    if (profile && profile._shape2d) return profile;                // idempotent
+    const hash = h("shape2d", profile, segs);
+    return cachedCS(hash, () => {
+      const { outer, holes } = tessellateProfile(profile, segs);
+      return T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
+    });
+  };
+
   // Copy the mesh out into JS-owned arrays (so it survives cleanup) and free the
   // transient mesh handle.
   function meshOut(m, asStl) {
@@ -82,6 +141,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     cutAll: (tools) => cached(h("cutAll", hash, tools.map((t) => t._hash)),
       () => T(m.subtract(unionRaw(tools.map((t) => t._m))))),
     intersect: (t) => cached(h("intersect", hash, t._hash), () => T(m.intersect(t._m))),
+    union: (t) => cached(h("union", [hash, t._hash]), () => unionRaw([m, t._m])),
     clone: () => wrap(m, hash),
     // Name this solid's surface for hover/pick feature attribution. asOriginal()
     // stamps a fresh originalID that survives transforms and booleans, so every
@@ -152,14 +212,21 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       }),
     // Polygon-with-holes extrude in one op: even/odd fill turns the extra contours into
     // holes regardless of their winding (outer + holes, no per-hole boolean cut).
-    extrude: (profile, height, { twist = 0, scaleTop = 1 } = {}) =>
-      cached(h("extrude", profile, height, twist, scaleTop, segs), () => {
-        const { outer, holes } = tessellateProfile(profile, segs);
-        const cs = T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
+    // A Shape2D `profile` (already a CrossSection, possibly multi-region) extrudes
+    // directly off its own `_cs` — no re-tessellation — and folds into the cache
+    // key by `_hash` like any other solid operand.
+    extrude: (profile, height, { twist = 0, scaleTop = 1 } = {}) => {
+      const shape = profile && profile._shape2d ? profile : null;
+      return cached(h("extrude", shape ? shape._hash : profile, height, twist, scaleTop, segs), () => {
+        const cs = shape ? shape._cs : (() => {
+          const { outer, holes } = tessellateProfile(profile, segs);
+          return T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
+        })();
         if (twist === 0 && scaleTop === 1) return T(cs.extrude(height));
         const nDiv = Math.max(1, Math.ceil(Math.abs(twist) / 5));
         return T(cs.extrude(height, nDiv, twist, [scaleTop, scaleTop]));
-      }),
+      });
+    },
     // 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.
     loft: (rings, opts = {}) => cached(h("loft", rings, opts), () => T(loftMesh(wasm, rings, opts))),
@@ -169,9 +236,13 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // (closed/cornerRadius) so a shape change is a fresh node and an identical rebuild hits.
     sweep: (profile, path, opts = {}) => cached(h("sweep", profile, path, opts), () => T(sweepMesh(wasm, profile, path, opts))),
     helixSweptTube: (o) => cached(h("helixSweptTube", o, tube), () => T(helixTube(wasm, { ...o, ...tube }))),
-    revolve: (pts, { degrees = 360 } = {}) =>
-      cached(h("revolve", pts, degrees, segs), () => T(Manifold.revolve([pts], segs, degrees))),
+    revolve: (pts, { degrees = 360 } = {}) => {
+      if (pts && pts._shape2d)
+        return cached(h("revolve", pts._hash, degrees, segs), () => T(pts._cs.revolve(segs, degrees)));
+      return cached(h("revolve", pts, degrees, segs), () => T(Manifold.revolve([pts], segs, degrees)));
+    },
     union: (solids) => cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
+    shape2d,
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     cacheStats: () => cache.stats(),

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

@@ -4,6 +4,8 @@
 import { toEdgeFinder } from "./edge-selector.js";
 import { toFaceFinder } from "./face-selector.js";
 import { addSugar } from "./solid-sugar.js";
+import { addShape2dSugar } from "./shape2d-sugar.js";
+import { assembleRegions, svgPathToRings, regionsArea, pointInRing, ringArea } from "./shape2d-regions.js";
 import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
@@ -36,6 +38,7 @@ export function createOcctKernel(replicad) {
       [...cloneLabels(labels), ...tools.flatMap((t) => cloneLabels(t._labels ?? []))]
     ),
     intersect: (t) => wrap(shape.intersect(t._s), [...cloneLabels(labels), ...cloneLabels(t._labels ?? [])]),
+    union: (t) => wrap(shape.fuse(t._s), [...cloneLabels(labels), ...cloneLabels(t._labels ?? [])]),
     clone: () => wrap(shape.clone(), cloneLabels(labels)),
     boundingBox: () => {
       const [min, max] = shape.boundingBox.bounds; // addSugar derives center/size
@@ -89,8 +92,9 @@ export function createOcctKernel(replicad) {
   // Draw a closed Drawing from a Contour: a legacy 2-D point list (all straight edges,
   // the former polyDrawing) OR an ArcContour whose { to, via } segments become true
   // OCCT arc edges via threePointsArcTo — so a rounded corner survives to STEP as a
-  // real CIRCLE B-rep entity, not a fan of LINEs. close() joins the last point back to
-  // the start with a straight edge (mirrors the implied ArcContour closure).
+  // real CIRCLE B-rep entity, not a fan of LINEs. Cubic segments ({ to, c1, c2 })
+  // map to cubicBezierCurveTo for exact B-rep spline edges. close() joins the last
+  // point back to the start with a straight edge (mirrors the implied ArcContour closure).
   const contourDrawing = (contour) => {
     if (Array.isArray(contour)) {
       let pen = draw(contour[0]);
@@ -98,10 +102,97 @@ export function createOcctKernel(replicad) {
       return pen.close();
     }
     let pen = draw(contour.start);
-    for (const seg of contour.segments) pen = seg.via ? pen.threePointsArcTo(seg.to, seg.via) : pen.lineTo(seg.to);
+    for (const seg of contour.segments)
+      pen = seg.c1 ? pen.cubicBezierCurveTo(seg.to, seg.c1, seg.c2)
+          : seg.via ? pen.threePointsArcTo(seg.to, seg.via)
+          : pen.lineTo(seg.to);
     return pen.close();
   };
 
+  // Region (outer + holes) -> Drawing, exactly like extrude's former inline region
+  // path: draw the outer contour, then .cut() each hole Drawing out of it.
+  const SHAPE2D_SEGS = 64;   // materialization LOD for toRegions() discretization
+  const drawingFromProfile = (profile) => {
+    const { outer, holes } = normalizeProfile(profile);
+    let region = contourDrawing(outer);
+    for (const hole of holes) region = region.cut(contourDrawing(hole));
+    return region;
+  };
+  const liftDrawing = (x) => (x && x._shape2d ? x : shape2d(x));
+  // Materialize a replicad Drawing into flat rings ready for the shared
+  // assembleRegions (which buckets outer/hole by ring winding SIGN). TWO
+  // corrections here, both confirmed against real replicad output rather than
+  // guessed (see task-4-report.md's probe results):
+  //
+  // 1. toSVGPathD() renders in SVG's y-down convention, so every coordinate is
+  //    negated back to model space.
+  // 2. Drawing.toSVGPaths() nests 0-2 levels deep depending on the result shape,
+  //    INCONSISTENTLY — e.g. a single interior hole nests as
+  //    [[outerD, holeD]], but two disjoint holes built via sequential .cut()
+  //    calls (cutAll) come back as a flat [outerD, hole1D, hole2D] with no
+  //    grouping at all. So which array position is "the outer" can't be read off
+  //    the nesting shape. Worse: unlike Manifold's CrossSection.toPolygons()
+  //    (outer CCW/positive, hole CW/negative), replicad emits EVERY loop of a
+  //    region — outer or hole — with the same rotational sense, so ring winding
+  //    carries no outer/hole signal either (verified: an interior hole in a
+  //    20x20 square, classified by sign alone, came back as 2 disjoint "outer"
+  //    regions summing 400+36 instead of one region netting 364).
+  //    The one signal that IS reliable is geometric containment DEPTH: classify
+  //    each ring by how many OTHER rings contain it (even-odd nesting), then
+  //    force each ring's winding to match its depth parity ABSOLUTELY — even depth
+  //    is an outer (CCW / positive area), odd depth is a hole (CW / negative area).
+  //    Setting the orientation absolutely (rather than reversing relative to the
+  //    emitted sense) is what makes this winding-agnostic: a CW-wound cut tool
+  //    makes replicad emit the hole loop with the opposite sense, and a relative
+  //    reversal would double-flip it back to a positive area — misbucketing the
+  //    hole as a second outer (409/2-regions/0-holes instead of 391/1/1).
+  const drawingRegionRings = (drawing) => {
+    const rings = drawing.toSVGPaths().flat(Infinity)
+      .flatMap((d) => svgPathToRings(d, SHAPE2D_SEGS))
+      .map((ring) => ring.map(([x, y]) => [x, -y]));
+    const containedBy = rings.map((r, i) =>
+      rings.reduce((n, other, j) => (i !== j && pointInRing(r[0], other) ? n + 1 : n), 0));
+    return rings.map((r, i) => {
+      const wantOuter = containedBy[i] % 2 === 0;                 // even depth = outer
+      return (ringArea(r) >= 0) === wantOuter ? r : r.slice().reverse();
+    });
+  };
+  const wrapShape2d = (drawing) => {
+    const toRegions = () => assembleRegions(drawingRegionRings(drawing));
+    return addShape2dSugar({
+      _drawing: drawing,
+      _shape2d: true,
+      union:     (o) => wrapShape2d(drawing.clone().fuse(liftDrawing(o)._drawing.clone())),
+      cut:       (o) => wrapShape2d(drawing.clone().cut(liftDrawing(o)._drawing.clone())),
+      cutAll:    (os) => wrapShape2d(os.map(liftDrawing).reduce((acc, t) => acc.cut(t._drawing.clone()), drawing.clone())),
+      intersect: (o) => wrapShape2d(drawing.clone().intersect(liftDrawing(o)._drawing.clone())),
+      // corners map onto replicad's Offset2DConfig.lineJoinType; "chamfer" → "bevel", a
+      // true 45° corner cut (a straight chord). Manifold now matches this via a
+      // single-chord Round join (see manifold-backend offset) — the two agree to float
+      // precision for convex corners with interior angle ≥ 90°; at acute (<90°) corners
+      // Manifold uses a 2-facet approximation that departs slightly. See KERNEL-CONTRACT.
+      offset: (delta, { corners = "round" } = {}) => {
+        const lineJoinType = { round: "round", chamfer: "bevel", sharp: "miter" }[corners];
+        if (!lineJoinType) throw new Error('Shape2D.offset: corners must be "round" | "chamfer" | "sharp"');
+        if (!Number.isFinite(delta)) throw new Error("Shape2D.offset: delta must be a finite number");
+        const result = drawing.clone().offset(delta, { lineJoinType });   // clone — replicad consumes the operand
+        // Collapse doesn't throw and Drawing has no public `blueprints` array (that's on
+        // Blueprints/CompoundBlueprint, not Drawing) — replicad instead returns a Drawing
+        // whose private `innerShape` is null (confirmed by probe). That's the collapse signal.
+        // NB: `innerShape` is replicad-internal; the "collapse throws immediately (OCCT)" test
+        // guards this — a replicad upgrade that renames it must keep that test green.
+        if (!result || !result.innerShape)
+          throw new Error("Shape2D.offset: offset collapses the shape (reduce |delta|)");
+        return wrapShape2d(result);
+      },
+      area: () => regionsArea(toRegions()),                 // no native Drawing area → derive from materialized regions
+      boundingBox: () => { const b = drawing.boundingBox; return { min: [b.bounds[0][0], b.bounds[0][1]], max: [b.bounds[1][0], b.bounds[1][1]] }; },
+      toRegions,
+      clone: () => wrapShape2d(drawing.clone()),
+    });
+  };
+  const shape2d = (profile) => (profile && profile._shape2d ? profile : wrapShape2d(drawingFromProfile(profile)));
+
   // extrude a 2-D polygon from z=0 (arguments validated by the kernel front)
   const prism = (pts, h, { twist = 0, scaleTop = 1 } = {}) => {
     const sketch = contourDrawing(pts).sketchOnPlane("XY");
@@ -113,15 +204,17 @@ export function createOcctKernel(replicad) {
   };
 
   // revolve a lathe profile [[r,z],…] around the Z axis (degrees defaults to 360)
-  const revolve = (pts, { degrees = 360 } = {}) =>
-    wrap(contourDrawing(pts).sketchOnPlane("XZ").revolve([0, 0, 1], { angle: degrees }));
+  const revolve = (pts, { degrees = 360 } = {}) => {
+    const region = pts && pts._shape2d ? pts._drawing.clone() : contourDrawing(pts);
+    return wrap(region.sketchOnPlane("XZ").revolve([0, 0, 1], { angle: degrees }));
+  };
 
   // extrude a polygon-with-holes region from z=0: cut each hole Drawing out of the outer
   // Drawing (winding-agnostic 2-D boolean), sketch it, then extrude (twist/taper via cfg).
+  // A Shape2D `profile` (already a Drawing, possibly multi-region) extrudes directly off
+  // its own `_drawing` (cloned — replicad booleans/extrude consume their operand).
   const extrude = (profile, h, { twist = 0, scaleTop = 1 } = {}) => {
-    const { outer, holes } = normalizeProfile(profile);
-    let region = contourDrawing(outer);
-    for (const hole of holes) region = region.cut(contourDrawing(hole));
+    const region = profile && profile._shape2d ? profile._drawing.clone() : drawingFromProfile(profile);
     const sketch = region.sketchOnPlane("XY");
     if (twist === 0 && scaleTop === 1) return wrap(sketch.extrude(h));
     const cfg = {};
@@ -180,6 +273,7 @@ export function createOcctKernel(replicad) {
       solids.map((s) => s._s).reduce((a, b) => a.fuse(b)),
       solids.flatMap((s) => cloneLabels(s._labels ?? []))
     ),
+    shape2d,
     toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._s }))).arrayBuffer(),
   });
 }

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

@@ -145,6 +145,10 @@ export const KERNEL_OP_SPECS = {
   prism:    { toArgs: prismArgs, check: checkScaleTop("prism") },
   extrude:  { toArgs: extrudeArgs, check: checkScaleTop("extrude") },
   revolve:  { toArgs: revolveArgs, check: (pts) => {
+    if (pts && pts._shape2d) {
+      if (pts.boundingBox().min[0] < 0) throw new Error("revolve: profile radius must be ≥ 0");
+      return;
+    }
     for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
   } },
   loft:     { toArgs: loftArgs },

package/src/framework/geometry/polygon.js

@@ -156,6 +156,32 @@ export function filletPolygon(points, r, { segs = 8 } = {}) {
   return out;
 }
 
+// Fluent builder for a curve-native path contour { start, segments }. Segment kinds:
+// lineTo → {to}, arcTo → {to,via} (three-point arc), cubicTo → {to,c1,c2} (cubic Bézier).
+// close() returns the plain contour object (feeds extrude/revolve/prism), not a Solid.
+export function pathProfile(start) {
+  const fin2 = (p, what) => {
+    if (!Array.isArray(p) || p.length < 2 || !Number.isFinite(p[0]) || !Number.isFinite(p[1]))
+      throw new Error(`pathProfile: ${what} must be a finite [x,y]`);
+    return [p[0], p[1]];
+  };
+  const s = fin2(start, "start");
+  const segments = [];
+  const api = {
+    lineTo(to) { segments.push({ to: fin2(to, "lineTo point") }); return api; },
+    arcTo(to, via) { segments.push({ to: fin2(to, "arcTo point"), via: fin2(via, "arcTo via") }); return api; },
+    cubicTo(to, c1, c2) {
+      segments.push({ to: fin2(to, "cubicTo point"), c1: fin2(c1, "cubicTo c1"), c2: fin2(c2, "cubicTo c2") });
+      return api;
+    },
+    close() {
+      if (segments.length < 1) throw new Error("pathProfile: need ≥1 segment before close()");
+      return { start: [s[0], s[1]], segments: segments.slice() }; // snapshot — chaining after close() must not mutate the returned contour
+    },
+  };
+  return api;
+}
+
 // Arc-aware sibling of filletPolygon: rounds the corners of a CCW polygon with the SAME
 // tangent/centre/sweep math (via cornerArc), but instead of tessellating each arc into
 // line facets it emits a canonical ArcContour { start, segments:[{to}|{to,via}], arc:true }

package/src/framework/geometry/profile.js

@@ -1,23 +1,37 @@
 // Backend-shared 2-D region normalization + tessellation for extrude()/prism(). A contour
-// is EITHER a bare points array (legacy, all straight edges) OR a canonical ArcContour
-// { start:[x,y], segments:[{to}|{to,via}], arc:true } carrying true circular arcs (from
-// roundedProfile). normalizeProfile validates the polymorphic { outer, holes } envelope
-// (bare array = outer only), preserving each contour's shape; tessellateProfile turns the
-// arcs into point rings for the Manifold (mesh) path. The OCCT path consumes the same
-// ArcContour directly (contourDrawing → threePointsArcTo) for true CIRCLE B-rep edges.
-// Legacy point-array contours take the exact former path byte-for-byte — no cache-busting.
+// is EITHER a bare points array (legacy, all straight edges) OR a canonical path contour
+// { start:[x,y], segments:[{to}|{to,via}|{to,c1,c2}] } carrying true circular arcs ({to,via},
+// from roundedProfile) and/or cubic Béziers ({to,c1,c2}, from pathProfile). normalizeProfile
+// validates the polymorphic { outer, holes } envelope (bare array = outer only), preserving
+// each contour's shape; tessellateProfile turns arcs/cubics into point rings for the Manifold
+// (mesh) path at the mesh LOD. The OCCT path consumes the same contour directly (contourDrawing
+// → threePointsArcTo / cubicBezierCurveTo) for true CIRCLE / B-spline B-rep edges. Legacy
+// point-array contours take the exact former path byte-for-byte — no cache-busting.
 
 // An ArcContour is a non-array object carrying arcs symbolically.
 export function isArcContour(c) {
   return !!c && typeof c === "object" && !Array.isArray(c) && (c.arc === true || Array.isArray(c.segments));
 }
 
+// Curves generalize arcs; the symbolic-form predicate is the same. Prefer this name.
+export const isPathContour = isArcContour;
+
 function validateContour(c, role) {
   if (isArcContour(c)) {
     if (!Array.isArray(c.start) || c.start.length < 2)
       throw new Error(`extrude: ${role} arc contour needs a start [x,y]`);
     if (!Array.isArray(c.segments) || c.segments.length < 1)
       throw new Error(`extrude: ${role} arc contour needs ≥1 segment`);
+    for (const s of c.segments) {
+      const hasCubic = s.c1 != null || s.c2 != null;
+      if (hasCubic) {
+        if (s.via != null)
+          throw new Error(`extrude: ${role} segment cannot mix arc (via) and cubic (c1/c2)`);
+        const ok = (p) => Array.isArray(p) && p.length >= 2 && Number.isFinite(p[0]) && Number.isFinite(p[1]);
+        if (!ok(s.c1) || !ok(s.c2))
+          throw new Error(`extrude: ${role} cubic segment needs c1 and c2 as finite [x,y]`);
+      }
+    }
     return;
   }
   if (!Array.isArray(c) || c.length < 3) throw new Error(`extrude: ${role} needs ≥3 points`);
@@ -73,15 +87,50 @@ export function sampleArc(p0, via, p1, segs) {
   return out;
 }
 
+// Flatten the cubic Bézier (p0,c1,c2,p1) into points p1…pN — EXCLUDING the start
+// p0 (the ring already holds it), last point pinned exactly to p1. Adaptive: split
+// at t=½ (de Casteljau) until the control polygon's total unsigned turn is ≤ 2π/segs
+// — the exact generalization of sampleArc's "a point every 2π/segs of sweep", so a
+// cubic tracing a circular arc facets like the arc primitive at the same segs. Summing
+// |turn| at BOTH interior control points also catches S-curves a pure endpoint-tangent
+// test would miss. Depth cap guarantees termination. Pure in (args, segs).
+export function sampleBezier(p0, c1, c2, p1, segs) {
+  const maxTurn = (2 * Math.PI) / Math.max(3, segs);
+  const out = [];
+  const mid = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+  const turn = (u, v) => {
+    const du = Math.hypot(u[0], u[1]), dv = Math.hypot(v[0], v[1]);
+    if (du < 1e-12 || dv < 1e-12) return 0;
+    let c = (u[0] * v[0] + u[1] * v[1]) / (du * dv);
+    if (c > 1) c = 1; else if (c < -1) c = -1;
+    return Math.acos(c);
+  };
+  const recurse = (a, b, c, d, depth) => {
+    const ab = [b[0] - a[0], b[1] - a[1]];
+    const bc = [c[0] - b[0], c[1] - b[1]];
+    const cd = [d[0] - c[0], d[1] - c[1]];
+    if (depth >= 12 || turn(ab, bc) + turn(bc, cd) <= maxTurn) { out.push([d[0], d[1]]); return; }
+    const p01 = mid(a, b), p12 = mid(b, c), p23 = mid(c, d);
+    const p012 = mid(p01, p12), p123 = mid(p12, p23), m = mid(p012, p123);
+    recurse(a, p01, p012, m, depth + 1);
+    recurse(m, p123, p23, d, depth + 1);
+  };
+  recurse(p0, c1, c2, p1, 0);
+  if (out.length === 0) out.push([p1[0], p1[1]]);
+  out[out.length - 1] = [p1[0], p1[1]];   // pin the exact endpoint
+  return out;
+}
+
 // Tessellate a single contour into a CCW point ring. A legacy array is returned unchanged
-// (identical to the former path); an ArcContour is walked start→segment→segment, lines
-// pushing their `to` and arcs pushing their sampled points.
+// (identical to the former path); a path contour is walked start→segment→segment, lines
+// pushing their `to`, arcs and cubics pushing their sampled points (sampleArc/sampleBezier).
 export function tessellateContour(contour, segs) {
   if (Array.isArray(contour)) return contour;
   const ring = [[contour.start[0], contour.start[1]]];
   let prev = contour.start;
   for (const seg of contour.segments) {
-    if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) ring.push(p);
+    if (seg.c1) for (const p of sampleBezier(prev, seg.c1, seg.c2, seg.to, segs)) ring.push(p);
+    else if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) ring.push(p);
     else ring.push([seg.to[0], seg.to[1]]);
     prev = seg.to;
   }

package/src/framework/geometry/shape2d-regions.js

@@ -0,0 +1,134 @@
+// Pure (WASM-free) helpers for materializing a 2-D boolean result into region
+// arrays. assembleRegions groups a flat set of point-rings into {outer,holes}
+// regions by winding + point-in-polygon nesting. svgPathToRings discretizes a
+// replicad Drawing's SVG path (from toSVGPathD) into rings, reusing F1's
+// sampleBezier / sampleArc so an OCCT-materialized curve facets like Manifold.
+import { sampleBezier } from "./profile.js";
+
+// Signed shoelace area of a ring (CCW positive). Exported (in addition to its use
+// below) for the OCCT backend's absolute outer/hole orientation — see
+// occt-backend.js's drawingRegionRings.
+export function ringArea(p) {
+  let a = 0;
+  for (let i = 0; i < p.length; i++) { const [x1, y1] = p[i], [x2, y2] = p[(i + 1) % p.length]; a += x1 * y2 - x2 * y1; }
+  return a / 2;
+}
+
+// Ray-cast point-in-polygon (even-odd). ring: [[x,y],…]. Exported (in addition to
+// its use below) for the OCCT backend's containment-based outer/hole classification
+// — see occt-backend.js's drawingRegionRings for why sign-based classification
+// (this module's own convention, below) doesn't hold for replicad's SVG output.
+export function pointInRing([px, py], ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const [xi, yi] = ring[i], [xj, yj] = ring[j];
+    if ((yi > py) !== (yj > py) && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+
+// Group rings: positive-area rings are outers, negative-area are holes; nest each
+// hole into the smallest-area outer that contains its first vertex.
+export function assembleRegions(rings) {
+  const outers = [], holes = [];
+  for (const r of rings) {
+    if (r.length < 3) continue;
+    (ringArea(r) >= 0 ? outers : holes).push(r);
+  }
+  const regions = outers.map((outer) => ({ outer, holes: [] }));
+  regions.sort((a, b) => Math.abs(ringArea(a.outer)) - Math.abs(ringArea(b.outer)));
+  for (const hole of holes) {
+    const home = regions.find((rg) => pointInRing(hole[0], rg.outer));
+    if (home) home.holes.push(hole);
+  }
+  // largest-first for a stable, readable order
+  regions.sort((a, b) => Math.abs(ringArea(b.outer)) - Math.abs(ringArea(a.outer)));
+  return regions;
+}
+
+// Net area of assembled regions: Σ|outer| − Σ|holes|.
+export function regionsArea(regions) {
+  let a = 0;
+  for (const rg of regions) {
+    a += Math.abs(ringArea(rg.outer));
+    for (const hole of rg.holes) a -= Math.abs(ringArea(hole));
+  }
+  return a;
+}
+
+// Sample an SVG elliptical-arc segment (endpoint parameterization → center form,
+// W3C SVG 1.1 notes F.6) from `from` to `to` into points AFTER `from` (last pinned
+// to `to`), honoring rx/ry/x-rotation and the large-arc/sweep flags. Exact for the
+// semicircle case a three-point circle fit degenerates on.
+function sampleSvgArc(from, rx, ry, rotDeg, largeArc, sweep, to, segs) {
+  const [x1, y1] = from, [x2, y2] = to;
+  if (rx === 0 || ry === 0) return [[x2, y2]];
+  const phi = (rotDeg * Math.PI) / 180, cosP = Math.cos(phi), sinP = Math.sin(phi);
+  const dx = (x1 - x2) / 2, dy = (y1 - y2) / 2;
+  const x1p = cosP * dx + sinP * dy, y1p = -sinP * dx + cosP * dy;
+  let RX = Math.abs(rx), RY = Math.abs(ry);
+  const lambda = (x1p * x1p) / (RX * RX) + (y1p * y1p) / (RY * RY);
+  if (lambda > 1) { const s = Math.sqrt(lambda); RX *= s; RY *= s; }
+  const numr = RX * RX * RY * RY - RX * RX * y1p * y1p - RY * RY * x1p * x1p;
+  const den = RX * RX * y1p * y1p + RY * RY * x1p * x1p;
+  let coef = Math.sqrt(Math.max(0, numr / den));
+  if (Boolean(largeArc) === Boolean(sweep)) coef = -coef;
+  const cxp = (coef * RX * y1p) / RY, cyp = (-coef * RY * x1p) / RX;
+  const cx = cosP * cxp - sinP * cyp + (x1 + x2) / 2;
+  const cy = sinP * cxp + cosP * cyp + (y1 + y2) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const dot = ux * vx + uy * vy, len = Math.hypot(ux, uy) * Math.hypot(vx, vy) || 1e-12;
+    let a = Math.acos(Math.min(1, Math.max(-1, dot / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / RX, (y1p - cyp) / RY);
+  let dTheta = angle((x1p - cxp) / RX, (y1p - cyp) / RY, (-x1p - cxp) / RX, (-y1p - cyp) / RY);
+  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
+  if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
+  const steps = Math.max(2, Math.ceil((segs * Math.abs(dTheta)) / (2 * Math.PI)));
+  const out = [];
+  for (let i = 1; i <= steps; i++) {
+    const t = theta1 + dTheta * (i / steps);
+    const ex = RX * Math.cos(t), ey = RY * Math.sin(t);
+    out.push([cx + cosP * ex - sinP * ey, cy + sinP * ex + cosP * ey]);
+  }
+  out[out.length - 1] = [x2, y2];
+  return out;
+}
+
+// Minimal SVG-path tokenizer for the absolute commands replicad emits: M, L, C,
+// Q, A, Z. Coordinates are numbers separated by spaces or commas; a command may
+// be followed by several coordinate sets (implicit repeat). One subpath (M…Z) →
+// one ring; the start point is not duplicated. Throws on unsupported commands.
+export function svgPathToRings(d, segs) {
+  const toks = d.match(/[a-zA-Z]|-?\d*\.?\d+(?:e[-+]?\d+)?/g) ?? [];
+  const rings = [];
+  let ring = null, cur = [0, 0], cmd = null, i = 0;
+  const num = () => Number(toks[i++]);
+  const pt = () => [num(), num()];
+  const pushRing = () => { if (ring && ring.length >= 3) rings.push(ring); ring = null; };
+  while (i < toks.length) {
+    if (/^[a-zA-Z]$/.test(toks[i])) {
+      cmd = toks[i++];
+      if (!"MLCQAZ".includes(cmd)) throw new Error(`svgPathToRings: unsupported SVG command "${cmd}"`);
+    }
+    if (cmd === "M") { pushRing(); cur = pt(); ring = [cur.slice()]; cmd = "L"; }
+    else if (cmd === "L") { cur = pt(); ring.push(cur.slice()); }
+    else if (cmd === "C") { const c1 = pt(), c2 = pt(), end = pt(); for (const p of sampleBezier(cur, c1, c2, end, segs)) ring.push(p); cur = end; }
+    else if (cmd === "Q") {
+      const q = pt(), end = pt();
+      const c1 = [cur[0] + (2 / 3) * (q[0] - cur[0]), cur[1] + (2 / 3) * (q[1] - cur[1])];
+      const c2 = [end[0] + (2 / 3) * (q[0] - end[0]), end[1] + (2 / 3) * (q[1] - end[1])];
+      for (const p of sampleBezier(cur, c1, c2, end, segs)) ring.push(p); cur = end;
+    }
+    else if (cmd === "A") {
+      const rx = num(), ry = num(), rot = num(), large = num(), sweep = num(), end = pt();
+      for (const p of sampleSvgArc(cur, rx, ry, rot, large, sweep, end, segs)) ring.push(p); cur = end;
+    }
+    else if (cmd === "Z") { pushRing(); cmd = null; }
+    else throw new Error("svgPathToRings: coordinate before or after a command");
+  }
+  pushRing();
+  return rings;
+}

package/src/framework/geometry/shape2d-sugar.js

@@ -0,0 +1,11 @@
+// Backend-shared Shape2D front. Like solid-sugar for Solids, but the 2-D shared
+// surface is small: .simple() unwraps a single-region materialization or throws.
+// Backends attach the geometry ops (booleans, area, boundingBox, toRegions).
+export function addShape2dSugar(s) {
+  s.simple = () => {
+    const regions = s.toRegions();
+    if (regions.length !== 1) throw new Error(`Shape2D.simple: result has ${regions.length} regions, not 1 (use toRegions())`);
+    return regions[0];
+  };
+  return s;
+}

package/src/parts/demo.js

@@ -49,7 +49,7 @@ export default {
       export: { name: "spacer" },
       build: (k, p, d) => {
         let s = k.cylinder({ d: p.od, h: p.h });
-        if (p.flange_d > 0) s = k.union([s, k.cylinder({ d: p.flange_d, h: p.flange_h })]);
+        if (p.flange_d > 0) s = s.union(k.cylinder({ d: p.flange_d, h: p.flange_h }));
         return s.cut(k.cylinder({ r: d.boreR, h: d.cutH }).at([0, 0, -2]));
       },
     },