partforge 0.55.0 → 0.56.0

package/src/framework/geometry/curve-fill.js

@@ -7,65 +7,7 @@
 //   2. CompoundPath of all the simple sub-paths;
 //   3. set the font's nonzero/evenodd rule;
 //   4. unite(self) to normalize overlaps and crossings into simple paths.
-import paper from "paper/dist/paper-core.js";
-
-// Lazy, private PaperScope: built on first use (not at module load), so parts that never
-// call k.text2d don't pull paper-core's setup onto the geometry worker. Never paper's
-// package-global project — another consumer in the same worker may import paper too.
-let _scope = null;
-function paperScope() {
-  if (!_scope) { _scope = new paper.PaperScope(); _scope.setup(new _scope.Size(1, 1)); }
-  return _scope;
-}
-
-function toPaperPath(scope, contour) {
-  const path = new scope.Path({ insert: false });
-  path.moveTo(new scope.Point(contour.start[0], contour.start[1]));
-  for (const s of contour.segments) {
-    if (s.c1) path.cubicCurveTo(
-      new scope.Point(s.c1[0], s.c1[1]),
-      new scope.Point(s.c2[0], s.c2[1]),
-      new scope.Point(s.to[0], s.to[1]));
-    else path.lineTo(new scope.Point(s.to[0], s.to[1]));
-  }
-  path.closePath();
-  return path;
-}
-
-function toContour(path) {
-  const segs = path.segments;
-  const start = [segs[0].point.x, segs[0].point.y];
-  const out = { start, segments: [] };
-  for (let i = 0; i < segs.length; i++) {
-    const a = segs[i], b = segs[(i + 1) % segs.length];
-    const straight = a.handleOut.isZero() && b.handleIn.isZero();
-    const closing = i === segs.length - 1;
-    if (closing && straight) continue;                 // implicit straight close
-    const to = [b.point.x, b.point.y];
-    if (straight) out.segments.push({ to });
-    else out.segments.push({ to, c1: [a.point.x + a.handleOut.x, a.point.y + a.handleOut.y], c2: [b.point.x + b.handleIn.x, b.point.y + b.handleIn.y] });
-  }
-  return out;
-}
-
-// Group while paths are still Paper geometry. Path.area includes cubic handles and
-// interiorPoint is guaranteed to lie inside the curve; never reduce curves to endpoint rings.
-function groupPaperPaths(paths) {
-  const largest = paths.reduce((a, b) => Math.abs(b.area) > Math.abs(a.area) ? b : a);
-  const outerClockwise = largest.clockwise;
-  const outers = paths.filter((p) => p.clockwise === outerClockwise)
-    .map((path) => ({ path, holes: [] }));
-  for (const hole of paths.filter((p) => p.clockwise !== outerClockwise)) {
-    const home = outers.filter((o) => o.path.contains(hole.interiorPoint))
-      .sort((a, b) => Math.abs(a.path.area) - Math.abs(b.path.area))[0];
-    if (!home) throw new Error("curve-fill: resolved hole has no containing outer");
-    home.holes.push(hole);
-  }
-  return outers.map(({ path, holes }) => ({
-    outer: toContour(path),
-    holes: holes.map(toContour),
-  }));
-}
+import { paperScope, toPaperPath, groupPaperPaths } from "./paper-bridge.js";
 
 export function resolveCurveFill(contours, { fillRule = "nonzero" } = {}) {
   if (fillRule !== "nonzero" && fillRule !== "evenodd")

package/src/framework/geometry/kernel.js

@@ -44,9 +44,13 @@ export const SOLID_OPS = [
 export const SOLID_OPTIONAL_OPS = ["genus", "isEmpty"];
 
 // Public methods every Shape2D exposes (2-D boolean value; contract-linted).
+// One shared implementation backs both backends (geometry/shape2d.js) — storage is
+// the curve-native contour IR, so booleans/transforms/queries are backend-identical
+// and only `offset` routes into the backend's own 2-D engine.
 export const SHAPE2D_OPS = [
   "union", "cut", "cutAll", "intersect", "offset", "area", "boundingBox", "toRegions", "simple", "regions", "clone",
   "extrude", "revolve",
+  "translate", "rotate", "scale", "mirror", "toContours", "fillet", "chamfer", "simplify", "corners", "contains",
 ];
 
 // Solid ops only OCCT implements natively. Single source of truth: probe.js routes
@@ -85,16 +89,30 @@ 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.
+ * @typedef {Object} Shape2D  A 2-D boolean value. ONE shared implementation on both backends: storage is the curve-native contour IR (arcs/cubics survive every op), so results are backend-identical except `offset`. `_`-prefixed keys are 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 {(delta:number, opts?:{corners?:"round"|"chamfer"|"sharp",segs?:number}) => Shape2D} offset   grow (+) / shrink (−) by delta; the one backend-specific op (Clipper2 vs OCCT) — throws when the shape collapses
+ * @property {() => number} area   net area (outers minus holes), mm² — curve-exact, not tessellated
+ * @property {() => {min:number[],max:number[]}} boundingBox   axis-aligned 2-D bounds (curve-exact)
+ * @property {() => {outer:number[][],holes:number[][][]}[]} toRegions   materialize into point-ring region arrays (tessellated at the backend's LOD)
  * @property {() => {outer:number[][],holes:number[][][]}} simple   toRegions(), unwrapped — throws unless exactly 1 region
- * @property {() => Shape2D} clone   independent handle
+ * @property {() => Shape2D[]} regions   scission: each disjoint region as its own Shape2D
+ * @property {() => {outer:object,holes:object[]}[]} toContours   the stored contour IR (curve-native, lossless) — a deep copy, safe to mutate
+ * @property {() => Shape2D} clone   independent copy
+ * @property {(v:number[]) => Shape2D} translate   translate by [dx,dy]
+ * @property {(deg:number, center?:number[]) => Shape2D} rotate   rotate about center (default origin)
+ * @property {(f:number|number[], center?:number[]) => Shape2D} scale   scale about center (default origin); a bare number scales uniformly, [sx,sy] scales each axis independently
+ * @property {(axis:"x"|"y"|{point:number[],dir:number[]}) => Shape2D} mirror   reflect across an axis line
+ * @property {(r:number|number[], opts?:{corners?:"all"|"convex"|"concave"|{indices:number[]}|{near:number[],count?:number}}) => Shape2D} fillet   round selected corners with true arcs
+ * @property {(d:number|number[], opts?:{corners?:"all"|"convex"|"concave"|{indices:number[]}|{near:number[],count?:number}}) => Shape2D} chamfer   bevel selected corners with straight chords
+ * @property {(tolerance:number) => Shape2D} simplify   corner-preserving decimation/refit within tolerance
+ * @property {() => {index:number,point:number[],interiorAngleDeg:number,convex:boolean,segTypes:string[]}[]} corners   corner list (the positional order fillet/chamfer `{indices}` index into)
+ * @property {(p:number[]) => boolean} contains   is point [x,y] inside the shape (holes excluded)
+ * @property {(o?:{h:number,twist?:number,scaleTop?:number}) => Solid} extrude   sugar for k.extrude({profile:this,…})
+ * @property {(o?:{degrees?:number}) => Solid} revolve   sugar for k.revolve({profile:this,…})
  *
  * @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
@@ -112,7 +130,7 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @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 {(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 {(profile: number[][]|{outer:number[][],holes?:number[][][]}|{start:number[],segments:object[]}|Shape2D) => Shape2D} shape2d   2-D boolean value; one shared contour-storage implementation on both backends
  * @property {(inputs: (Shape2D|number[][]|{start:number[],segments:object[]})[]) => Shape2D} hull   convex hull of all inputs → a convex Shape2D (faceted; pure-JS monotone chain)
  * @property {(inputs: (Shape2D|number[][]|{start:number[],segments:object[]})[]) => Shape2D} hullChain   swept hull over an ordered sequence (≥2): union of hull([inᵢ,inᵢ₊₁])
  * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only (Manifold throws KernelCapabilityError)

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

@@ -2,11 +2,11 @@ import { helixTube } from "./helix-tube.js";
 import { loftMesh } from "./loft.js";
 import { sweepMesh } from "./sweep.js";
 import { roundedBoxRings } from "./rounded-solids.js";
-import { tessellateContour, tessellateProfile } from "./profile.js";
+import { tessellateContour, tessellateProfile, pointsToContour } 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 { makeShape2dFactory } from "./shape2d.js";
 import { assembleRegions } from "./shape2d-regions.js";
 import { finishKernel } from "./kernel-front.js";
 import { meshToStl } from "./mesh-stl.js";
@@ -53,63 +53,70 @@ 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),
-  }, { shape2d, extrude: kernel.extrude, revolve: kernel.revolve });
-  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"));
-    });
+  // 2-D offset logic. This is the ONE op the shared Shape2D cannot do on the
+  // contour IR itself, so it is the backend's hook into the factory below (and
+  // is also published as k._offsetRegions). resolveOffsetJoin validates corners/delta and picks
+  // Clipper2's join type + segment count:
+  // 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 resolveOffsetJoin = (delta, corners, nSeg) => {
+    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");
+    return corners === "sharp" ? ["Miter", nSeg]
+      : corners === "chamfer" ? ["Round", 4]
+      : ["Round", nSeg];
+  };
+  // Run the offset op on a T-tracked CrossSection; throws the pinned collapse message.
+  const offsetCS = (cs, delta, joinType, 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;
   };
 
+  // Contour-IR region list -> flat point rings at `nSeg` (outer + holes, even/odd
+  // fill sorts them out). The one place the IR meets CrossSection.ofPolygons.
+  const regionPolys = (regions, nSeg) => regions.flatMap((rg) =>
+    [tessellateContour(rg.outer, nSeg), ...rg.holes.map((hl) => tessellateContour(hl, nSeg))]);
+
+  // Region-in / region-out offset: tessellate the contour IR at `nSeg`, build a
+  // CrossSection, run the shared offset logic above, then lift the resulting point
+  // rings back into line contours via pointsToContour. This is Shape2D.offset's
+  // engine (wired into the factory below) and is also published as k._offsetRegions.
+  const offsetRegions = (regions, delta, { corners = "round", segs: nSeg = segs } = {}) => {
+    const [joinType, cseg] = resolveOffsetJoin(delta, corners, nSeg);
+    const cs = T(CrossSection.ofPolygons(regionPolys(regions, nSeg), "EvenOdd"));
+    const out = offsetCS(cs, delta, joinType, cseg);
+    return assembleRegions(out.toPolygons()).map((rg) => ({
+      outer: pointsToContour(rg.outer),
+      holes: rg.holes.map(pointsToContour),
+    }));
+  };
+
+  // 2-D boolean value: the SHARED Shape2D (shape2d.js). Storage is the curve-native
+  // contour IR and every op but `offset` runs on it in pure JS — no CrossSection is
+  // built until a shape is handed to a kernel op. `extrude`/`revolve` are thunks
+  // because `kernel` below is defined after this.
+  const shape2d = makeShape2dFactory({
+    segs,
+    offsetRegions,
+    extrude: (o) => kernel.extrude(o),
+    revolve: (o) => kernel.revolve(o),
+  });
+  // Lazy CrossSection materialization, memoized through the solid cache by content
+  // hash + LOD: the same shape extruded twice (or extruded and revolved) tessellates
+  // once, and the cache's pin/dispose keeps the WASM object alive exactly as long as
+  // the entry (cleanup() skips pinned objects).
+  const csFor = (shape) => cache.lookup(h("cs2d", shape._hash, segs), () => {
+    const cs = T(CrossSection.ofPolygons(regionPolys(shape._regions, segs), "EvenOdd"));
+    return { value: cs, pin: cs, dispose: () => cs.delete?.() };
+  });
+
   // Copy the mesh out into JS-owned arrays (so it survives cleanup) and free the
   // transient mesh handle.
   function meshOut(m, asStl) {
@@ -270,13 +277,13 @@ 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).
-    // 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.
+    // A Shape2D `profile` (curve-native, possibly multi-region) materializes through
+    // csFor — one memoized tessellation per shape+LOD — 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 cs = shape ? csFor(shape) : (() => {
           const { outer, holes } = tessellateProfile(profile, segs);
           return T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
         })();
@@ -309,7 +316,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     helixSweptTube: (o) => cached(h("helixSweptTube", o, tube), () => T(helixTube(wasm, { ...o, ...tube }))),
     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._hash, degrees, segs), () => T(csFor(pts).revolve(segs, degrees)));
       return cached(h("revolve", pts, degrees, segs), () => T(Manifold.revolve([pts], segs, degrees)));
     },
     // A one-solid union is an identity — no new WASM / cache entry (avoids double-free):
@@ -319,6 +326,9 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       ? solids[0]
       : cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
     shape2d,
+    // Backend-internal region adapter: the same function Shape2D.offset runs on
+    // (defined above). `_`-prefixed — not part of the public kernel surface.
+    _offsetRegions: offsetRegions,
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     sweepCache: () => cache.sweep(),

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

@@ -18,14 +18,14 @@
 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 { makeShape2dFactory } from "./shape2d.js";
+import { assembleRegions, svgPathToContours, pointInRing, ringArea } from "./shape2d-regions.js";
 import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
 import { resolveRings } from "./loft.js";
 import { resolveSweepStations } from "./sweep.js";
-import { normalizeProfile } from "./profile.js";
+import { normalizeProfile, tessellateContour, reverseContour } from "./profile.js";
 import { roundedRectContour } from "./rounded-solids.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
@@ -318,96 +318,129 @@ export function createOcctKernel(replicad) {
     return pen.close();
   };
 
+  // Shape2D's tessellation LOD: the segment count toRegions()/simple() discretize
+  // curve contours at. 64 preserves the LOD the Drawing-backed Shape2D materialized
+  // at, so toRegions() output keeps the resolution parts already depend on.
+  const SHAPE2D_SEGS = 64;
   // 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):
+  // Region list -> fused Drawing: draw each region's outer contour, cut its holes
+  // out, then fuse every region together — the multi-region generalization of
+  // drawingFromProfile above. Used by _offsetRegions to materialize an arbitrary
+  // region LIST (not a single { outer, holes }) into one Drawing to offset, and by
+  // extrude/revolve to materialize a Shape2D's stored contours into a Drawing.
+  const drawingFromRegions = (regions) => regions.reduce((acc, rg) => {
+    let region = contourDrawing(rg.outer);
+    for (const hole of rg.holes) region = region.cut(contourDrawing(hole));
+    return acc ? acc.fuse(region) : region;
+  }, null);
+
+  // y-negate a whole contour (start + every segment's to/via/c1/c2): toSVGPathD()
+  // renders in SVG's y-down convention, so everything read back out of a Drawing
+  // via SVG paths must be negated back into model space.
+  const negateContourY = (c) => ({
+    start: [c.start[0], -c.start[1]],
+    segments: c.segments.map((s) => {
+      const m = { to: [s.to[0], -s.to[1]] };
+      if (s.via) m.via = [s.via[0], -s.via[1]];
+      if (s.c1) { m.c1 = [s.c1[0], -s.c1[1]]; m.c2 = [s.c2[0], -s.c2[1]]; }
+      return m;
+    }),
+  });
+
+  // Classify + nest a flat list of curve-native contours into a region list.
   //
-  // 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) => {
+  // Drawing.toSVGPaths() nests 0-2 levels deep depending on the result shape,
+  // INCONSISTENTLY (a single interior hole nests as [[outerD, holeD]], but two
+  // disjoint holes from sequential .cut() calls come back flat), so array position
+  // carries no outer/hole signal. Neither does winding: unlike Manifold's
+  // CrossSection.toPolygons() (outer CCW, hole CW), replicad emits EVERY loop of a
+  // region with the same rotational sense. The one signal that IS reliable is
+  // geometric containment DEPTH: count how many OTHER contours contain a sample
+  // point, then force each contour's winding to match its depth parity ABSOLUTELY
+  // (even depth = outer/CCW, odd = hole/CW) via reverseContour — setting it
+  // absolutely rather than reversing relative to the emitted sense is what makes
+  // this winding-agnostic. The now-correctly-signed tessellations then go to
+  // assembleRegions for the actual smallest-containing-outer nesting, reusing that
+  // logic rather than reimplementing it. 32-segment sampling (vs. SHAPE2D_SEGS=64)
+  // is plenty for classification, which only needs containment and area sign.
+  const OFFSET_CLASSIFY_SEGS = 32;
+  const groupOffsetContours = (contours) => {
+    const samples = contours.map((c) => tessellateContour(c, OFFSET_CLASSIFY_SEGS));
+    const containedBy = contours.map((_, i) =>
+      samples.reduce((n, ring, j) => (i !== j && pointInRing(samples[i][0], ring) ? n + 1 : n), 0));
+    const oriented = contours.map((c, i) => {
       const wantOuter = containedBy[i] % 2 === 0;                 // even depth = outer
-      return (ringArea(r) >= 0) === wantOuter ? r : r.slice().reverse();
+      const isCCW = ringArea(samples[i]) >= 0;
+      return isCCW === wantOuter
+        ? { contour: c, ring: samples[i] }
+        : { contour: reverseContour(c), ring: samples[i].slice().reverse() };
     });
+    const byRing = new Map(oriented.map(({ contour, ring }) => [ring, contour]));
+    const regions = assembleRegions(oriented.map(({ ring }) => ring));
+    return regions.map((rg) => ({ outer: byRing.get(rg.outer), holes: rg.holes.map((ring) => byRing.get(ring)) }));
   };
-  // Shape2D carries a content hash (so a Solid op over a profile can key on it)
-  // but stays UNCACHED — Drawings already clone before every consuming replicad
-  // call, and 2-D booleans are cheap next to the B-rep work they feed.
-  const wrapShape2d = (drawing, hash) => {
-    const toRegions = () => assembleRegions(drawingRegionRings(drawing));
-    return addShape2dSugar({
-      _drawing: drawing,
-      _shape2d: true,
-      _hash: hash,
-      union:     (o) => { const t = liftDrawing(o); return wrapShape2d(drawing.clone().fuse(t._drawing.clone()), h("union2d", hash, t._hash)); },
-      cut:       (o) => { const t = liftDrawing(o); return wrapShape2d(drawing.clone().cut(t._drawing.clone()), h("cut2d", hash, t._hash)); },
-      cutAll:    (os) => {
-        const ts = os.map(liftDrawing);
-        return wrapShape2d(ts.reduce((acc, t) => acc.cut(t._drawing.clone()), drawing.clone()), h("cutAll2d", hash, ts.map((t) => t._hash)));
-      },
-      intersect: (o) => { const t = liftDrawing(o); return wrapShape2d(drawing.clone().intersect(t._drawing.clone()), h("intersect2d", hash, t._hash)); },
-      // 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, h("offset2d", hash, delta, corners));
-      },
-      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(), hash),
-    }, { shape2d, extrude: kernel.extrude, revolve: kernel.revolve });
+
+  // Offset logic (corners validation, replicad Offset2DConfig join-type mapping,
+  // collapse detection via `innerShape`), Drawing-in/Drawing-out. This is the ONE
+  // op the shared Shape2D cannot do on the contour IR itself — offsetRegions below
+  // wraps it as the backend's hook. corners map onto replicad's Offset2DConfig
+  // lineJoinType; "chamfer" -> "bevel", a true 45° bevel — 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.
+  const offsetDrawing = (drawing, delta, corners) => {
+    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");
+    // No clone: offset CONSUMES its operand, and the sole caller (offsetRegions) hands
+    // in a Drawing it just built from the contour IR, owned by nobody else.
+    const result = drawing.offset(delta, { lineJoinType });
+    // 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 result;
   };
-  const shape2d = (profile) => (profile && profile._shape2d ? profile : wrapShape2d(drawingFromProfile(profile), h("shape2d", profile)));
+  // Region-in / region-out offset: fuse the region list into one Drawing, run the
+  // shared offset logic, then read the curve-native result back via SVG paths —
+  // y-negate (toSVGPathD is y-down), svgPathToContours per subpath (curves survive
+  // as cubics, no facet fan), then classify/orient/nest via groupOffsetContours.
+  // This is Shape2D.offset's engine (wired into the factory below) and is also
+  // published as k._offsetRegions.
+  const offsetRegions = (regions, delta, { corners = "round" } = {}) => {
+    const result = offsetDrawing(drawingFromRegions(regions), delta, corners);
+    const contours = result.toSVGPaths().flat(Infinity)
+      .flatMap((d) => svgPathToContours(d).map(negateContourY));
+    return groupOffsetContours(contours);
+  };
+  // 2-D boolean value: the SHARED Shape2D (shape2d.js), identical to the Manifold
+  // backend's. Storage is the curve-native contour IR and every op but `offset`
+  // runs on it in pure JS, so no Drawing exists until a shape is handed to a
+  // kernel op. `extrude`/`revolve` are thunks because `kernel` is defined below.
+  const shape2d = makeShape2dFactory({
+    segs: SHAPE2D_SEGS,
+    offsetRegions,
+    extrude: (o) => kernel.extrude(o),
+    revolve: (o) => kernel.revolve(o),
+  });
+  // Lazy Drawing materialization for the kernel ops that need one. drawingFromRegions
+  // draws a FRESH Drawing on every call, so callers never need to .clone() the result
+  // before handing it to a consuming replicad op.
+  // An empty shape (e.g. the intersection of two disjoint shapes) has no regions to
+  // draw; say so rather than letting the null reach replicad as a TypeError.
+  const drawingFor = (shape) => drawingFromRegions(shape._regions)
+    ?? (() => { throw new Error("Shape2D: the shape is empty — nothing to build"); })();
 
   // extrude a 2-D polygon from z=0 (arguments validated by the kernel front)
   const prism = (pts, hgt, { twist = 0, scaleTop = 1 } = {}) => {
@@ -426,19 +459,20 @@ export function createOcctKernel(replicad) {
   const revolve = (pts, { degrees = 360 } = {}) => {
     const key = h("revolve", pts && pts._shape2d ? pts._hash : pts, degrees);
     return cached(key, () => {
-      const region = pts && pts._shape2d ? pts._drawing.clone() : contourDrawing(pts);
+      const region = pts && pts._shape2d ? drawingFor(pts) : contourDrawing(pts);
       return wrap(region.sketchOnPlane("XZ").revolve([0, 0, 1], { angle: degrees }), [], key);
     });
   };
 
   // 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).
+  // A Shape2D `profile` (curve-native, possibly multi-region) materializes through
+  // drawingFor — a fresh Drawing per call, so no .clone() is needed before the
+  // sketch consumes it (replicad booleans/extrude consume their operand).
   const extrude = (profile, hgt, { twist = 0, scaleTop = 1 } = {}) => {
     const key = h("extrude", profile && profile._shape2d ? profile._hash : profile, hgt, twist, scaleTop);
     return cached(key, () => {
-      const region = profile && profile._shape2d ? profile._drawing.clone() : drawingFromProfile(profile);
+      const region = profile && profile._shape2d ? drawingFor(profile) : drawingFromProfile(profile);
       const sketch = region.sketchOnPlane("XY");
       if (twist === 0 && scaleTop === 1) return wrap(sketch.extrude(hgt), [], key);
       const cfg = {};
@@ -518,6 +552,9 @@ export function createOcctKernel(replicad) {
       });
     },
     shape2d,
+    // Backend-internal region adapter: the same function Shape2D.offset runs on
+    // (defined above). `_`-prefixed — not part of the public kernel surface.
+    _offsetRegions: offsetRegions,
     toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._mat()._s }))).arrayBuffer(),
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),